ldn: Added ldnSetProtocol.

* remove unused version number in Makefile
* add dist-src target using git tag

.doozer.json

@@ -1,34 +0,0 @@
-{
-  "targets": {
-    "lib": {
-
-      "buildenv": "docker:devkitpro/devkita64",
-
-      "buildcmd": [
-        "sudo -E make -j${PARALLEL} -C nx install"
-      ]
-    },
-
-    "docs": {
-       // Only invoke docs target when building from master branch
-      "branch": "master",
-
-      "buildenv": "xenial-amd64",
-      "builddeps": [
-        "doxygen"
-      ],
-
-      "buildcmd": [
-        "cd nx", "doxygen"
-      ],
-
-      "artifacts": [{
-        "source": "nx/docs/html",
-        "destination": {
-          "type": "git",
-          "branch": "gh-pages"
-        }
-      }]
-    }
-  }
-}

.github/workflows/build.yaml

@@ -0,0 +1,22 @@
+name: Build libnx
+
+on:
+  push:
+    branches:
+     - master
+  pull_request:
+
+jobs:
+  build:
+    name: Test build
+    runs-on: ubuntu-latest
+    container:
+      image: 'devkitpro/devkita64'
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: build
+        run: make -C nx -j$(nproc)

.github/workflows/doxygen.yaml

@@ -0,0 +1,39 @@
+name: Build documentation
+
+on:
+  push:
+    tags: [ v* ]
+
+jobs:
+  build:
+    name: Build documentation
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          persist-credentials: false
+
+      - name: Get current tag
+        id: vars
+        run: echo ::set-output name=tag::${GITHUB_REF/refs\/tags\//}
+
+      - name: Set up Doxygen
+        run: sudo apt-get install -y doxygen
+
+      - name: Display Doxygen version
+        run: echo "Doxygen version $(doxygen -v)"
+
+      - name: Build documentation
+        run: |
+               cd nx
+               LIBNX_VERSION=${{ steps.vars.outputs.tag }} doxygen Doxyfile
+
+      - name: Deploy 🚀
+        uses: JamesIves/github-pages-deploy-action@3.7.1
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          BRANCH: gh-pages
+          FOLDER: nx/docs/html
+          CLEAN: true
+          SINGLE_COMMIT: true

.gitignore

@@ -8,7 +8,10 @@
 *.pfs0
 Thumbs.db
 .*/
+!.github/
 debug/
 release/
 lib/
 docs/
+compile_commands.json
+.clangd

README.md

@@ -1,7 +1,7 @@
 # Nintendo Switch AArch64-only userland library.
 Based on libctru.
 
-[![Build status](https://doozer.io/badge/switchbrew/libnx/buildstatus/master)](https://doozer.io/switchbrew/libnx)
+![Build status](https://github.com/switchbrew/libnx/actions/workflows/build.yaml/badge.svg)
 
 # Install instructions
-See [Switchbrew](http://switchbrew.org/index.php?title=Setting_up_Development_Environment).
+See [Switchbrew](https://switchbrew.org/wiki/Setting_up_Development_Environment).

nx/Doxyfile

@@ -38,7 +38,7 @@ PROJECT_NAME           = "libnx"
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = "$(TRAVIS_TAG)"
+PROJECT_NUMBER         = "$(LIBNX_VERSION)"
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

nx/Makefile

@@ -8,13 +8,6 @@ endif
 
 include $(DEVKITPRO)/devkitA64/base_rules
 
-export LIBNX_MAJOR	:= 1
-export LIBNX_MINOR	:= 4
-export LIBNX_PATCH	:= 1
-
-
-VERSION	:=	$(LIBNX_MAJOR).$(LIBNX_MINOR).$(LIBNX_PATCH)
-
 #---------------------------------------------------------------------------------
 # TARGET is the name of the output
 # BUILD is the directory where object files & intermediate files will be placed
@@ -24,14 +17,14 @@ VERSION	:=	$(LIBNX_MAJOR).$(LIBNX_MINOR).$(LIBNX_PATCH)
 #---------------------------------------------------------------------------------
 TARGET		:=	nx
 #BUILD		:=	build
-SOURCES		:=	source/arm source/kernel source/services source/nvidia source/nvidia/ioctl source/nvidia/gpu source/display source/audio source/runtime source/runtime/devices source/runtime/util/utf
+SOURCES		:=	source/arm source/kernel source/sf source/services source/crypto source/nvidia source/nvidia/ioctl source/display source/audio source/applets source/runtime source/runtime/devices source/runtime/util source/runtime/util/utf
 DATA		:=	data
 INCLUDES	:=	include external/bsd/include
 
 #---------------------------------------------------------------------------------
 # options for code generation
 #---------------------------------------------------------------------------------
-ARCH	:=	-march=armv8-a -mtune=cortex-a57 -mtp=soft -fPIC -ftls-model=local-exec
+ARCH	:=	-march=armv8-a+crc+crypto -mtune=cortex-a57 -mtp=soft -fPIC -ftls-model=local-exec
 
 CFLAGS	:=	-g -Wall -Werror \
 			-ffunction-sections \
@@ -39,7 +32,7 @@ CFLAGS	:=	-g -Wall -Werror \
 			$(ARCH) \
 			$(BUILD_CFLAGS)
 
-CFLAGS	+=	$(INCLUDE) -DSWITCH
+CFLAGS	+=	$(INCLUDE) -D__SWITCH__ -DLIBNX_NO_DEPRECATION
 
 CXXFLAGS	:= $(CFLAGS) -fno-rtti -fno-exceptions -std=gnu++11
 
@@ -95,17 +88,14 @@ export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
 #---------------------------------------------------------------------------------
 all: lib/libnx.a lib/libnxd.a
 
-dist-bin: all
-	@tar --exclude=*~ -cjf libnx-$(VERSION).tar.bz2 include lib default_icon.jpg switch_rules switch.ld switch.specs -C external/bsd include 
+install: lib/libnx.a lib/libnxd.a
+	@mkdir -p $(DESTDIR)$(DEVKITPRO)/libnx
+	@cp -v default_icon.jpg switch_rules switch.ld switch.specs $(DESTDIR)$(DEVKITPRO)/libnx/
+	@cp -rv include lib $(DESTDIR)$(DEVKITPRO)/libnx/
+	@cp -rv external/bsd/include $(DESTDIR)$(DEVKITPRO)/libnx/
 
 dist-src:
-	@tar --exclude=*~ -cjf libnx-src-$(VERSION).tar.bz2 include source data external Makefile default_icon.jpg switch_rules switch.ld switch.specs
-
-dist: dist-src dist-bin
-
-install: dist-bin
-	mkdir -p $(DESTDIR)$(DEVKITPRO)/libnx
-	bzip2 -cd libnx-$(VERSION).tar.bz2 | tar -xf - -C $(DESTDIR)$(DEVKITPRO)/libnx
+	@tar -cjf libnx-`git describe --tags | sed 's/^v//'`.tar.bz2 include source data external Makefile default_icon.jpg switch_rules switch.ld switch.specs
 
 #dox:
 #	@doxygen Doxyfile

nx/external/bsd/include/net/if.h

@@ -373,7 +373,8 @@ struct	ifreq {
 		struct	sockaddr ifr_dstaddr; /* other end of p-to-p link */
 		struct	sockaddr ifr_broadaddr; /* broadcast address */
 		struct	ifreq_buffer ifr_buffer; /* user supplied buffer with its length */
-		short	ifr_flags[2]; /* flags (low 16 bits) */
+		short	ifr_flags; /* flags (low 16 bits) */
+		short	ifr_flagshigh; /* flags (high 16 bits) */
 		short	ifr_index; /* interface index */
 		int	ifr_jid; /* jail/vnet */
 		int	ifr_metric; /* metric */

nx/external/bsd/include/netinet/in.h

@@ -45,6 +45,15 @@
 #include <sys/types.h>
 #include <machine/endian.h>
 
+#ifndef _IN_ADDR_T_DECLARED
+typedef	__uint32_t	in_addr_t;
+#define	_IN_ADDR_T_DECLARED
+#endif
+#ifndef _IN_PORT_T_DECLARED
+typedef	__uint16_t	in_port_t;
+#define	_IN_PORT_T_DECLARED
+#endif
+
 /* Protocols common to RFC 1700, POSIX, and X/Open. */
 #define	IPPROTO_IP		0		/* dummy for IP */
 #define	IPPROTO_ICMP		1		/* control message protocol */

nx/external/bsd/include/sys/poll.h

@@ -0,0 +1,2 @@
+#include <poll.h>
+

nx/external/bsd/include/sys/socket.h

@@ -437,8 +437,35 @@ struct cmsghdr {
 /* followed by	u_char  cmsg_data[]; */
 };
 
-// socket credential stuff, we don't need this
-// cmsg macros, uses some obscure macro
+#define	_ALIGNBYTES		(sizeof(long) - 1)
+#define	_ALIGN(p)		(((unsigned long)(p) + _ALIGNBYTES) & ~_ALIGNBYTES)
+
+/* given pointer to struct cmsghdr, return pointer to data */
+#define	CMSG_DATA(cmsg) \
+	((unsigned char *)(cmsg) + _ALIGN(sizeof(struct cmsghdr)))
+
+/* given pointer to struct cmsghdr, return pointer to next cmsghdr */
+#define	CMSG_NXTHDR(mhdr, cmsg)	\
+	(((char *)(cmsg) + _ALIGN((cmsg)->cmsg_len) + \
+			    _ALIGN(sizeof(struct cmsghdr)) > \
+	    ((char *)(mhdr)->msg_control) + (mhdr)->msg_controllen) ? \
+	    (struct cmsghdr *)NULL : \
+	    (struct cmsghdr *)((char *)(cmsg) + _ALIGN((cmsg)->cmsg_len)))
+
+/*
+ * RFC 2292 requires to check msg_controllen, in case that the kernel returns
+ * an empty list for some reasons.
+ */
+#define	CMSG_FIRSTHDR(mhdr) \
+	((mhdr)->msg_controllen >= sizeof(struct cmsghdr) ? \
+	 (struct cmsghdr *)(mhdr)->msg_control : \
+	 (struct cmsghdr *)NULL)
+
+/* Length of the contents of a control message of length len */
+#define	CMSG_LEN(len)	(_ALIGN(sizeof(struct cmsghdr)) + (len))
+
+/* Length of the space taken up by a padded control message of length len */
+#define	CMSG_SPACE(len)	(_ALIGN(sizeof(struct cmsghdr)) + _ALIGN(len))
 
 /* "Socket"-level control message types: */
 #define	SCM_RIGHTS	0x01		/* access rights (array of int) */

nx/include/machine/_threads.h

@@ -1,33 +0,0 @@
-#pragma once
-#include "../switch/types.h"
-#include "../switch/result.h"
-#include "../switch/kernel/mutex.h"
-#include "../switch/kernel/condvar.h"
-#include "../switch/kernel/thread.h"
-
-#define TSS_DTOR_ITERATIONS 1
-
-typedef struct {
-    Thread thr;
-    int rc;
-} __thrd_t;
-
-typedef CondVar   cnd_t;
-typedef __thrd_t* thrd_t;
-typedef u32       tss_t;
-
-#define _MTX_INITIALIZER_NP {mtx_plain, {0}}
-typedef struct mtx_t {
-    int type;
-    union {
-        Mutex mutex;
-        RMutex rmutex;
-    };
-} mtx_t;
-
-#define ONCE_FLAG_INIT {0,_MTX_INITIALIZER_NP,0}
-typedef struct once_flag_t {
-    int status;
-    mtx_t mutex;
-    cnd_t cond;
-} once_flag;

nx/include/switch.h

@@ -17,14 +17,17 @@ extern "C" {
 
 #include "switch/arm/tls.h"
 #include "switch/arm/cache.h"
-#include "switch/arm/atomics.h"
 #include "switch/arm/counter.h"
 
 #include "switch/kernel/svc.h"
+#include "switch/kernel/wait.h"
 #include "switch/kernel/tmem.h"
 #include "switch/kernel/shmem.h"
 #include "switch/kernel/mutex.h"
 #include "switch/kernel/event.h"
+#include "switch/kernel/levent.h"
+#include "switch/kernel/uevent.h"
+#include "switch/kernel/utimer.h"
 #include "switch/kernel/rwlock.h"
 #include "switch/kernel/condvar.h"
 #include "switch/kernel/thread.h"
@@ -33,7 +36,13 @@ extern "C" {
 #include "switch/kernel/detect.h"
 #include "switch/kernel/random.h"
 #include "switch/kernel/jit.h"
-#include "switch/kernel/ipc.h"
+#include "switch/kernel/barrier.h"
+
+#include "switch/sf/hipc.h"
+#include "switch/sf/cmif.h"
+#include "switch/sf/service.h"
+#include "switch/sf/sessionmgr.h"
+#include "switch/sf/tipc.h"
 
 #include "switch/services/sm.h"
 #include "switch/services/smm.h"
@@ -43,53 +52,124 @@ extern "C" {
 #include "switch/services/acc.h"
 #include "switch/services/apm.h"
 #include "switch/services/applet.h"
+#include "switch/services/async.h"
+#include "switch/services/audctl.h"
 #include "switch/services/audin.h"
 #include "switch/services/audout.h"
+#include "switch/services/audrec.h"
 #include "switch/services/audren.h"
+#include "switch/services/auddev.h"
+#include "switch/services/hwopus.h"
 #include "switch/services/csrng.h"
+#include "switch/services/lbl.h"
+#include "switch/services/i2c.h"
+#include "switch/services/gpio.h"
+#include "switch/services/uart.h"
 #include "switch/services/bpc.h"
+#include "switch/services/pcv.h"
+#include "switch/services/clkrst.h"
+#include "switch/services/fan.h"
+#include "switch/services/pgl.h"
 #include "switch/services/psm.h"
-//#include "switch/services/bsd.h" Use switch/runtime/devices/socket.h instead
+#include "switch/services/spsm.h"
+//#include "switch/services/bsd.h" Use <sys/socket.h> instead
+//#include "switch/services/sfdnsres.h" Use <netdb.h> instead
+//#include "switch/services/htcs.h"
 #include "switch/services/fatal.h"
 #include "switch/services/time.h"
 #include "switch/services/usb.h"
+#include "switch/services/usbds.h"
+#include "switch/services/usbhs.h"
 #include "switch/services/hid.h"
+#include "switch/services/hidbus.h"
+#include "switch/services/hiddbg.h"
+#include "switch/services/hidsys.h"
 #include "switch/services/irs.h"
 #include "switch/services/pl.h"
 #include "switch/services/vi.h"
 #include "switch/services/nv.h"
 #include "switch/services/nifm.h"
+#include "switch/services/nim.h"
 #include "switch/services/ns.h"
 #include "switch/services/ldr.h"
+#include "switch/services/ro.h"
+#include "switch/services/tc.h"
+#include "switch/services/ts.h"
 #include "switch/services/pm.h"
 #include "switch/services/set.h"
+#include "switch/services/ssl.h"
 #include "switch/services/lr.h"
+#include "switch/services/bt.h"
+#include "switch/services/btdrv.h"
+#include "switch/services/btm.h"
+#include "switch/services/btmu.h"
+#include "switch/services/btmsys.h"
 #include "switch/services/spl.h"
 #include "switch/services/ncm.h"
+#include "switch/services/psc.h"
+#include "switch/services/caps.h"
+#include "switch/services/capsa.h"
+#include "switch/services/capsc.h"
+#include "switch/services/capsdc.h"
+#include "switch/services/capsu.h"
+#include "switch/services/capssc.h"
+#include "switch/services/capssu.h"
+#include "switch/services/capmtp.h"
+#include "switch/services/nfc.h"
+#include "switch/services/wlaninf.h"
+#include "switch/services/pctl.h"
+#include "switch/services/pdm.h"
+#include "switch/services/grc.h"
+#include "switch/services/friends.h"
+#include "switch/services/notif.h"
+#include "switch/services/mii.h"
+#include "switch/services/miiimg.h"
+#include "switch/services/ldn.h"
+#include "switch/services/lp2p.h"
+#include "switch/services/news.h"
+#include "switch/services/ins.h"
+#include "switch/services/ectx.h"
+#include "switch/services/avm.h"
+#include "switch/services/mm.h"
 
-#include "switch/display/gfx.h"
 #include "switch/display/binder.h"
 #include "switch/display/parcel.h"
 #include "switch/display/buffer_producer.h"
-#include "switch/display/nvgfx.h"
+#include "switch/display/native_window.h"
+#include "switch/display/framebuffer.h"
 
 #include "switch/nvidia/ioctl.h"
-#include "switch/nvidia/buffer.h"
+#include "switch/nvidia/graphic_buffer.h"
+#include "switch/nvidia/fence.h"
+#include "switch/nvidia/map.h"
 #include "switch/nvidia/address_space.h"
 #include "switch/nvidia/channel.h"
-#include "switch/nvidia/info.h"
-#include "switch/nvidia/fence.h"
-#include "switch/nvidia/gpu/cmd_list.h"
-#include "switch/nvidia/gpu/gpfifo.h"
-#include "switch/nvidia/gpu/zcull_ctx.h"
-#include "switch/nvidia/gpu/3d_ctx.h"
-#include "switch/nvidia/gpu/error_notifier.h"
-#include "switch/nvidia/gpu/gpu.h"
+#include "switch/nvidia/gpu.h"
+#include "switch/nvidia/gpu_channel.h"
 
 #include "switch/audio/driver.h"
 
+#include "switch/applets/libapplet.h"
+#include "switch/applets/album_la.h"
+#include "switch/applets/friends_la.h"
+#include "switch/applets/hid_la.h"
+#include "switch/applets/mii_la.h"
+#include "switch/applets/nfp_la.h"
+#include "switch/applets/nifm_la.h"
+#include "switch/applets/pctlauth.h"
+#include "switch/applets/psel.h"
+#include "switch/applets/error.h"
+#include "switch/applets/swkbd.h"
+#include "switch/applets/web.h"
+
 #include "switch/runtime/env.h"
+#include "switch/runtime/hosversion.h"
+#include "switch/runtime/diag.h"
 #include "switch/runtime/nxlink.h"
+#include "switch/runtime/resolver.h"
+#include "switch/runtime/pad.h"
+#include "switch/runtime/ringcon.h"
+#include "switch/runtime/btdev.h"
 
 #include "switch/runtime/util/utf.h"
 
@@ -99,6 +179,18 @@ extern "C" {
 #include "switch/runtime/devices/romfs_dev.h"
 #include "switch/runtime/devices/socket.h"
 
+#include "switch/crypto/aes.h"
+#include "switch/crypto/aes_cbc.h"
+#include "switch/crypto/aes_ctr.h"
+#include "switch/crypto/aes_xts.h"
+#include "switch/crypto/cmac.h"
+
+#include "switch/crypto/sha256.h"
+#include "switch/crypto/sha1.h"
+#include "switch/crypto/hmac.h"
+
+#include "switch/crypto/crc.h"
+
 #ifdef __cplusplus
 }
 #endif

nx/include/switch/applets/album_la.h

@@ -0,0 +1,31 @@
+/**
+ * @file album_la.h
+ * @brief Wrapper for using the Album LibraryApplet.
+ * @author yellows8
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+
+/// Arg type values pushed for the applet input storage, stored as an u8.
+typedef enum {
+    AlbumLaArg_ShowAlbumFiles                 = 0,  ///< ShowAlbumFiles. Only displays AlbumFiles associated with the application which launched the Album applet, with the filter button disabled.
+    AlbumLaArg_ShowAllAlbumFiles              = 1,  ///< ShowAllAlbumFiles. Displays all AlbumFiles, with filtering allowed.
+    AlbumLaArg_ShowAllAlbumFilesForHomeMenu   = 2,  ///< ShowAllAlbumFilesForHomeMenu. Similar to ::AlbumLaArg_ShowAllAlbumFiles.
+} AlbumLaArg;
+
+/**
+ * @brief Launches the applet with ::AlbumLaArg_ShowAlbumFiles and playStartupSound=false.
+ */
+Result albumLaShowAlbumFiles(void);
+
+/**
+ * @brief Launches the applet with ::AlbumLaArg_ShowAllAlbumFiles and playStartupSound=false.
+ */
+Result albumLaShowAllAlbumFiles(void);
+
+/**
+ * @brief Launches the applet with ::AlbumLaArg_ShowAllAlbumFilesForHomeMenu and playStartupSound=true.
+ */
+Result albumLaShowAllAlbumFilesForHomeMenu(void);
+

nx/include/switch/applets/error.h

@@ -0,0 +1,314 @@
+/**
+ * @file error.h
+ * @brief Wrapper for using the error LibraryApplet.
+ * @author StuntHacks, yellows8
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+#include "../services/set.h"
+
+/// Error type for ErrorCommonHeader.type.
+typedef enum {
+    ErrorType_Normal           = 0,  ///< Normal
+    ErrorType_System           = 1,  ///< System
+    ErrorType_Application      = 2,  ///< Application
+    ErrorType_Eula             = 3,  ///< EULA
+    ErrorType_Pctl             = 4,  ///< Parental Controls
+    ErrorType_Record           = 5,  ///< Record
+    ErrorType_SystemUpdateEula = 8,  ///< SystemUpdateEula
+} ErrorType;
+
+/// Stores error-codes which are displayed as XXXX-XXXX, low for the former and desc for the latter.
+typedef struct {
+    u32 low;             ///< The module portion of the error, normally this should be set to module + 2000.
+    u32 desc;            ///< The error description.
+} ErrorCode;
+
+/// Error type for ErrorContext.type
+typedef enum {
+    ErrorContextType_None              = 0, ///< None
+    ErrorContextType_Http              = 1, ///< Http
+    ErrorContextType_FileSystem        = 2, ///< FileSystem
+    ErrorContextType_WebMediaPlayer    = 3, ///< WebMediaPlayer
+    ErrorContextType_LocalContentShare = 4, ///< LocalContentShare
+} ErrorContextType;
+
+/// Error context.
+typedef struct {
+    u8 type;             ///< Type, see \ref ErrorContextType.
+    u8 pad[7];           ///< Padding
+    u8 data[0x1f4];      ///< Data
+    Result res;          ///< Result
+} ErrorContext;
+
+/// Common header for the start of the arg storage.
+typedef struct {
+    u8 type;             ///< Type, see \ref ErrorType.
+    u8 jumpFlag;         ///< When clear, this indicates WithoutJump.
+    u8 unk_x2[3];        ///< Unknown
+    u8 contextFlag;      ///< When set with ::ErrorType_Normal, indicates that an additional storage is pushed for \ref ErrorResultBacktrace. [4.0.0+] Otherwise, when set indicates that an additional storage is pushed for \ref ErrorContext.
+    u8 resultFlag;       ///< ErrorCommonArg: When clear, errorCode is used, otherwise the applet generates the error-code from res.
+    u8 contextFlag2;     ///< Similar to contextFlag except for ErrorCommonArg, indicating \ref ErrorContext is used.
+} ErrorCommonHeader;
+
+/// Common error arg data.
+typedef struct {
+    ErrorCommonHeader hdr;            ///< Common header.
+    ErrorCode errorCode;              ///< \ref ErrorCode
+    Result res;                       ///< Result
+} ErrorCommonArg;
+
+/// Error arg data for certain errors with module PCTL.
+typedef struct {
+    ErrorCommonHeader hdr;            ///< Common header.
+    Result res;                       ///< Result
+} ErrorPctlArg;
+
+/// ResultBacktrace
+typedef struct {
+    s32 count;                        ///< Total entries in the backtrace array.
+    Result backtrace[0x20];           ///< Result backtrace.
+} ErrorResultBacktrace;
+
+/// Error arg data for EULA.
+typedef struct {
+    ErrorCommonHeader hdr;            ///< Common header.
+    SetRegion regionCode;             ///< \ref SetRegion
+} ErrorEulaArg;
+
+/// Additional input storage data for \ref errorSystemUpdateEulaShow.
+typedef struct {
+    u8 data[0x20000];                ///< data
+} ErrorEulaData;
+
+/// Error arg data for Record.
+typedef struct {
+    ErrorCommonHeader hdr;            ///< Common header.
+    ErrorCode errorCode;              ///< \ref ErrorCode
+    u64 timestamp;                    ///< POSIX timestamp.
+} ErrorRecordArg;
+
+/// SystemErrorArg
+typedef struct {
+    ErrorCommonHeader hdr;            ///< Common header.
+    ErrorCode errorCode;              ///< \ref ErrorCode
+    u64 languageCode;                 ///< See set.h.
+    char dialogMessage[0x800];        ///< UTF-8 Dialog message.
+    char fullscreenMessage[0x800];    ///< UTF-8 Fullscreen message (displayed when the user clicks on "Details").
+} ErrorSystemArg;
+
+/// Error system config.
+typedef struct {
+    ErrorSystemArg arg;               ///< Arg data.
+    ErrorContext ctx;                 ///< Optional error context.
+} ErrorSystemConfig;
+
+/// ApplicationErrorArg
+typedef struct {
+    ErrorCommonHeader hdr;            ///< Common header.
+    u32 errorNumber;                  ///< Raw decimal error number which is displayed in the dialog.
+    u64 languageCode;                 ///< See set.h.
+    char dialogMessage[0x800];        ///< UTF-8 Dialog message.
+    char fullscreenMessage[0x800];    ///< UTF-8 Fullscreen message (displayed when the user clicks on "Details").
+} NX_PACKED ErrorApplicationArg;
+
+/// Error application config.
+typedef struct {
+    ErrorApplicationArg arg;          ///< Arg data.
+} ErrorApplicationConfig;
+
+/**
+ * @brief Creates an \ref ErrorCode.
+ * @param low  The module portion of the error, normally this should be set to module + 2000.
+ * @param desc The error description.
+ */
+static inline ErrorCode errorCodeCreate(u32 low, u32 desc) {
+    return (ErrorCode){low, desc};
+}
+
+/**
+ * @brief Creates an \ref ErrorCode with the input Result. Wrapper for \ref errorCodeCreate.
+ * @param res Input Result.
+ */
+static inline ErrorCode errorCodeCreateResult(Result res) {
+    return errorCodeCreate(2000 + R_MODULE(res), R_DESCRIPTION(res));
+}
+
+/**
+ * @brief Creates an invalid \ref ErrorCode.
+ */
+static inline ErrorCode errorCodeCreateInvalid(void) {
+    return (ErrorCode){0};
+}
+
+/**
+ * @brief Checks whether the input ErrorCode is valid.
+ * @param errorCode \ref ErrorCode
+ */
+static inline bool errorCodeIsValid(ErrorCode errorCode) {
+    return errorCode.low!=0;
+}
+
+/**
+ * @brief Launches the applet for displaying the specified Result.
+ * @param res Result
+ * @param jumpFlag Jump flag, normally this is true.
+ * @param ctx Optional \ref ErrorContext, can be NULL. Unused when jumpFlag=false. Ignored on pre-4.0.0, since it's only available for [4.0.0+].
+ * @note Sets the following fields: jumpFlag and contextFlag2. Uses ::ErrorType_Normal normally.
+ * @note For module=PCTL errors with desc 100-119 this sets uses ::ErrorType_Pctl, in which case the applet will display the following special dialog: "This software is restricted by Parental Controls".
+ * @note If the input Result is 0xC8A2, the applet will display a special dialog regarding the current application requiring a software update, with buttons "Later" and "Restart".
+ * @note [3.0.0+] If the input Result is 0xCAA2, the applet will display a special dialog related to DLC version.
+ * @warning This applet creates an error report that is logged in the system, when not handling the above special dialogs. Proceed at your own risk!
+ */
+Result errorResultShow(Result res, bool jumpFlag, const ErrorContext* ctx);
+
+/**
+ * @brief Launches the applet for displaying the specified ErrorCode.
+ * @param errorCode \ref ErrorCode
+ * @param jumpFlag Jump flag, normally this is true.
+ * @param ctx Optional \ref ErrorContext, can be NULL. Unused when jumpFlag=false. Ignored on pre-4.0.0, since it's only available for [4.0.0+].
+ * @note Sets the following fields: jumpFlag and contextFlag2. resultFlag=1. Uses ::ErrorType_Normal.
+ * @warning This applet creates an error report that is logged in the system. Proceed at your own risk!
+ */
+Result errorCodeShow(ErrorCode errorCode, bool jumpFlag, const ErrorContext* ctx);
+
+/**
+ * @brief Creates an ErrorResultBacktrace struct.
+ * @param backtrace \ref ErrorResultBacktrace struct.
+ * @param count Total number of entries.
+ * @param entries Input array of Result.
+ */
+Result errorResultBacktraceCreate(ErrorResultBacktrace* backtrace, s32 count, const Result* entries);
+
+/**
+ * @brief Launches the applet for \ref ErrorResultBacktrace.
+ * @param backtrace ErrorResultBacktrace struct.
+ * @param res Result
+ * @note Sets the following fields: jumpFlag=1, contextFlag=1, and uses ::ErrorType_Normal.
+ * @warning This applet creates an error report that is logged in the system. Proceed at your own risk!
+ */
+Result errorResultBacktraceShow(Result res, const ErrorResultBacktrace* backtrace);
+
+/**
+ * @brief Launches the applet for displaying the EULA.
+ * @param RegionCode \ref SetRegion
+ * @note Sets the following fields: jumpFlag=1, regionCode, and uses ::ErrorType_Eula.
+ */
+Result errorEulaShow(SetRegion RegionCode);
+
+/**
+ * @brief Launches the applet for displaying the system-update EULA.
+ * @param RegionCode \ref SetRegion
+ * @param eula EULA data. Address must be 0x1000-byte aligned.
+ * @note Sets the following fields: jumpFlag=1, regionCode, and uses ::ErrorType_SystemUpdateEula.
+ */
+Result errorSystemUpdateEulaShow(SetRegion RegionCode, const ErrorEulaData* eula);
+
+/**
+ * @brief Launches the applet for displaying an error full-screen, using the specified ErrorCode and timestamp.
+ * @param errorCode \ref ErrorCode
+ * @param timestamp POSIX timestamp.
+ * @note Sets the following fields: jumpFlag=1, errorCode, timestamp, and uses ::ErrorType_Record.
+ * @note The applet does not log an error report for this. error*RecordShow is used by qlaunch for displaying previously logged error reports.
+ */
+Result errorCodeRecordShow(ErrorCode errorCode, u64 timestamp);
+
+/**
+ * @brief Launches the applet for displaying an error full-screen, using the specified Result and timestamp.
+ * @param res Result
+ * @param timestamp POSIX timestamp.
+ * @note Wrapper for \ref errorCodeRecordShow, see \ref errorCodeRecordShow notes.
+ */
+static inline Result errorResultRecordShow(Result res, u64 timestamp) {
+    return errorCodeRecordShow(errorCodeCreateResult(res), timestamp);
+}
+
+/**
+ * @brief Creates an ErrorSystemConfig struct.
+ * @param c ErrorSystemConfig struct.
+ * @param dialog_message UTF-8 dialog message.
+ * @param fullscreen_message UTF-8 fullscreen message, displayed when the user clicks on "Details". Optional, can be NULL (which disables displaying Details).
+ * @note Sets the following fields: {strings}, and uses ::ErrorType_System. The rest are cleared.
+ * @note On pre-5.0.0 this will initialize languageCode by using: setInitialize(), setMakeLanguageCode(SetLanguage_ENUS, ...), and setExit(). This is needed since an empty languageCode wasn't supported until [5.0.0+] (which would also use SetLanguage_ENUS).
+ * @warning This applet creates an error report that is logged in the system. Proceed at your own risk!
+ */
+Result errorSystemCreate(ErrorSystemConfig* c, const char* dialog_message, const char* fullscreen_message);
+
+/**
+ * @brief Launches the applet with the specified config.
+ * @param c ErrorSystemConfig struct.
+ */
+Result errorSystemShow(ErrorSystemConfig* c);
+
+/**
+ * @brief Sets the error code.
+ * @param c    ErrorSystemConfig struct.
+ * @param errorCode \ref ErrorCode
+ */
+static inline void errorSystemSetCode(ErrorSystemConfig* c, ErrorCode errorCode) {
+    c->arg.errorCode = errorCode;
+}
+
+/**
+ * @brief Sets the error code, using the input Result. Wrapper for \ref errorSystemSetCode.
+ * @param c    ErrorSystemConfig struct.
+ * @param res  The Result to set.
+ */
+static inline void errorSystemSetResult(ErrorSystemConfig* c, Result res) {
+    errorSystemSetCode(c, errorCodeCreateResult(res));
+}
+
+/**
+ * @brief Sets the LanguageCode.
+ * @param c            ErrorSystemConfig struct.
+ * @param LanguageCode LanguageCode, see set.h.
+ */
+static inline void errorSystemSetLanguageCode(ErrorSystemConfig* c, u64 LanguageCode) {
+    c->arg.languageCode = LanguageCode;
+}
+
+/**
+ * @brief Sets the ErrorContext.
+ * @note Only available on [4.0.0+], on older versions this will return without setting the context.
+ * @param c   ErrorSystemConfig struct.
+ * @param ctx ErrorContext, NULL to clear it.
+ */
+void errorSystemSetContext(ErrorSystemConfig* c, const ErrorContext* ctx);
+
+/**
+ * @brief Creates an ErrorApplicationConfig struct.
+ * @param c ErrorApplicationConfig struct.
+ * @param dialog_message UTF-8 dialog message.
+ * @param fullscreen_message UTF-8 fullscreen message, displayed when the user clicks on "Details". Optional, can be NULL (which disables displaying Details).
+ * @note Sets the following fields: jumpFlag=1, {strings}, and uses ::ErrorType_Application. The rest are cleared.
+ * @note On pre-5.0.0 this will initialize languageCode by using: setInitialize(), setMakeLanguageCode(SetLanguage_ENUS, ...), and setExit(). This is needed since an empty languageCode wasn't supported until [5.0.0+] (which would also use SetLanguage_ENUS).
+ * @note With [10.0.0+] this must only be used when running under an Application, since otherwise the applet will trigger a fatalerr.
+ * @warning This applet creates an error report that is logged in the system. Proceed at your own risk!
+ */
+Result errorApplicationCreate(ErrorApplicationConfig* c, const char* dialog_message, const char* fullscreen_message);
+
+/**
+ * @brief Launches the applet with the specified config.
+ * @param c ErrorApplicationConfig struct.
+ */
+Result errorApplicationShow(ErrorApplicationConfig* c);
+
+/**
+ * @brief Sets the error code number.
+ * @param c           ErrorApplicationConfig struct.
+ * @param errorNumber Error code number. Raw decimal error number which is displayed in the dialog.
+ */
+static inline void errorApplicationSetNumber(ErrorApplicationConfig* c, u32 errorNumber) {
+    c->arg.errorNumber = errorNumber;
+}
+
+/**
+ * @brief Sets the LanguageCode.
+ * @param c            ErrorApplicationConfig struct.
+ * @param LanguageCode LanguageCode, see set.h.
+ */
+static inline void errorApplicationSetLanguageCode(ErrorApplicationConfig* c, u64 LanguageCode) {
+    c->arg.languageCode = LanguageCode;
+}
+

nx/include/switch/applets/friends_la.h

@@ -0,0 +1,172 @@
+/**
+ * @file friends_la.h
+ * @brief Wrapper for using the MyPage (friends) LibraryApplet.
+ * @author yellows8
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+#include "../services/acc.h"
+#include "../services/friends.h"
+
+/// Arg type values used with \ref FriendsLaArg.
+typedef enum {
+    FriendsLaArgType_ShowFriendList                    = 0,      ///< ShowFriendList. Launches the applet with the "Friend List" menu initially selected.
+    FriendsLaArgType_ShowUserDetailInfo                = 1,      ///< ShowUserDetailInfo
+    FriendsLaArgType_StartSendingFriendRequest         = 2,      ///< StartSendingFriendRequest
+    FriendsLaArgType_ShowMethodsOfSendingFriendRequest = 3,      ///< ShowMethodsOfSendingFriendRequest. Launches the applet with the "Add Friend" menu initially selected.
+    FriendsLaArgType_StartFacedFriendRequest           = 4,      ///< StartFacedFriendRequest. Launches the applet where the "Search for Local Users" menu is initially shown. Returning from this menu will exit the applet.
+    FriendsLaArgType_ShowReceivedFriendRequestList     = 5,      ///< ShowReceivedFriendRequestList. Launches the applet where the "Received Friend Requests" menu is initially shown. Returning from this menu will exit the applet.
+    FriendsLaArgType_ShowBlockedUserList               = 6,      ///< ShowBlockedUserList. Launches the applet where the "Blocked-User List" menu is initially shown. Returning from this menu will exit the applet.
+    FriendsLaArgType_ShowMyProfile                     = 7,      ///< ShowMyProfile. Launches the applet with the "Profile" menu initially selected. ShowMyProfileForHomeMenu is identical to this except for playStartupSound=true.
+    FriendsLaArgType_StartFriendInvitation             = 8,      ///< [9.0.0+] StartFriendInvitation. Launches the applet for sending online-play invites to friends, where the friends are selected via the UI.
+    FriendsLaArgType_StartSendingFriendInvitation      = 9,      ///< [9.0.0+] StartSendingFriendInvitation.
+    FriendsLaArgType_ShowReceivedInvitationDetail      = 10,     ///< [9.0.0+] ShowReceivedInvitationDetail.
+} FriendsLaArgType;
+
+/// Header for the arg struct.
+typedef struct {
+    u32 type;                                                    ///< \ref FriendsLaArgType
+    u32 pad;                                                     ///< Padding.
+    AccountUid uid;                                              ///< \ref AccountUid
+} FriendsLaArgHeader;
+
+/// Common data for the arg struct, for the pre-9.0.0 types.
+/// This is only set for ::FriendsLaArgType_ShowUserDetailInfo/::FriendsLaArgType_StartSendingFriendRequest, for everything else this is cleared.
+typedef struct {
+    AccountNetworkServiceAccountId id;                           ///< \ref AccountNetworkServiceAccountId for the other account.
+    FriendsInAppScreenName first_inAppScreenName;                ///< First InAppScreenName.
+    FriendsInAppScreenName second_inAppScreenName;               ///< Second InAppScreenName.
+} FriendsLaArgCommonData;
+
+/// Arg struct pushed for the applet input storage, for pre-9.0.0.
+typedef struct {
+    FriendsLaArgHeader hdr;                                      ///< \ref FriendsLaArgHeader
+    FriendsLaArgCommonData data;                                 ///< \ref FriendsLaArgCommonData
+} FriendsLaArgV1;
+
+/// Arg struct pushed for the applet input storage, for [9.0.0+].
+typedef struct {
+    FriendsLaArgHeader hdr;                                      ///< \ref FriendsLaArgHeader
+
+    union {
+        u8 raw[0x1090];                                          ///< Raw data.
+
+        FriendsLaArgCommonData common;                           ///< \ref FriendsLaArgCommonData
+
+        struct {
+            s32 id_count;                                        ///< \ref AccountNetworkServiceAccountId count, must be 1-15.
+            u32 pad;                                             ///< Padding.
+            u64 userdata_size;                                   ///< User-data size, must be <=0x400.
+            u8 userdata[0x400];                                  ///< Arbitrary user-data, see above size.
+            FriendsFriendInvitationGameModeDescription desc;     ///< \ref FriendsFriendInvitationGameModeDescription
+        } start_friend_invitation;                               ///< Data for ::FriendsLaArgType_StartFriendInvitation.
+
+        struct {
+            s32 id_count;                                        ///< \ref AccountNetworkServiceAccountId count, must be 1-15.
+            u32 pad;                                             ///< Padding.
+            AccountNetworkServiceAccountId id_list[16];          ///< \ref AccountNetworkServiceAccountId list, see above count.
+            u64 userdata_size;                                   ///< User-data size, must be <=0x400.
+            u8 userdata[0x400];                                  ///< Arbitrary user-data, see above size.
+            FriendsFriendInvitationGameModeDescription desc;     ///< \ref FriendsFriendInvitationGameModeDescription
+        } start_sending_friend_invitation;                       ///< Data for ::FriendsLaArgType_StartSendingFriendInvitation.
+
+        struct {
+            FriendsFriendInvitationId invitation_id;             ///< \ref FriendsFriendInvitationId
+            FriendsFriendInvitationGroupId invitation_group_id;  ///< \ref FriendsFriendInvitationGroupId
+        } show_received_invitation_detail;                       ///< Data for ::FriendsLaArgType_ShowReceivedInvitationDetail.
+    } data;                                                      ///< Data for each \ref FriendsLaArgType.
+} FriendsLaArg;
+
+/**
+ * @brief Launches the applet with ::FriendsLaArgType_ShowFriendList, the specified input, and playStartupSound=false.
+ * @param[in] uid \ref AccountUid
+ */
+Result friendsLaShowFriendList(AccountUid uid);
+
+/**
+ * @brief Launches the applet with ::FriendsLaArgType_ShowUserDetailInfo, the specified input, and playStartupSound=false.
+ * @param[in] uid \ref AccountUid
+ * @param[in] id \ref AccountNetworkServiceAccountId for the user to show UserDetailInfo for.
+ * @param[in] first_inAppScreenName First \ref FriendsInAppScreenName.
+ * @param[in] second_inAppScreenName Second \ref FriendsInAppScreenName.
+ */
+Result friendsLaShowUserDetailInfo(AccountUid uid, AccountNetworkServiceAccountId id, const FriendsInAppScreenName *first_inAppScreenName, const FriendsInAppScreenName *second_inAppScreenName);
+
+/**
+ * @brief Launches the applet with ::FriendsLaArgType_StartSendingFriendRequest, the specified input, and playStartupSound=false. On success, this will load the output Result from the output storage.
+ * @param[in] uid \ref AccountUid
+ * @param[in] id \ref AccountNetworkServiceAccountId to send the friend request to.
+ * @param[in] first_inAppScreenName First \ref FriendsInAppScreenName.
+ * @param[in] second_inAppScreenName Second \ref FriendsInAppScreenName.
+ */
+Result friendsLaStartSendingFriendRequest(AccountUid uid, AccountNetworkServiceAccountId id, const FriendsInAppScreenName *first_inAppScreenName, const FriendsInAppScreenName *second_inAppScreenName);
+
+/**
+ * @brief Launches the applet with ::FriendsLaArgType_ShowMethodsOfSendingFriendRequest, the specified input, and playStartupSound=false.
+ * @param[in] uid \ref AccountUid
+ */
+Result friendsLaShowMethodsOfSendingFriendRequest(AccountUid uid);
+
+/**
+ * @brief Launches the applet with ::FriendsLaArgType_StartFacedFriendRequest, the specified input, and playStartupSound=false.
+ * @param[in] uid \ref AccountUid
+ */
+Result friendsLaStartFacedFriendRequest(AccountUid uid);
+
+/**
+ * @brief Launches the applet with ::FriendsLaArgType_ShowReceivedFriendRequestList, the specified input, and playStartupSound=false.
+ * @param[in] uid \ref AccountUid
+ */
+Result friendsLaShowReceivedFriendRequestList(AccountUid uid);
+
+/**
+ * @brief Launches the applet with ::FriendsLaArgType_ShowBlockedUserList, the specified input, and playStartupSound=false.
+ * @param[in] uid \ref AccountUid
+ */
+Result friendsLaShowBlockedUserList(AccountUid uid);
+
+/**
+ * @brief Launches the applet with ::FriendsLaArgType_ShowMyProfile, the specified input, and playStartupSound=false.
+ * @param[in] uid \ref AccountUid
+ */
+Result friendsLaShowMyProfile(AccountUid uid);
+
+/**
+ * @brief Same as \ref friendsLaShowMyProfile except with playStartupSound=true.
+ * @param[in] uid \ref AccountUid
+ */
+Result friendsLaShowMyProfileForHomeMenu(AccountUid uid);
+
+/**
+ * @brief Launches the applet with ::FriendsLaArgType_StartFriendInvitation, the specified input, and playStartupSound=false. On success, this will load the output Result from the output storage.
+ * @note Only available on [9.0.0+].
+ * @param[in] uid \ref AccountUid
+ * @param[in] id_count \ref AccountNetworkServiceAccountId count, must be 1-15. Number of friends to invite.
+ * @param[in] desc \ref FriendsFriendInvitationGameModeDescription
+ * @param[in] userdata Arbitrary user-data. Can be NULL.
+ * @param[in] userdata_size User-data size, must be <=0x400. Can be 0 if userdata is NULL.
+ */
+Result friendsLaStartFriendInvitation(AccountUid uid, s32 id_count, const FriendsFriendInvitationGameModeDescription *desc, const void* userdata, u64 userdata_size);
+
+/**
+ * @brief Launches the applet with ::FriendsLaArgType_StartSendingFriendInvitation, the specified input, and playStartupSound=false. On success, this will load the output Result from the output storage.
+ * @note Only available on [9.0.0+].
+ * @param[in] uid \ref AccountUid
+ * @param[in] id_list \ref AccountNetworkServiceAccountId list.
+ * @param[in] id_count Size of the id_list array in entries, must be 1-15. Number of friends to invite.
+ * @param[in] desc \ref FriendsFriendInvitationGameModeDescription
+ * @param[in] userdata Arbitrary user-data. Can be NULL.
+ * @param[in] userdata_size User-data size, must be <=0x400. Can be 0 if userdata is NULL.
+ */
+Result friendsLaStartSendingFriendInvitation(AccountUid uid, const AccountNetworkServiceAccountId *id_list, s32 id_count, const FriendsFriendInvitationGameModeDescription *desc, const void* userdata, u64 userdata_size);
+
+/**
+ * @brief Launches the applet with ::FriendsLaArgType_ShowReceivedInvitationDetail, the specified input, and playStartupSound=false.
+ * @note Only available on [9.0.0+].
+ * @param[in] uid \ref AccountUid
+ * @param[in] invitation_id \ref FriendsFriendInvitationId
+ * @param[in] invitation_group_id \ref FriendsFriendInvitationGroupId
+ */
+Result friendsLaShowReceivedInvitationDetail(AccountUid uid, FriendsFriendInvitationId invitation_id, FriendsFriendInvitationGroupId invitation_group_id);
+

nx/include/switch/applets/hid_la.h

@@ -0,0 +1,175 @@
+/**
+ * @file hid_la.h
+ * @brief Wrapper for using the controller LibraryApplet.
+ * @author yellows8
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+#include "../services/hid.h"
+
+/// Mode values for HidLaControllerSupportArgPrivate::mode.
+typedef enum {
+    HidLaControllerSupportMode_ShowControllerSupport                = 0,    ///< ShowControllerSupport
+    HidLaControllerSupportMode_ShowControllerStrapGuide             = 1,    ///< [3.0.0+] ShowControllerStrapGuide
+    HidLaControllerSupportMode_ShowControllerFirmwareUpdate         = 2,    ///< [3.0.0+] ShowControllerFirmwareUpdate
+    HidLaControllerSupportMode_ShowControllerKeyRemappingForSystem  = 4,    ///< [11.0.0+] ShowControllerKeyRemappingForSystem
+} HidLaControllerSupportMode;
+
+/// ControllerSupportCaller
+typedef enum {
+    HidLaControllerSupportCaller_Application                   = 0,    ///< Application, this is the default.
+    HidLaControllerSupportCaller_System                        = 1,    ///< System. Skips the firmware-update confirmation dialog. This has the same affect as using the controller-update option from qlaunch System Settings.
+} HidLaControllerSupportCaller;
+
+/// ControllerSupportArgPrivate
+typedef struct {
+    u32 private_size;                                                  ///< Size of this ControllerSupportArgPrivate struct.
+    u32 arg_size;                                                      ///< Size of the storage following this one (\ref HidLaControllerSupportArg or \ref HidLaControllerFirmwareUpdateArg).
+    u8 flag0;                                                          ///< Flag0
+    u8 flag1;                                                          ///< Flag1
+    u8 mode;                                                           ///< \ref HidLaControllerSupportMode
+    u8 controller_support_caller;                                      ///< \ref HidLaControllerSupportCaller. Always zero except with \ref hidLaShowControllerFirmwareUpdateForSystem, which sets this to the input param.
+    u32 npad_style_set;                                                ///< Output from \ref hidGetSupportedNpadStyleSet. With ShowControllerSupportForSystem on pre-3.0.0 this is value 0.
+    u32 npad_joy_hold_type;                                            ///< Output from \ref hidGetNpadJoyHoldType. With ShowControllerSupportForSystem on pre-3.0.0 this is value 1.
+} HidLaControllerSupportArgPrivate;
+
+/// Common header used by HidLaControllerSupportArg*.
+/// max_supported_players is 4 on pre-8.0.0, 8 on [8.0.0+]. player_count_min and player_count_max are overriden with value 4 when larger than value 4, during conversion handling for \ref HidLaControllerSupportArg on pre-8.0.0.
+typedef struct {
+    s8 player_count_min;                                               ///< playerCountMin. Must be >=0 and <=max_supported_players.
+    s8 player_count_max;                                               ///< playerCountMax. Must be >=1 and <=max_supported_players.
+    u8 enable_take_over_connection;                                    ///< enableTakeOverConnection, non-zero to enable. Disconnects the controllers when not enabled.
+    u8 enable_left_justify;                                            ///< enableLeftJustify, non-zero to enable.
+    u8 enable_permit_joy_dual;                                         ///< enablePermitJoyDual, non-zero to enable.
+    u8 enable_single_mode;                                             ///< enableSingleMode, non-zero to enable. Enables using a single player in handheld-mode, dual-mode, or single-mode (player_count_* are overridden). Using handheld-mode is not allowed if this is not enabled.
+    u8 enable_identification_color;                                    ///< When non-zero enables using identification_color.
+} HidLaControllerSupportArgHeader;
+
+/// Identification color used by HidLaControllerSupportArg*. When HidLaControllerSupportArgHeader::enable_identification_color is set this controls the color of the UI player box outline.
+typedef struct {
+    u8 r;                                                              ///< Red color component.
+    u8 g;                                                              ///< Green color component.
+    u8 b;                                                              ///< Blue color component.
+    u8 a;                                                              ///< Alpha color component.
+} HidLaControllerSupportArgColor;
+
+/// ControllerSupportArg for [1.0.0+].
+typedef struct {
+    HidLaControllerSupportArgHeader hdr;                               ///< \ref HidLaControllerSupportArgHeader
+    HidLaControllerSupportArgColor identification_color[4];            ///< \ref HidLaControllerSupportArgColor for each player, see HidLaControllerSupportArgHeader::enable_identification_color.
+    u8 enable_explain_text;                                            ///< Enables using the ExplainText data when non-zero.
+    char explain_text[4][0x81];                                        ///< ExplainText for each player, NUL-terminated UTF-8 strings.
+} HidLaControllerSupportArgV3;
+
+/// ControllerSupportArg for [8.0.0+], converted to \ref HidLaControllerSupportArgV3 on pre-8.0.0.
+typedef struct {
+    HidLaControllerSupportArgHeader hdr;                               ///< \ref HidLaControllerSupportArgHeader
+    HidLaControllerSupportArgColor identification_color[8];            ///< \ref HidLaControllerSupportArgColor for each player, see HidLaControllerSupportArgHeader::enable_identification_color.
+    u8 enable_explain_text;                                            ///< Enables using the ExplainText data when non-zero.
+    char explain_text[8][0x81];                                        ///< ExplainText for each player, NUL-terminated UTF-8 strings.
+} HidLaControllerSupportArg;
+
+/// ControllerFirmwareUpdateArg
+typedef struct {
+    u8 enable_force_update;                                            ///< enableForceUpdate, non-zero to enable. Default is 0. Forces a firmware update when enabled, without an UI option to skip it.
+    u8 pad[3];                                                         ///< Padding.
+} HidLaControllerFirmwareUpdateArg;
+
+/// ControllerKeyRemappingArg
+typedef struct {
+    u64 unk_x0;                                                        ///< Unknown
+    u32 unk_x8;                                                        ///< Unknown
+    u8 pad[0x4];                                                       ///< Padding
+} HidLaControllerKeyRemappingArg;
+
+/// ControllerSupportResultInfo. First 8-bytes from the applet output storage.
+typedef struct {
+    s8 player_count;                                                   ///< playerCount.
+    u8 pad[3];                                                         ///< Padding.
+    u32 selected_id;                                                   ///< \ref HidNpadIdType, selectedId.
+} HidLaControllerSupportResultInfo;
+
+/// Struct for the applet output storage.
+typedef struct {
+    HidLaControllerSupportResultInfo info;                             ///< \ref HidLaControllerSupportResultInfo
+    u32 res;                                                           ///< Output res value.
+} HidLaControllerSupportResultInfoInternal;
+
+/**
+ * @brief Initializes a \ref HidLaControllerSupportArg with the defaults.
+ * @note This clears the arg, then does: HidLaControllerSupportArgHeader::player_count_min = 0, HidLaControllerSupportArgHeader::player_count_max = 4, HidLaControllerSupportArgHeader::enable_take_over_connection = 1, HidLaControllerSupportArgHeader::enable_left_justify = 1, and HidLaControllerSupportArgHeader::enable_permit_joy_dual = 1.
+ * @note If preferred, you can also memset \ref HidLaControllerSupportArg manually and initialize it yourself.
+ * @param[out] arg \ref HidLaControllerSupportArg
+ */
+void hidLaCreateControllerSupportArg(HidLaControllerSupportArg *arg);
+
+/**
+ * @brief Initializes a \ref HidLaControllerFirmwareUpdateArg with the defaults.
+ * @note This just uses memset() with the arg.
+ * @param[out] arg \ref HidLaControllerFirmwareUpdateArg
+ */
+void hidLaCreateControllerFirmwareUpdateArg(HidLaControllerFirmwareUpdateArg *arg);
+
+/**
+ * @brief Initializes a \ref HidLaControllerKeyRemappingArg with the defaults.
+ * @note This just uses memset() with the arg.
+ * @param[out] arg \ref HidLaControllerKeyRemappingArg
+ */
+void hidLaCreateControllerKeyRemappingArg(HidLaControllerKeyRemappingArg *arg);
+
+/**
+ * @brief Sets the ExplainText for the specified player and \ref HidLaControllerSupportArg.
+ * @note This string is displayed in the UI box for the player.
+ * @note HidLaControllerSupportArg::enable_explain_text must be set, otherwise this ExplainText is ignored.
+ * @param arg \ref HidLaControllerSupportArg
+ * @param[in] str Input ExplainText UTF-8 string, max length is 0x80 excluding NUL-terminator.
+ + @oaram[in] id Player controller, must be <8.
+ */
+Result hidLaSetExplainText(HidLaControllerSupportArg *arg, const char *str, HidNpadIdType id);
+
+/**
+ * @brief Launches the applet for ControllerSupport.
+ * @note This seems to only display the applet UI when doing so is actually needed? This doesn't apply to \ref hidLaShowControllerSupportForSystem.
+ * @param[out] result_info \ref HidLaControllerSupportResultInfo. Optional, can be NULL.
+ * @param[in] arg \ref HidLaControllerSupportArg
+ */
+Result hidLaShowControllerSupport(HidLaControllerSupportResultInfo *result_info, const HidLaControllerSupportArg *arg);
+
+/**
+ * @brief Launches the applet for ControllerStrapGuide.
+ * @note Only available on [3.0.0+].
+ */
+Result hidLaShowControllerStrapGuide(void);
+
+/**
+ * @brief Launches the applet for ControllerFirmwareUpdate.
+ * @note Only available on [3.0.0+].
+ * @param[in] arg \ref HidLaControllerFirmwareUpdateArg
+ */
+Result hidLaShowControllerFirmwareUpdate(const HidLaControllerFirmwareUpdateArg *arg);
+
+/**
+ * @brief This is the system version of \ref hidLaShowControllerSupport.
+ * @param[out] result_info \ref HidLaControllerSupportResultInfo. Optional, can be NULL.
+ * @param[in] arg \ref HidLaControllerSupportArg
+ * @param[in] flag Input flag. When true, the applet displays the menu as if launched by qlaunch.
+ */
+Result hidLaShowControllerSupportForSystem(HidLaControllerSupportResultInfo *result_info, const HidLaControllerSupportArg *arg, bool flag);
+
+/**
+ * @brief This is the system version of \ref hidLaShowControllerFirmwareUpdate.
+ * @note Only available on [3.0.0+].
+ * @param[in] arg \ref HidLaControllerFirmwareUpdateArg
+ * @param[in] caller \ref HidLaControllerSupportCaller
+ */
+Result hidLaShowControllerFirmwareUpdateForSystem(const HidLaControllerFirmwareUpdateArg *arg, HidLaControllerSupportCaller caller);
+
+/**
+ * @brief Launches the applet for ControllerKeyRemappingForSystem.
+ * @note Only available on [11.0.0+].
+ * @param[in] arg \ref HidLaControllerKeyRemappingArg
+ * @param[in] caller \ref HidLaControllerSupportCaller
+ */
+Result hidLaShowControllerKeyRemappingForSystem(const HidLaControllerKeyRemappingArg *arg, HidLaControllerSupportCaller caller);
+

nx/include/switch/applets/libapplet.h

@@ -0,0 +1,136 @@
+/**
+ * @file libapplet.h
+ * @brief LibraryApplet wrapper.
+ * @author yellows8
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+#include "../services/applet.h"
+#include "../services/acc.h"
+
+/// CommonArguments
+typedef struct {
+    u32 CommonArgs_version;  ///< \ref libappletArgsCreate sets this to 1, and \ref libappletArgsPop requires value 1. v0 is not supported.
+    u32 CommonArgs_size;     ///< Size of this struct.
+
+    u32 LaVersion;           ///< LibraryApplet API version.
+    s32 ExpectedThemeColor;  ///< Set to the output from \ref appletGetThemeColorType by \ref libappletArgsCreate.
+    u8  PlayStartupSound;    ///< bool flag, default is false.
+    u8  pad[7];              ///< Padding.
+    u64 tick;                ///< System tick. Set to the output from \ref armGetSystemTick during \ref libappletArgsPush.
+} LibAppletArgs;
+
+/**
+ * @brief Creates a LibAppletArgs struct.
+ * @param a LibAppletArgs struct.
+ * @param version LaVersion for \ref LibAppletArgs.
+ */
+void libappletArgsCreate(LibAppletArgs* a, u32 version);
+
+/**
+ * @brief Sets the PlayStartupSound field in \ref LibAppletArgs.
+ * @param a LibAppletArgs struct.
+ * @param flag Value for \ref LibAppletArgs PlayStartupSound.
+ */
+void libappletArgsSetPlayStartupSound(LibAppletArgs* a, bool flag);
+
+/**
+ * @brief Creates an AppletStorage with the specified size and writes the buffer contents to that storage at offset 0.
+ * @param[out] s Storage object.
+ * @param buffer Input buffer.
+ * @param size Size to write.
+ */
+Result libappletCreateWriteStorage(AppletStorage* s, const void* buffer, size_t size);
+
+/**
+ * @brief Reads data from offset 0 from the specified storage into the buffer. If the storage-size is smaller than the size param, the storage-size is used instead.
+ * @param s Storage object.
+ * @param buffer Output buffer.
+ * @param size Size to read.
+ * @param transfer_size Optional output size field for the actual size used for the read, can be NULL.
+ */
+Result libappletReadStorage(AppletStorage* s, void* buffer, size_t size, size_t *transfer_size);
+
+/**
+ * @brief Sets the tick field in LibAppletArgs, then creates a storage with it which is pushed to the AppletHolder via \ref appletHolderPushInData.
+ * @param a LibAppletArgs struct.
+ * @param h AppletHolder object.
+ */
+Result libappletArgsPush(LibAppletArgs* a, AppletHolder *h);
+
+/**
+ * @brief Uses \ref appletPopInData and reads it to the specified LibAppletArgs. The LibAppletArgs is validated, an error is thrown when invalid.
+ * @param[out] a LibAppletArgs struct.
+ */
+Result libappletArgsPop(LibAppletArgs* a);
+
+/**
+ * @brief Creates a storage using the input buffer which is pushed to the AppletHolder via \ref appletHolderPushInData.
+ * @param h AppletHolder object.
+ * @param buffer Input data buffer.
+ * @param size Input data size.
+ */
+Result libappletPushInData(AppletHolder *h, const void* buffer, size_t size);
+
+/**
+ * @brief Pops a storage via \ref appletHolderPopOutData, uses \ref libappletReadStorage, then closes the storage. 
+ * @param h AppletHolder object.
+ * @param buffer Output buffer.
+ * @param size Size to read.
+ * @param transfer_size Optional output size field for the actual size used for the read, can be NULL.
+ */
+Result libappletPopOutData(AppletHolder *h, void* buffer, size_t size, size_t *transfer_size);
+
+/**
+ * @brief Sets whether \ref libappletStart uses \ref appletHolderJump.
+ * @param flag Flag. Value true should not be used unless running as AppletType_LibraryApplet.
+ */
+void libappletSetJumpFlag(bool flag);
+
+/**
+ * @brief If the flag from \ref libappletSetJumpFlag is set, this just uses \ref appletHolderJump. Otherwise, starts the applet and waits for it to finish, then checks the \ref LibAppletExitReason.
+ * @note Uses \ref appletHolderStart and \ref appletHolderJoin.
+ * @param h AppletHolder object.
+ */
+Result libappletStart(AppletHolder *h);
+
+/**
+ * @brief Creates a LibraryApplet with the specified input storage data, uses \ref libappletStart, and reads the output storage reply data via \ref libappletPopOutData.
+ * @param id \ref AppletId
+ * @param commonargs \ref LibAppletArgs struct.
+ * @param arg Input storage data buffer. Optional, can be NULL.
+ * @param arg_size Size of the arg buffer.
+ * @param reply Output storage data buffer. Optional, can be NULL.
+ * @param reply_size Size to read for the reply buffer.
+ * @param out_reply_size Actual read reply data size, see \ref libappletPopOutData.
+ */
+Result libappletLaunch(AppletId id, LibAppletArgs *commonargs, const void* arg, size_t arg_size, void* reply, size_t reply_size, size_t *out_reply_size);
+
+/// Wrapper for \ref appletPushToGeneralChannel, see appletPushToGeneralChannel regarding the requirements for using this.
+/// Returns to the main Home Menu, equivalent to pressing the HOME button.
+Result libappletRequestHomeMenu(void);
+
+/// Wrapper for \ref appletPushToGeneralChannel, see appletPushToGeneralChannel regarding the requirements for using this.
+/// Equivalent to entering "System Update" under System Settings. When leaving this, it returns to the main Home Menu.
+Result libappletRequestJumpToSystemUpdate(void);
+
+/**
+ * @brief Wrapper for \ref appletPushToGeneralChannel, see appletPushToGeneralChannel regarding the requirements for using this.
+ * @note Only available on [11.0.0+].
+ * @param[in] application_id ApplicationId
+ * @param[in] uid \ref AccountUid
+ * @param[in] buffer Input buffer.
+ * @param[in] size Input buffer size.
+ * @param[in] sender LaunchApplicationRequestSender
+ */
+Result libappletRequestToLaunchApplication(u64 application_id, AccountUid uid, const void* buffer, size_t size, u32 sender);
+
+/**
+ * @brief Wrapper for \ref appletPushToGeneralChannel, see appletPushToGeneralChannel regarding the requirements for using this.
+ * @note Only available on [11.0.0+].
+ * @param[in] uid \ref AccountUid
+ * @param[in] application_id Optional ApplicationId, can be 0.
+ */
+Result libappletRequestJumpToStory(AccountUid uid, u64 application_id);
+

nx/include/switch/applets/mii_la.h

@@ -0,0 +1,101 @@
+/**
+ * @file mii_la.h
+ * @brief Wrapper for using the MiiEdit LibraryApplet.
+ * @author yellows8
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+#include "../services/mii.h"
+
+/// AppletMode
+typedef enum {
+    MiiLaAppletMode_ShowMiiEdit         = 0,   ///< ShowMiiEdit
+    MiiLaAppletMode_AppendMii           = 1,   ///< AppendMii
+    MiiLaAppletMode_AppendMiiImage      = 2,   ///< AppendMiiImage
+    MiiLaAppletMode_UpdateMiiImage      = 3,   ///< UpdateMiiImage
+    MiiLaAppletMode_CreateMii           = 4,   ///< [10.2.0+] CreateMii
+    MiiLaAppletMode_EditMii             = 5,   ///< [10.2.0+] EditMii
+} MiiLaAppletMode;
+
+/// AppletInput
+typedef struct {
+    s32 version;               ///< Version
+    u32 mode;                  ///< \ref MiiLaAppletMode
+    s32 special_key_code;      ///< \ref MiiSpecialKeyCode
+    union {
+        Uuid valid_uuid_array[8];  ///< ValidUuidArray. Only used with \ref MiiLaAppletMode ::NfpLaMiiLaAppletMode_AppendMiiImage / ::NfpLaMiiLaAppletMode_UpdateMiiImage.
+        struct {
+            MiiCharInfo char_info;     ///< \ref MiiCharInfo
+            u8 unused_x64[0x28];       ///< Unused
+        } char_info;
+    };
+    Uuid used_uuid;            ///< UsedUuid. Only used with \ref MiiLaAppletMode ::NfpLaMiiLaAppletMode_UpdateMiiImage.
+    u8 unk_x9C[0x64];          ///< Unused
+} MiiLaAppletInput;
+
+/// AppletOutput
+typedef struct {
+    u32 res;                   ///< Result: 0 = Success, 1 = Cancel.
+    s32 index;                 ///< Index. Only set when Result is Success, where \ref MiiLaAppletMode isn't ::NfpLaMiiLaAppletMode_ShowMiiEdit.
+    u8 unk_x8[0x18];           ///< Unused
+} MiiLaAppletOutput;
+
+/// AppletOutputForCharInfoEditing
+typedef struct {
+    u32 res;                   ///< MiiLaAppletOutput::res
+    MiiCharInfo char_info;     ///< \ref MiiCharInfo
+    u8 unused[0x24];           ///< Unused
+} MiiLaAppletOutputForCharInfoEditing;
+
+/**
+ * @brief Launches the applet for ShowMiiEdit.
+ * @param[in] special_key_code \ref MiiSpecialKeyCode
+ */
+Result miiLaShowMiiEdit(MiiSpecialKeyCode special_key_code);
+
+/**
+ * @brief Launches the applet for AppendMii.
+ * @param[in] special_key_code \ref MiiSpecialKeyCode
+ * @param[out] index Output Index.
+ */
+Result miiLaAppendMii(MiiSpecialKeyCode special_key_code, s32 *index);
+
+/**
+ * @brief Launches the applet for AppendMiiImage.
+ * @param[in] special_key_code \ref MiiSpecialKeyCode
+ * @param[in] valid_uuid_array Input array of Uuid.
+ * @param[in] count Total entries for the valid_uuid_array. Must be 0-8.
+ * @param[out] index Output Index.
+ */
+Result miiLaAppendMiiImage(MiiSpecialKeyCode special_key_code, const Uuid *valid_uuid_array, s32 count, s32 *index);
+
+/**
+ * @brief Launches the applet for UpdateMiiImage.
+ * @param[in] special_key_code \ref MiiSpecialKeyCode
+ * @param[in] valid_uuid_array Input array of Uuid.
+ * @param[in] count Total entries for the valid_uuid_array. Must be 0-8.
+ * @param[in] used_uuid UsedUuid
+ * @param[out] index Output Index.
+ */
+Result miiLaUpdateMiiImage(MiiSpecialKeyCode special_key_code, const Uuid *valid_uuid_array, s32 count, Uuid used_uuid, s32 *index);
+
+/**
+ * @brief Launches the applet for CreateMii.
+ * @note This creates a Mii and returns it, without saving it in the database.
+ * @note Only available on [10.2.0+].
+ * @param[in] special_key_code \ref MiiSpecialKeyCode
+ * @param[out] out_char \ref MiiCharInfo
+ */
+Result miiLaCreateMii(MiiSpecialKeyCode special_key_code, MiiCharInfo *out_char);
+
+/**
+ * @brief Launches the applet for EditMii.
+ * @note This edits the specified Mii and returns it, without saving it in the database.
+ * @note Only available on [10.2.0+].
+ * @param[in] special_key_code \ref MiiSpecialKeyCode
+ * @param[in] in_char \ref MiiCharInfo
+ * @param[out] out_char \ref MiiCharInfo
+ */
+Result miiLaEditMii(MiiSpecialKeyCode special_key_code, const MiiCharInfo *in_char, MiiCharInfo *out_char);
+

nx/include/switch/applets/nfp_la.h

@@ -0,0 +1,89 @@
+/**
+ * @file nfp_la.h
+ * @brief Wrapper for using the cabinet (amiibo) LibraryApplet.
+ * @author yellows8
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+#include "../services/nfc.h"
+
+/// Values for NfpLaStartParamForAmiiboSettings::type.
+typedef enum {
+    NfpLaStartParamTypeForAmiiboSettings_NicknameAndOwnerSettings = 0,   ///< NicknameAndOwnerSettings
+    NfpLaStartParamTypeForAmiiboSettings_GameDataEraser           = 1,   ///< GameDataEraser
+    NfpLaStartParamTypeForAmiiboSettings_Restorer                 = 2,   ///< Restorer
+    NfpLaStartParamTypeForAmiiboSettings_Formatter                = 3,   ///< Formatter
+} NfpLaStartParamTypeForAmiiboSettings;
+
+/// AmiiboSettingsStartParam
+typedef struct {
+    u8 unk_x0[0x8];                       ///< Unknown
+    u8 unk_x8[0x20];                      ///< Unknown
+    u8 unk_x28;                           ///< Unknown
+} NfpLaAmiiboSettingsStartParam;
+
+/// StartParamForAmiiboSettings
+typedef struct {
+    u8 unk_x0;                            ///< Unknown
+    u8 type;                              ///< \ref NfpLaStartParamTypeForAmiiboSettings
+    u8 flags;                             ///< Flags
+    u8 unk_x3;                            ///< NfpLaAmiiboSettingsStartParam::unk_x28
+    u8 unk_x4[0x8];                       ///< NfpLaAmiiboSettingsStartParam::unk_x0
+    NfpTagInfo tag_info;                  ///< \ref NfpTagInfo, only enabled when flags bit1 is set.
+    NfpRegisterInfo register_info;        ///< \ref NfpRegisterInfo, only enabled when flags bit2 is set.
+    u8 unk_x164[0x20];                    ///< NfpLaAmiiboSettingsStartParam::unk_x8
+    u8 unk_x184[0x24];                    ///< Unknown
+} NfpLaStartParamForAmiiboSettings;
+
+/// ReturnValueForAmiiboSettings
+typedef struct {
+    u8 flags;                             ///< 0 = error, non-zero = success.
+    u8 pad[3];                            ///< Padding
+    NfcDeviceHandle handle;               ///< \ref NfcDeviceHandle
+    NfpTagInfo tag_info;                  ///< \ref NfpTagInfo
+    NfpRegisterInfo register_info;        ///< \ref NfpRegisterInfo, only available when flags bit2 is set.
+    u8 unk_x164[0x24];                    ///< Unknown
+} NfpLaReturnValueForAmiiboSettings;
+
+/**
+ * @brief Launches the applet for NicknameAndOwnerSettings.
+ * @note Official sw does not expose functionality for using input/output \ref NfpTagInfo at the same time.
+ * @param[in] in_param \ref NfpLaAmiiboSettingsStartParam
+ * @param[in] in_tag_info \ref NfpTagInfo. Optional, can be NULL. If specified, this must match the scanned amiibo.
+ * @param[in] in_reg_info \ref NfpRegisterInfo. Optional, can be NULL. If specified, this sets the \ref NfpRegisterInfo which will be used for writing, with an option for the user to change it.
+ * @param[out] out_tag_info \ref NfpTagInfo. Optional, can be NULL.
+ * @param[out] handle \ref NfcDeviceHandle
+ * @param[out] reg_info_flag Flag indicating whether the data for out_reg_info is set. Optional, can be NULL.
+ * @param[out] out_reg_info \ref NfpRegisterInfo, see reg_info_flag. Optional, can be NULL.
+ */
+Result nfpLaStartNicknameAndOwnerSettings(const NfpLaAmiiboSettingsStartParam *in_param, const NfpTagInfo *in_tag_info, const NfpRegisterInfo *in_reg_info, NfpTagInfo *out_tag_info, NfcDeviceHandle *handle, bool *reg_info_flag, NfpRegisterInfo *out_reg_info);
+
+/**
+ * @brief Launches the applet for GameDataEraser.
+ * @note Official sw does not expose functionality for using input/output \ref NfpTagInfo at the same time.
+ * @param[in] in_param \ref NfpLaAmiiboSettingsStartParam
+ * @param[in] in_tag_info \ref NfpTagInfo. Optional, can be NULL. If specified, this must match the scanned amiibo.
+ * @param[out] out_tag_info \ref NfpTagInfo. Optional, can be NULL.
+ * @param[out] handle \ref NfcDeviceHandle
+ */
+Result nfpLaStartGameDataEraser(const NfpLaAmiiboSettingsStartParam *in_param, const NfpTagInfo *in_tag_info, NfpTagInfo *out_tag_info, NfcDeviceHandle *handle);
+
+/**
+ * @brief Launches the applet for Restorer.
+ * @note Official sw does not expose functionality for using input/output \ref NfpTagInfo at the same time.
+ * @param[in] in_param \ref NfpLaAmiiboSettingsStartParam
+ * @param[in] in_tag_info \ref NfpTagInfo. Optional, can be NULL. If specified, this must match the scanned amiibo.
+ * @param[out] out_tag_info \ref NfpTagInfo. Optional, can be NULL.
+ * @param[out] handle \ref NfcDeviceHandle
+ */
+Result nfpLaStartRestorer(const NfpLaAmiiboSettingsStartParam *in_param, const NfpTagInfo *in_tag_info, NfpTagInfo *out_tag_info, NfcDeviceHandle *handle);
+
+/**
+ * @brief Launches the applet for Formatter.
+ * @param[in] in_param \ref NfpLaAmiiboSettingsStartParam
+ * @param[out] out_tag_info \ref NfpTagInfo
+ * @param[out] handle \ref NfcDeviceHandle
+ */
+Result nfpLaStartFormatter(const NfpLaAmiiboSettingsStartParam *in_param, NfpTagInfo *out_tag_info, NfcDeviceHandle *handle);
+

nx/include/switch/applets/nifm_la.h

@@ -0,0 +1,16 @@
+/**
+ * @file nifm_la.h
+ * @brief Wrapper for using the nifm LibraryApplet (the launched applet varies).
+ * @author yellows8
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+#include "../services/nifm.h"
+
+/**
+ * @brief Uses \ref nifmGetResult, then on failure launches the applet.
+ * @param r \ref NifmRequest
+ */
+Result nifmLaHandleNetworkRequestResult(NifmRequest* r);
+

nx/include/switch/applets/pctlauth.h

@@ -0,0 +1,58 @@
+/**
+ * @file pctlauth.h
+ * @brief Wrapper for using the Parental Controls authentication LibraryApplet. This applet is used by qlaunch.
+ * @author yellows8
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+
+/// Type values for PctlAuthArg::type.
+typedef enum {
+    PctlAuthType_Show             = 0,  ///< ShowParentalAuthentication
+    PctlAuthType_RegisterPasscode = 1,  ///< RegisterParentalPasscode
+    PctlAuthType_ChangePasscode   = 2,  ///< ChangeParentalPasscode
+} PctlAuthType;
+
+/// Input arg storage for the applet.
+typedef struct {
+    u32 unk_x0;         ///< Always set to 0 by the user-process.
+    PctlAuthType type;  ///< \ref PctlAuthType
+    u8 arg0;            ///< Arg0
+    u8 arg1;            ///< Arg1
+    u8 arg2;            ///< Arg2
+    u8 pad;             ///< Padding
+} PctlAuthArg;
+
+/**
+ * @brief Launches the applet.
+ * @note Should not be used if a PIN is not already registered. See \ref pctlIsRestrictionEnabled.
+ * @param flag Input flag. false = temporarily disable Parental Controls. true = validate the input PIN.
+ */
+Result pctlauthShow(bool flag);
+
+/**
+ * @brief Launches the applet. Only available with [4.0.0+].
+ * @param arg0 Value for PctlAuthArg.arg0.
+ * @param arg1 Value for PctlAuthArg.arg1.
+ * @param arg2 Value for PctlAuthArg.arg2.
+ */
+Result pctlauthShowEx(u8 arg0, u8 arg1, u8 arg2);
+
+/**
+ * @brief Just calls: pctlauthShowEx(1, 0, 1). Launches the applet for checking the PIN, used when changing system-settings.
+ * @note Should not be used if a PIN is not already registered. See \ref pctlIsRestrictionEnabled.
+ */
+Result pctlauthShowForConfiguration(void);
+
+/**
+ * @brief Launches the applet for registering the Parental Controls PIN.
+ */
+Result pctlauthRegisterPasscode(void);
+
+/**
+ * @brief Launches the applet for changing the Parental Controls PIN.
+ * @note Should not be used if a PIN is not already registered. See \ref pctlIsRestrictionEnabled.
+ */
+Result pctlauthChangePasscode(void);
+

nx/include/switch/applets/psel.h

@@ -0,0 +1,210 @@
+/**
+ * @file psel.h
+ * @brief Wrapper for using the playerSelect (user selection) LibraryApplet.
+ * @author XorTroll, yellows8
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+#include "../services/acc.h"
+
+/// playerSelect UI modes.
+typedef enum {
+    PselUiMode_UserSelector                                            = 0,  ///< UserSelector
+    PselUiMode_UserCreator                                             = 1,  ///< UserCreator
+    PselUiMode_EnsureNetworkServiceAccountAvailable                    = 2,  ///< EnsureNetworkServiceAccountAvailable
+    PselUiMode_UserIconEditor                                          = 3,  ///< UserIconEditor
+    PselUiMode_UserNicknameEditor                                      = 4,  ///< UserNicknameEditor
+    PselUiMode_UserCreatorForStarter                                   = 5,  ///< UserCreatorForStarter
+    PselUiMode_NintendoAccountAuthorizationRequestContext              = 6,  ///< NintendoAccountAuthorizationRequestContext
+    PselUiMode_IntroduceExternalNetworkServiceAccount                  = 7,  ///< IntroduceExternalNetworkServiceAccount
+    PselUiMode_IntroduceExternalNetworkServiceAccountForRegistration   = 8,  ///< [6.0.0+] IntroduceExternalNetworkServiceAccountForRegistration
+    PselUiMode_NintendoAccountNnidLinker                               = 9,  ///< [6.0.0+] NintendoAccountNnidLinker
+    PselUiMode_LicenseRequirementsForNetworkService                    = 10, ///< [6.0.0+] LicenseRequirementsForNetworkService
+    PselUiMode_LicenseRequirementsForNetworkServiceWithUserContextImpl = 11, ///< [7.0.0+] LicenseRequirementsForNetworkServiceWithUserContextImpl
+    PselUiMode_UserCreatorForImmediateNaLoginTest                      = 12, ///< [7.0.0+] UserCreatorForImmediateNaLoginTest
+    PselUiMode_UserQualificationPromoter                               = 13, ///< [13.0.0+] UserQualificationPromoter
+} PselUiMode;
+
+/// UI message text to display with ::PselUiMode_UserSelector. Invalid values are handled as ::PselUserSelectionPurpose_General.
+typedef enum {
+    PselUserSelectionPurpose_General                                   = 0,  ///< "Select a user."
+    PselUserSelectionPurpose_GameCardRegistration                      = 1,  ///< [2.0.0+] "Who will receive the points?"
+    PselUserSelectionPurpose_EShopLaunch                               = 2,  ///< [2.0.0+] "Who is using Nintendo eShop?"
+    PselUserSelectionPurpose_EShopItemShow                             = 3,  ///< [2.0.0+] "Who is making this purchase?"
+    PselUserSelectionPurpose_PicturePost                               = 4,  ///< [2.0.0+] "Who is posting?"
+    PselUserSelectionPurpose_NintendoAccountLinkage                    = 5,  ///< [2.0.0+] "Select a user to link to a Nintendo Account."
+    PselUserSelectionPurpose_SettingsUpdate                            = 6,  ///< [2.0.0+] "Change settings for which user?"
+    PselUserSelectionPurpose_SaveDataDeletion                          = 7,  ///< [2.0.0+] "Format data for which user?"
+    PselUserSelectionPurpose_UserMigration                             = 8,  ///< [4.0.0+] "Which user will be transferred to another console?"
+    PselUserSelectionPurpose_SaveDataTransfer                          = 9,  ///< [8.0.0+] "Send save data for which user?"
+} PselUserSelectionPurpose;
+
+/// NintendoAccountStartupDialogType
+typedef enum {
+    PselNintendoAccountStartupDialogType_LoginAndCreate                = 0,  ///< LoginAndCreate
+    PselNintendoAccountStartupDialogType_Login                         = 1,  ///< Login
+    PselNintendoAccountStartupDialogType_Create                        = 2,  ///< Create
+} PselNintendoAccountStartupDialogType;
+
+/// Base UI settings for playerSelect.
+typedef struct {
+    u32 mode;                                          ///< \ref PselUiMode
+    u32 pad;                                           ///< Padding.
+    AccountUid invalid_uid_list[ACC_USER_LIST_SIZE];   ///< List of \ref AccountUid. TODO: This is only correct for ::PselUiMode_UserSelector, for other modes this is a single uid, followed by mode-specific data (if any).
+    u64 application_id;                                ///< ApplicationId with \ref pselShowUserSelectorForLauncher.
+    u8 is_network_service_account_required;            ///< PselUserSelectionSettings::is_network_service_account_required.
+    u8 is_skip_enabled;                                ///< PselUserSelectionSettings::is_skip_enabled
+    u8 unk_x92;                                        ///< Set to value 1 by \ref pselShowUserSelectorForSystem / \ref pselShowUserSelectorForLauncher.
+    u8 is_permitted;                                   ///< isPermitted. With ::PselUiMode_UserSelector: enables the option to create a new user. Set to the output from \ref accountIsUserRegistrationRequestPermitted with pselShowUserSelector*. When not set, a dialog will be displayed when the user attempts to create an user.
+    u8 show_skip_button;                               ///< PselUserSelectionSettings::show_skip_button
+    u8 additional_select;                              ///< PselUserSelectionSettings::additional_select
+    u8 unk_x96;                                        ///< [2.0.0+] Set to PselUserSelectionSettingsForSystemService::enable_user_creation_button. \ref pselShowUserSelectorForLauncher / \ref pselShowUserSelector sets this to value 1.
+    u8 unk_x97;                                        ///< [6.0.0+] Set to PselUserSelectionSettings::is_unqualified_user_selectable ^ 1.
+} PselUiSettingsV1;
+
+/// UI settings for versions starting with 0x10000.
+typedef struct {
+    PselUiSettingsV1 settings;                         ///< \ref PselUiSettingsV1
+    u32 unk_x98;                                       ///< [2.0.0+] Set to PselUserSelectionSettingsForSystemService::purpose.
+    u8 unk_x9c[0x4];                                   ///< Unknown.
+} PselUiSettings;
+
+/// UserSelectionSettings
+typedef struct {
+    AccountUid invalid_uid_list[ACC_USER_LIST_SIZE];   ///< invalidUidList.
+    u8 is_skip_enabled;                                ///< isSkipEnabled. When set, the first user in invalid_uid_list must not be set, and additional_select must be 0. When enabled \ref accountTrySelectUserWithoutInteraction will be used to select the user, in this case the applet will only be launched if \ref accountTrySelectUserWithoutInteraction doesn't return an user.
+    u8 is_network_service_account_required;            ///< isNetworkServiceAccountRequired. Whether the user needs to be linked to a Nintendo account.
+    u8 show_skip_button;                               ///< showSkipButton. Enables the option to skip user selection with a button.
+    u8 additional_select;                              ///< additionalSelect.
+    u8 is_unqualified_user_selectable;                 ///< [6.0.0+] isUnqualifiedUserSelectable
+} PselUserSelectionSettings;
+
+/// [2.0.0+] UserSelectionSettingsForSystemService
+typedef struct {
+    u32 purpose;                                       ///< \ref PselUserSelectionPurpose
+    u8 enable_user_creation_button;                    ///< Enables the user-creation button when set. Whether user-creation when pressing the button is actually allowed is controlled by PselUiSettingsV1::is_permitted.
+    u8 pad[0x3];                                       ///< Padding.
+} PselUserSelectionSettingsForSystemService;
+
+/// Return data sent after execution.
+typedef struct {
+    Result res;                                        ///< Result.
+    AccountUid user_id;                                ///< Selected \ref AccountUid.
+} PselUiReturnArg;
+
+/**
+ * @brief Creates a new UI config for the playerSelect applet with the specified mode.
+ * @param ui PseluiSettings struct.
+ * @param mode playerSelect UI mode.
+ */
+Result pselUiCreate(PselUiSettings *ui, PselUiMode mode);
+
+/**
+ * @brief Adds an user to the user list of the applet.
+ * @param ui PselUiSettings struct.
+ * @param[in] user_id user ID.
+ * @note The users will be treated as invalid users for user selection mode, and as the input user for other modes.
+ */
+void pselUiAddUser(PselUiSettings *ui, AccountUid user_id);
+
+/**
+ * @brief Sets whether users can be created in the applet.
+ * @param ui PselUiSettings struct.
+ * @param flag Flag value.
+ * @note Only used for ::PselUiMode_SelectUser.
+ */
+NX_CONSTEXPR void pselUiSetAllowUserCreation(PselUiSettings *ui, bool flag) {
+    if(ui->settings.mode == PselUiMode_UserSelector) {
+        ui->settings.is_permitted = flag!=0;
+    }
+}
+
+/**
+ * @brief Sets whether users need to be linked to a Nintendo account.
+ * @param ui PselUiSettings struct.
+ * @param flag Flag value.
+ */
+NX_CONSTEXPR void pselUiSetNetworkServiceRequired(PselUiSettings *ui, bool flag) {
+    ui->settings.is_network_service_account_required = flag;
+}
+
+/**
+ * @brief Sets whether selection can be skipped with a button.
+ * @param ui PselUiSettings struct.
+ * @param flag Flag value.
+ */
+NX_CONSTEXPR void pselUiSetSkipButtonEnabled(PselUiSettings *ui, bool flag) {
+    ui->settings.show_skip_button = flag!=0;
+}
+
+/**
+ * @brief Shows the applet with the specified UI settings.
+ * @param ui PselUiSettings struct.
+ * @param out_user Selected user ID.
+ * @note If user skips (see \ref pselUiSetSkipEnabled) this will return successfully but the output ID will be 0.
+ */
+Result pselUiShow(PselUiSettings *ui, AccountUid *out_user);
+
+/**
+ * @brief This is the System version of \ref pselShowUserSelector.
+ * @note This uses \ref accountIsUserRegistrationRequestPermitted, hence \ref accountInitialize must be used prior to this. See also the docs for PselUserSelectionSettings::is_skip_enabled.
+ * @param[out] out_user Returned selected user ID.
+ * @param[in] settings \ref PselUserSelectionSettings
+ * @param[in] settings_system [2.0.0+] \ref PselUserSelectionSettingsForSystemService, ignored on prior versions.
+ */
+Result pselShowUserSelectorForSystem(AccountUid *out_user, const PselUserSelectionSettings *settings, const PselUserSelectionSettingsForSystemService *settings_system);
+
+/**
+ * @brief This is the Launcher version of \ref pselShowUserSelector.
+ * @note This uses \ref accountIsUserRegistrationRequestPermitted, hence \ref accountInitialize must be used prior to this. See also the docs for PselUserSelectionSettings::is_skip_enabled.
+ * @param[out] out_user Returned selected user ID.
+ * @param[in] settings \ref PselUserSelectionSettings
+ * @param[in] application_id ApplicationId
+ */
+Result pselShowUserSelectorForLauncher(AccountUid *out_user, const PselUserSelectionSettings *settings, u64 application_id);
+
+/**
+ * @brief Shows the applet to select a user.
+ * @note This uses \ref accountIsUserRegistrationRequestPermitted, hence \ref accountInitialize must be used prior to this. See also the docs for PselUserSelectionSettings::is_skip_enabled.
+ * @param[out] out_user Returned selected user ID.
+ * @param[in] settings \ref PselUserSelectionSettings
+ */
+Result pselShowUserSelector(AccountUid *out_user, const PselUserSelectionSettings *settings);
+
+/**
+ * @brief Shows the applet to create a user.
+ * @note This uses \ref accountIsUserRegistrationRequestPermitted, hence \ref accountInitialize must be used prior to this. If the output flag is 0, an error will be thrown.
+ */
+Result pselShowUserCreator(void);
+
+/**
+ * @brief Shows the applet to change a user's icon.
+ * @param[in] user Input user ID.
+ */
+Result pselShowUserIconEditor(AccountUid user);
+
+/**
+ * @brief Shows the applet to change a user's nickname.
+ * @param[in] user Input user ID.
+ */
+Result pselShowUserNicknameEditor(AccountUid user);
+
+/**
+ * @brief Shows the applet to create a user. Used by the starter applet during system setup.
+ */
+Result pselShowUserCreatorForStarter(void);
+
+/**
+ * @brief Shows the applet for Nintendo Account Nnid linking.
+ * @note Only available on [6.0.0+].
+ * @param[in] user Input user ID.
+ */
+Result pselShowNintendoAccountNnidLinker(AccountUid user);
+
+/**
+ * @brief Shows the applet for UserQualificationPromoter.
+ * @note Only available on [13.0.0+].
+ * @param[in] user Input user ID.
+ */
+Result pselShowUserQualificationPromoter(AccountUid user);

nx/include/switch/applets/web.h

@@ -0,0 +1,862 @@
+/**
+ * @file web.h
+ * @brief Wrapper for using the web LibraryApplets. See also: https://switchbrew.org/wiki/Internet_Browser
+ * @author p-sam, yellows8
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+#include "../services/applet.h"
+#include "../services/caps.h"
+#include "../services/acc.h"
+#include "../kernel/mutex.h"
+
+/// This indicates the type of web-applet.
+typedef enum {
+    WebShimKind_Shop    = 1,
+    WebShimKind_Login   = 2,
+    WebShimKind_Offline = 3,
+    WebShimKind_Share   = 4,
+    WebShimKind_Web     = 5,
+    WebShimKind_Wifi    = 6,
+    WebShimKind_Lobby   = 7,
+} WebShimKind;
+
+/// ExitReason
+typedef enum {
+    WebExitReason_ExitButton  = 0x0,  ///< User pressed the X button to exit.
+    WebExitReason_BackButton  = 0x1,  ///< User pressed the B button to exit, on the initial page.
+    WebExitReason_Requested   = 0x2,  ///< The applet exited since \ref webConfigRequestExit was used.
+    WebExitReason_LastUrl     = 0x3,  ///< The applet exited due to LastUrl handling, see \ref webReplyGetLastUrl.
+    WebExitReason_ErrorDialog = 0x7,  ///< The applet exited after displaying an error dialog.
+    WebExitReason_UnknownE    = 0xE,  ///< Unknown
+} WebExitReason;
+
+/// Button values for \ref webConfigSetBootFooterButtonVisible.
+typedef enum {
+    WebFooterButtonId_None  = 0,  ///< None, for empty \ref WebBootFooterButtonEntry. Invalid for \ref webConfigSetBootFooterButtonVisible input.
+    WebFooterButtonId_Type1 = 1,  ///< Unknown button Id 1.
+    WebFooterButtonId_Type2 = 2,  ///< Unknown button Id 2.
+    WebFooterButtonId_Type3 = 3,  ///< Unknown button Id 3.
+    WebFooterButtonId_Type4 = 4,  ///< Unknown button Id 4.
+    WebFooterButtonId_Type5 = 5,  ///< Unknown button Id 5.
+    WebFooterButtonId_Type6 = 6,  ///< Unknown button Id 6.
+    WebFooterButtonId_Max,        ///< Values starting with this are invalid.
+} WebFooterButtonId;
+
+/// WebSessionBootMode
+typedef enum {
+    WebSessionBootMode_AllForeground                = 0,  ///< AllForeground. This is the default.
+    WebSessionBootMode_AllForegroundInitiallyHidden = 1,  ///< AllForegroundInitiallyHidden
+} WebSessionBootMode;
+
+/// WebSessionSendMessageKind
+typedef enum {
+    WebSessionSendMessageKind_BrowserEngineContent  = 0x0,     ///< BrowserEngine Content
+    WebSessionSendMessageKind_SystemMessageAppear   = 0x100,   ///< SystemMessage Appear
+    WebSessionSendMessageKind_Ack                   = 0x1000,  ///< Ack
+} WebSessionSendMessageKind;
+
+/// WebSessionReceiveMessageKind
+typedef enum {
+    WebSessionReceiveMessageKind_BrowserEngineContent  = 0x0,     ///< BrowserEngine Content
+    WebSessionReceiveMessageKind_AckBrowserEngine      = 0x1000,  ///< Ack BrowserEngine
+    WebSessionReceiveMessageKind_AckSystemMessage      = 0x1001,  ///< Ack SystemMessage
+} WebSessionReceiveMessageKind;
+
+/// Struct for the WebWifi applet input storage.
+typedef struct {
+    u32 unk_x0;                 ///< Official sw sets this to 0 with appletStorageWrite, separately from the rest of the config struct.
+    char conntest_url[0x100];   ///< Connection-test URL.
+    char initial_url[0x400];    ///< Initial URL navigated to by the applet.
+    Uuid uuid;                  ///< NIFM Network UUID. Only used by the applet when conntest_url is set.
+    u32 rev;                    ///< Input value for nifm cmd SetRequirementByRevision. Only used by the applet when conntest_url is set.
+} WebWifiPageArg;
+
+/// Struct for the WebWifi applet output storage.
+typedef struct {
+    u32 unk_x0;  ///< Unknown.
+    Result res;  ///< Result
+} WebWifiReturnValue;
+
+/// Config for WebWifi.
+typedef struct {
+    WebWifiPageArg arg;  ///< Arg data.
+} WebWifiConfig;
+
+/// TLV storage, starts with \ref WebArgHeader followed by \ref WebArgTLV entries.
+typedef struct {
+    u8 data[0x2000];    ///< Raw TLV data storage.
+} WebCommonTLVStorage;
+
+/// Common struct for the applet output storage, for non-TLV-storage.
+typedef struct {
+    WebExitReason exitReason;    ///< ExitReason
+    u32 pad;                     ///< Padding
+    char lastUrl[0x1000];        ///< LastUrl string
+    u64 lastUrlSize;             ///< Size of LastUrl, including NUL-terminator.
+} NX_PACKED WebCommonReturnValue;
+
+/// Header struct at offset 0 in the web Arg storage (non-webWifi).
+typedef struct {
+    u16 total_entries;     ///< Total \ref WebArgTLV entries following this struct.
+    u16 pad;               ///< Padding
+    WebShimKind shimKind;  ///< ShimKind
+} NX_PACKED WebArgHeader;
+
+/// Web TLV used in the web Arg storage.
+typedef struct {
+    u16 type;       ///< Type of this arg.
+    u16 size;       ///< Size of the arg data following this struct.
+    u8 pad[4];      ///< Padding
+} NX_PACKED WebArgTLV;
+
+/// Config struct for web applets, non-WebWifi.
+typedef struct {
+    WebCommonTLVStorage arg;  ///< TLV storage.
+    AppletId appletid;        ///< AppletId
+    u32 version;              ///< CommonArgs applet version.
+    AppletHolder holder;      ///< AppletHolder
+} WebCommonConfig;
+
+/// Common container struct for applets' reply data, from the output storage.
+typedef struct {
+    bool type;                     ///< Type of reply: false = ret, true = storage.
+    WebShimKind shimKind;          ///< ShimKind
+    WebCommonReturnValue ret;      ///< Reply data for reply=false.
+    WebCommonTLVStorage storage;   ///< Reply data for reply=true.
+} WebCommonReply;
+
+/// Entry data for ::WebArgType_BootFooterButton.
+typedef struct {
+    WebFooterButtonId id;
+    u8 visible;
+    u16 unk_x5;
+    u8 unk_x7;
+} NX_PACKED WebBootFooterButtonEntry;
+
+/// StorageHandleQueue
+typedef struct {
+    s32 read_pos;
+    s32 write_pos;
+    s32 max_storages;
+    bool is_full;
+    AppletStorage storages[0x10];
+} WebSessionStorageHandleQueue;
+
+/// WebSession
+typedef struct {
+    Mutex mutex;
+    WebCommonConfig *config;
+    struct {
+        u32 count;
+        u32 cur_size;
+    } queue[2];
+    WebSessionStorageHandleQueue storage_queue;
+} WebSession;
+
+/// SessionMessageHeader
+typedef struct {
+    u32 kind;                      ///< Message Kind (\ref WebSessionSendMessageKind / \ref WebSessionReceiveMessageKind)
+    u32 size;                      ///< Data size following the header.
+    u8 reserved[0x8];              ///< Unused
+} WebSessionMessageHeader;
+
+/// Types for \ref WebArgTLV, input storage.
+typedef enum {
+    WebArgType_Url                                      = 0x1,    ///< [1.0.0+] String, size 0xC00. Initial URL.
+    WebArgType_CallbackUrl                              = 0x3,    ///< [1.0.0+] String, size 0x400.
+    WebArgType_CallbackableUrl                          = 0x4,    ///< [1.0.0+] String, size 0x400.
+    WebArgType_ApplicationId                            = 0x5,    ///< [1.0.0+] Offline-applet, u64 ApplicationId
+    WebArgType_DocumentPath                             = 0x6,    ///< [1.0.0+] Offline-applet, string with size 0xC00.
+    WebArgType_DocumentKind                             = 0x7,    ///< [1.0.0+] Offline-applet, u32 enum \WebDocumentKind.
+    WebArgType_SystemDataId                             = 0x8,    ///< [1.0.0+] Offline-applet, u64 SystemDataId
+    WebArgType_ShareStartPage                           = 0x9,    ///< [1.0.0+] u32 enum \WebShareStartPage
+    WebArgType_Whitelist                                = 0xA,    ///< [1.0.0+] String, size 0x1000.
+    WebArgType_NewsFlag                                 = 0xB,    ///< [1.0.0+] u8 bool
+    WebArgType_UnknownC                                 = 0xC,    ///< [1.0.0+] u8
+    WebArgType_UnknownD                                 = 0xD,    ///< [1.0.0+] u8
+    WebArgType_Uid                                      = 0xE,    ///< [1.0.0+] \ref AccountUid, controls which user-specific savedata to mount.
+    WebArgType_AlbumEntry0                              = 0xF,    ///< [1.0.0+] Share-applet caps AlbumEntry, entry 0.
+    WebArgType_ScreenShot                               = 0x10,   ///< [1.0.0+] u8 bool
+    WebArgType_EcClientCert                             = 0x11,   ///< [1.0.0+] u8 bool
+    WebArgType_Unknown12                                = 0x12,   ///< [1.0.0+] u8
+    WebArgType_PlayReport                               = 0x13,   ///< [1.0.0+] u8 bool
+    WebArgType_Unknown14                                = 0x14,   ///< [1.0.0+] u8
+    WebArgType_Unknown15                                = 0x15,   ///< [1.0.0+] u8
+    WebArgType_BootDisplayKind                          = 0x17,   ///< [1.0.0+] u32 enum \ref WebBootDisplayKind
+    WebArgType_BackgroundKind                           = 0x18,   ///< [1.0.0+] u32 enum \ref WebBackgroundKind
+    WebArgType_Footer                                   = 0x19,   ///< [1.0.0+] u8 bool
+    WebArgType_Pointer                                  = 0x1A,   ///< [1.0.0+] u8 bool
+    WebArgType_LeftStickMode                            = 0x1B,   ///< [1.0.0+] u32 enum \ref WebLeftStickMode
+    WebArgType_KeyRepeatFrame0                          = 0x1C,   ///< [1.0.0+] s32 KeyRepeatFrame, first param
+    WebArgType_KeyRepeatFrame1                          = 0x1D,   ///< [1.0.0+] s32 KeyRepeatFrame, second param
+    WebArgType_BootAsMediaPlayerInverted                = 0x1E,   ///< [1.0.0+] u8 bool. With News on [3.0.0+] this is set after BootAsMediaPlayer with the value inverted.
+    WebArgType_DisplayUrlKind                           = 0x1F,   ///< [1.0.0+] u8 bool, DisplayUrlKind (value = (input_enumval==0x1)).
+    WebArgType_BootAsMediaPlayer                        = 0x21,   ///< [2.0.0+] u8 bool
+    WebArgType_ShopJump                                 = 0x22,   ///< [2.0.0+] u8 bool
+    WebArgType_MediaPlayerUserGestureRestriction        = 0x23,   ///< [2.0.0-5.1.0] u8 bool
+    WebArgType_MediaAutoPlay                            = 0x23,   ///< [6.0.0+] u8 bool
+    WebArgType_LobbyParameter                           = 0x24,   ///< [2.0.0+] String, size 0x100.
+    WebArgType_ApplicationAlbumEntry                    = 0x26,   ///< [3.0.0+] Share-applet caps ApplicationAlbumEntry
+    WebArgType_JsExtension                              = 0x27,   ///< [3.0.0+] u8 bool
+    WebArgType_AdditionalCommentText                    = 0x28,   ///< [4.0.0+] String, size 0x100. Share-applet AdditionalCommentText.
+    WebArgType_TouchEnabledOnContents                   = 0x29,   ///< [4.0.0+] u8 bool
+    WebArgType_UserAgentAdditionalString                = 0x2A,   ///< [4.0.0+] String, size 0x80.
+    WebArgType_AdditionalMediaData0                     = 0x2B,   ///< [4.0.0+] Share-applet 0x10-byte u8 array, AdditionalMediaData. Entry 0. If the user-input size is less than 0x10, the remaining data used for the TLV is cleared.
+    WebArgType_MediaPlayerAutoClose                     = 0x2C,   ///< [4.0.0+] u8 bool
+    WebArgType_PageCache                                = 0x2D,   ///< [4.0.0+] u8 bool
+    WebArgType_WebAudio                                 = 0x2E,   ///< [4.0.0+] u8 bool
+    WebArgType_2F                                       = 0x2F,   ///< [5.0.0+] u8
+    WebArgType_YouTubeVideoFlag                         = 0x31,   ///< [5.0.0+] u8 bool Indicates that the built-in whitelist for YouTubeVideo should be used.
+    WebArgType_FooterFixedKind                          = 0x32,   ///< [5.0.0+] u32 enum \ref WebFooterFixedKind
+    WebArgType_PageFade                                 = 0x33,   ///< [5.0.0+] u8 bool
+    WebArgType_MediaCreatorApplicationRatingAge         = 0x34,   ///< [5.0.0+] Share-applet 0x20-byte s8 array, MediaCreatorApplicationRatingAge.
+    WebArgType_BootLoadingIcon                          = 0x35,   ///< [5.0.0+] u8 bool
+    WebArgType_PageScrollIndicator                      = 0x36,   ///< [5.0.0+] u8 bool
+    WebArgType_MediaPlayerSpeedControl                  = 0x37,   ///< [6.0.0+] u8 bool
+    WebArgType_AlbumEntry1                              = 0x38,   ///< [6.0.0+] Share-applet caps AlbumEntry, entry 1.
+    WebArgType_AlbumEntry2                              = 0x39,   ///< [6.0.0+] Share-applet caps AlbumEntry, entry 2.
+    WebArgType_AlbumEntry3                              = 0x3A,   ///< [6.0.0+] Share-applet caps AlbumEntry, entry 3.
+    WebArgType_AdditionalMediaData1                     = 0x3B,   ///< [6.0.0+] Share-applet 0x10-byte u8 array, AdditionalMediaData. Entry 1.
+    WebArgType_AdditionalMediaData2                     = 0x3C,   ///< [6.0.0+] Share-applet 0x10-byte u8 array, AdditionalMediaData. Entry 2.
+    WebArgType_AdditionalMediaData3                     = 0x3D,   ///< [6.0.0+] Share-applet 0x10-byte u8 array, AdditionalMediaData. Entry 3.
+    WebArgType_BootFooterButton                         = 0x3E,   ///< [6.0.0+] Array of \ref WebBootFooterButtonEntry with 0x10 entries.
+    WebArgType_OverrideWebAudioVolume                   = 0x3F,   ///< [6.0.0+] float
+    WebArgType_OverrideMediaAudioVolume                 = 0x40,   ///< [6.0.0+] float
+    WebArgType_SessionBootMode                          = 0x41,   ///< [7.0.0+] u32 enum \ref WebSessionBootMode
+    WebArgType_SessionFlag                              = 0x42,   ///< [7.0.0+] u8 bool, enables using WebSession when set.
+    WebArgType_MediaPlayerUi                            = 0x43,   ///< [8.0.0+] u8 bool
+    WebArgType_TransferMemory                           = 0x44,   ///< [11.0.0+] u8 bool
+} WebArgType;
+
+/// Types for \ref WebArgTLV, output storage.
+typedef enum {
+    WebReplyType_ExitReason                        = 0x1,  ///< [3.0.0+] u32 ExitReason
+    WebReplyType_LastUrl                           = 0x2,  ///< [3.0.0+] string
+    WebReplyType_LastUrlSize                       = 0x3,  ///< [3.0.0+] u64
+    WebReplyType_SharePostResult                   = 0x4,  ///< [3.0.0+] u32 SharePostResult
+    WebReplyType_PostServiceName                   = 0x5,  ///< [3.0.0+] string
+    WebReplyType_PostServiceNameSize               = 0x6,  ///< [3.0.0+] u64
+    WebReplyType_PostId                            = 0x7,  ///< [3.0.0+] string
+    WebReplyType_PostIdSize                        = 0x8,  ///< [3.0.0+] u64
+    WebReplyType_MediaPlayerAutoClosedByCompletion = 0x9,  ///< [8.0.0+] u8 bool
+} WebReplyType;
+
+/// This controls the kind of content to mount with Offline-applet.
+typedef enum {
+    WebDocumentKind_OfflineHtmlPage             = 0x1,  ///< Use the HtmlDocument NCA content from the application.
+    WebDocumentKind_ApplicationLegalInformation = 0x2,  ///< Use the LegalInformation NCA content from the application.
+    WebDocumentKind_SystemDataPage              = 0x3,  ///< Use the Data NCA content from the specified SystemData, see also: https://switchbrew.org/wiki/Title_list#System_Data_Archives
+} WebDocumentKind;
+
+/// This controls the initial page for ShareApplet, used by \ref webShareCreate.
+typedef enum {
+    WebShareStartPage_Default  = 0,  ///< The default "/" page.
+    WebShareStartPage_Settings = 1,  ///< The "/settings/" page.
+} WebShareStartPage;
+
+/// Kind values for \ref webConfigSetBootDisplayKind. Controls the background color while displaying the loading screen during applet boot. Also controls the BackgroundKind when value is non-zero.
+typedef enum {
+    WebBootDisplayKind_Default  = 0,    ///< Default. BackgroundKind is controlled by \ref WebBackgroundKind.
+    WebBootDisplayKind_White    = 1,    ///< White background. Used by \ref webOfflineCreate for docKind ::WebDocumentKind_ApplicationLegalInformation/::WebDocumentKind_SystemDataPage.
+    WebBootDisplayKind_Black    = 2,    ///< Black background.
+    WebBootDisplayKind_Unknown3 = 3,    ///< Unknown. Used by \ref webShareCreate.
+    WebBootDisplayKind_Unknown4 = 4,    ///< Unknown. Used by \ref webLobbyCreate.
+} WebBootDisplayKind;
+
+/// Kind values for \ref webConfigSetBackgroundKind. Controls the background color while displaying the loading screen during applet boot. Only used when \ref WebBootDisplayKind is ::WebBootDisplayKind_Default. If the applet was not launched by an Application, the applet will only use WebBackgroundKind_Default.
+typedef enum {
+    WebBackgroundKind_Default  = 0,    ///< Default. Same as ::WebBootDisplayKind_White/::WebBootDisplayKind_Black, determined via ::WebArgType_BootAsMediaPlayer.
+    WebBackgroundKind_Unknown1 = 1,    ///< Unknown. Same as ::WebBootDisplayKind_Unknown3.
+    WebBackgroundKind_Unknown2 = 2,    ///< Unknown. Same as ::WebBootDisplayKind_Unknown4. Used by \ref webLobbyCreate.
+} WebBackgroundKind;
+
+/// Mode values for \ref webConfigSetLeftStickMode. Controls the initial mode, this can be toggled by the user via the pressing the left-stick button. If the Pointer flag is set to false (\ref webConfigSetPointer), only ::WebLeftStickMode_Cursor will be used and mode toggle by the user is disabled (input value ignored).
+typedef enum {
+    WebLeftStickMode_Pointer = 0,  ///< The user can directly control the pointer via the left-stick.
+    WebLeftStickMode_Cursor  = 1,  ///< The user can only select elements on the page via the left-stick.
+} WebLeftStickMode;
+
+/// Kind values for \ref webConfigSetFooterFixedKind. Controls UI footer display behaviour.
+typedef enum {
+    WebFooterFixedKind_Default = 0,  ///< Default. Footer is hidden while scrolling.
+    WebFooterFixedKind_Always  = 1,  ///< Footer is always displayed regardless of scrolling.
+    WebFooterFixedKind_Hidden  = 2,  ///< Footer is hidden regardless of scrolling.
+} WebFooterFixedKind;
+
+/**
+ * @brief Creates the config for WifiWebAuthApplet. This is the captive portal applet.
+ * @param config WebWifiConfig object.
+ * @param conntest_url URL used for the connection-test requests. When empty/NULL the applet will test the connection with nifm and throw an error on failure.
+ * @param initial_url Initial URL navigated to by the applet.
+ * @param uuid NIFM Network UUID, for nifm cmd SetNetworkProfileId. Value 0 can be used. Only used by the applet when conntest_url is set.
+ * @param rev Input value for nifm cmd SetRequirementByRevision. Value 0 can be used. Only used by the applet when conntest_url is set.
+ */
+void webWifiCreate(WebWifiConfig* config, const char* conntest_url, const char* initial_url, Uuid uuid, u32 rev);
+
+/**
+ * @brief Launches WifiWebAuthApplet with the specified config and waits for it to exit.
+ * @param config WebWifiConfig object.
+ * @param out Optional output applet reply data, can be NULL.
+ */
+Result webWifiShow(WebWifiConfig* config, WebWifiReturnValue *out);
+
+/**
+ * @brief Creates the config for WebApplet. This applet uses an URL whitelist loaded from the user-process host Application, which is only loaded when running under an Application.
+ * @note Sets ::WebArgType_UnknownD, and ::WebArgType_Unknown12 on pre-3.0.0, to value 1.
+ * @param config WebCommonConfig object.
+ * @param url Initial URL navigated to by the applet.
+ */
+Result webPageCreate(WebCommonConfig* config, const char* url);
+
+/**
+ * @brief Creates the config for WebApplet. This is based on \ref webPageCreate, for News. Hence other functions referencing \ref webPageCreate also apply to this.
+ * @note The domain from the input URL is automatically whitelisted, in addition to any already loaded whitelist.
+ * @note Sets ::WebArgType_UnknownD to value 1, and sets ::WebArgType_NewsFlag to true. Also uses \ref webConfigSetEcClientCert and \ref webConfigSetShopJump with flag=true.
+ * @param config WebCommonConfig object.
+ * @param url Initial URL navigated to by the applet.
+ */
+Result webNewsCreate(WebCommonConfig* config, const char* url);
+
+/**
+ * @brief Creates the config for WebApplet. This is based on \ref webPageCreate, for YouTubeVideo. Hence other functions referencing \ref webPageCreate also apply to this. This uses a whitelist which essentially only allows youtube embed/ URLs (without mounting content from the host Application).
+ * @note This is only available on [5.0.0+].
+ * @note Sets ::WebArgType_UnknownD to value 1, and sets ::WebArgType_YouTubeVideoFlag to true. Also uses \ref webConfigSetBootAsMediaPlayer with flag=true.
+ * @param config WebCommonConfig object.
+ * @param url Initial URL navigated to by the applet.
+ */
+Result webYouTubeVideoCreate(WebCommonConfig* config, const char* url);
+
+/**
+ * @brief Creates the config for Offline-applet. This applet uses data loaded from content.
+ * @note Uses \ref webConfigSetLeftStickMode with ::WebLeftStickMode_Cursor and sets ::WebArgType_BootAsMediaPlayerInverted to false. Uses \ref webConfigSetPointer with flag = docKind == ::WebDocumentKind_OfflineHtmlPage.
+ * @note For docKind ::WebDocumentKind_ApplicationLegalInformation / ::WebDocumentKind_SystemDataPage, uses \ref webConfigSetFooter with flag=true and \ref webConfigSetBackgroundKind with ::WebBackgroundKind_Default.
+ * @note For docKind ::WebDocumentKind_SystemDataPage, uses \ref webConfigSetBootDisplayKind with ::WebBootDisplayKind_White.
+ * @note Sets ::WebArgType_Unknown14/::WebArgType_Unknown15 to value 1. With docKind ::WebDocumentKind_ApplicationLegalInformation, uses \ref webConfigSetBootDisplayKind with ::WebBootDisplayKind_White.
+ * @note Sets ::WebArgType_UnknownC to value 1.
+ * @note With docKind ::WebDocumentKind_ApplicationLegalInformation, uses \ref webConfigSetEcClientCert with flag=true.
+ * @note With docKind ::WebDocumentKind_OfflineHtmlPage on pre-3.0.0, sets ::WebArgType_Unknown12 to value 1.
+ * @note Lastly, sets the TLVs as needed for the input params.
+ * @param config WebCommonConfig object.
+ * @param docKind \ref WebDocumentKind
+ * @param id Id to load the content from. With docKind = ::WebDocumentKind_OfflineHtmlPage, id=0 should be used to specify the user-process application (non-zero is ignored with this docKind).
+ * @param docPath Initial document path in RomFS, without the leading '/'. For ::WebDocumentKind_OfflineHtmlPage, this is relative to "html-document/" in RomFS. For the other docKind values, this is relative to "/" in RomFS. This path must contain ".htdocs/".
+ */
+Result webOfflineCreate(WebCommonConfig* config, WebDocumentKind docKind, u64 id, const char* docPath);
+
+/**
+ * @brief Creates the config for ShareApplet. This applet is for social media posting/settings.
+ * @note If a non-zero uid isn't set with \ref webConfigSetUid prior to using \ref webConfigShow, the applet will launch the profile-selector applet to select an account.
+ * @note An error will be displayed if neither \ref webConfigSetAlbumEntry, nor \ref webConfigSetApplicationAlbumEntry, nor \ref webConfigAddAlbumEntryAndMediaData are used prior to using \ref webConfigShow, with ::WebShareStartPage_Default.
+ * @note Uses \ref webConfigSetLeftStickMode with ::WebLeftStickMode_Cursor, \ref webConfigSetUid with uid=0, \ref webConfigSetDisplayUrlKind with kind=true, and sets ::WebArgType_Unknown14/::WebArgType_Unknown15 to value 1. Uses \ref webConfigSetBootDisplayKind with ::WebBootDisplayKind_Unknown3.
+ * @param config WebCommonConfig object.
+ * @param page \ref WebShareStartPage
+ */
+Result webShareCreate(WebCommonConfig* config, WebShareStartPage page);
+
+/**
+ * @brief Creates the config for LobbyApplet. This applet is for "Nintendo Switch Online Lounge".
+ * @note Only available on [2.0.0+].
+ * @note If a non-zero uid isn't set with \ref webConfigSetUid prior to using \ref webConfigShow, the applet will launch the profile-selector applet to select an account.
+ * @note Uses \ref webConfigSetLeftStickMode with ::WebLeftStickMode_Cursor, \ref webConfigSetPointer with flag=false on [3.0.0+], \ref webConfigSetUid with uid=0, and sets ::WebArgType_Unknown14/::WebArgType_Unknown15 to value 1. Uses \ref webConfigSetBootDisplayKind with ::WebBootDisplayKind_Unknown4, \ref webConfigSetBackgroundKind with ::WebBackgroundKind_Unknown2, and sets ::WebArgType_BootAsMediaPlayerInverted to false.
+ * @param config WebCommonConfig object.
+ */
+Result webLobbyCreate(WebCommonConfig* config);
+
+/**
+ * @brief Sets the CallbackUrl. See also \ref webReplyGetLastUrl.
+ * @note With Offline-applet for LastUrl handling, it compares the domain with "localhost" instead.
+ * @note Only available with config created by \ref webPageCreate or with Share-applet.
+ * @param config WebCommonConfig object.
+ * @param url URL
+ */
+Result webConfigSetCallbackUrl(WebCommonConfig* config, const char* url);
+
+/**
+ * @brief Sets the CallbackableUrl.
+ * @note Only available with config created by \ref webPageCreate.
+ * @param config WebCommonConfig object.
+ * @param url URL
+ */
+Result webConfigSetCallbackableUrl(WebCommonConfig* config, const char* url);
+
+/**
+ * @brief Sets the whitelist.
+ * @note Only available with config created by \ref webPageCreate.
+ * @note If the whitelist isn't formatted properly, the applet will exit briefly after the applet is launched.
+ * @param config WebCommonConfig object.
+ * @param whitelist Whitelist string, each line is a regex for each whitelisted URL.
+ */
+Result webConfigSetWhitelist(WebCommonConfig* config, const char* whitelist);
+
+/**
+ * @brief Sets the account uid. Controls which user-specific savedata to mount.
+ * @note Only available with config created by \ref webPageCreate, \ref webLobbyCreate, or with Share-applet.
+ * @note Used automatically by \ref webShareCreate and \ref webLobbyCreate with uid=0.
+ * @param config WebCommonConfig object.
+ * @param uid \ref AccountUid
+ */
+Result webConfigSetUid(WebCommonConfig* config, AccountUid uid);
+
+/**
+ * @brief Sets the Share CapsAlbumEntry.
+ * @note Only available with config created by \ref webShareCreate.
+ * @param config WebCommonConfig object.
+ * @param entry \ref CapsAlbumEntry
+ */
+Result webConfigSetAlbumEntry(WebCommonConfig* config, const CapsAlbumEntry *entry);
+
+/**
+ * @brief Sets the ScreenShot flag, which controls whether screen-shot capture is allowed.
+ * @note Only available with config created by \ref webPageCreate.
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetScreenShot(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets the EcClientCert flag.
+ * @note Only available with config created by \ref webOfflineCreate or \ref webPageCreate.
+ * @note Used automatically by \ref webOfflineCreate, depending on the docKind.
+ * @note Used automatically by \ref webNewsCreate with flag=true.
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetEcClientCert(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets whether PlayReport is enabled.
+ * @note Only available with config created by \ref webOfflineCreate.
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetPlayReport(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets the BootDisplayKind.
+ * @note Only available with config created by \ref webOfflineCreate, \ref webShareCreate, \ref webPageCreate, or \ref webLobbyCreate..
+ * @note Used automatically by \ref webOfflineCreate, depending on the docKind.
+ * @note Used automatically by \ref webShareCreate with kind=::WebBootDisplayKind_Unknown3.
+ * @note Used automatically by \ref webLobbyCreate with kind=::WebBootDisplayKind_Unknown4.
+ * @param config WebCommonConfig object.
+ * @param kind \ref WebBootDisplayKind
+ */
+Result webConfigSetBootDisplayKind(WebCommonConfig* config, WebBootDisplayKind kind);
+
+/**
+ * @brief Sets the BackgroundKind.
+ * @note Only available with config created by \ref webOfflineCreate, \ref webPageCreate, or \ref webLobbyCreate.
+ * @note Used automatically by \ref webOfflineCreate, depending on the docKind.
+ * @note Used automatically by \ref webLobbyCreate with kind=2.
+ * @param config WebCommonConfig object.
+ * @param kind \ref WebBackgroundKind
+ */
+Result webConfigSetBackgroundKind(WebCommonConfig* config, WebBackgroundKind kind);
+
+/**
+ * @brief Sets the whether the UI footer is enabled.
+ * @note Only available with config created by \ref webOfflineCreate or \ref webPageCreate.
+ * @note Used automatically by \ref webOfflineCreate, depending on the docKind.
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetFooter(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets the whether the Pointer is enabled. See also \ref WebLeftStickMode.
+ * @note Only available with config created by \ref webOfflineCreate, \ref webPageCreate, or \ref webLobbyCreate.
+ * @note Used automatically by \ref webOfflineCreate.
+ * @note Used automatically by \ref webLobbyCreate with flag=false on [3.0.0+].
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetPointer(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets the LeftStickMode.
+ * @note Only available with config created by \ref webOfflineCreate, \ref webShareCreate, \ref webPageCreate, or \ref webLobbyCreate.
+ * @note Used automatically by \ref webOfflineCreate, \ref webShareCreate, and \ref webLobbyCreate with ::WebLeftStickMode_Cursor.
+ * @param config WebCommonConfig object.
+ * @param mode Mode, different enums for Web and Offline.
+ */
+Result webConfigSetLeftStickMode(WebCommonConfig* config, WebLeftStickMode mode);
+
+/**
+ * @brief Sets the KeyRepeatFrame.
+ * @note Only available with config created by \ref webOfflineCreate.
+ * @param config WebCommonConfig object.
+ * @param inval0 First input param.
+ * @param inval1 Second input param.
+ */
+Result webConfigSetKeyRepeatFrame(WebCommonConfig* config, s32 inval0, s32 inval1);
+
+/**
+ * @brief Sets the DisplayUrlKind.
+ * @note Only available with config created by \ref webShareCreate or \ref webPageCreate.
+ * @param config WebCommonConfig object.
+ * @note Used automatically by \ref webShareCreate with kind=true.
+ * @param kind Kind
+ */
+Result webConfigSetDisplayUrlKind(WebCommonConfig* config, bool kind);
+
+/**
+ * @brief Sets the BootAsMediaPlayer flag.
+ * @note Only available with config created by \ref webOfflineCreate or \ref webPageCreate, on [2.0.0+].
+ * @note With config created by \ref webNewsCreate on [3.0.0+], this also sets ::WebArgType_BootAsMediaPlayerInverted to !flag.
+ * @param config WebCommonConfig object.
+ * @param flag Flag. true = BootAsMediaPlayer, false = BootAsWebPage.
+ */
+Result webConfigSetBootAsMediaPlayer(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets the ShopJump flag.
+ * @note Only available with config created by \ref webPageCreate on [2.0.0+].
+ * @note Used automatically by \ref webNewsCreate with flag=true.
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetShopJump(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets the MediaPlayerUserGestureRestriction flag.
+ * @note Only available with config created by \ref webPageCreate on [2.0.0-5.1.0].
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetMediaPlayerUserGestureRestriction(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets whether MediaAutoPlay is enabled.
+ * @note Only available with config created by \ref webOfflineCreate or \ref webPageCreate, on [6.0.0+].
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetMediaAutoPlay(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets the LobbyParameter.
+ * @note Only available with config created by \ref webLobbyCreate.
+ * @param config WebCommonConfig object.
+ * @param str String
+ */
+Result webConfigSetLobbyParameter(WebCommonConfig* config, const char* str);
+
+/**
+ * @brief Sets the Share CapsApplicationAlbumEntry.
+ * @note Only available with config created by \ref webShareCreate on [3.0.0+].
+ * @param config WebCommonConfig object.
+ * @param entry \ref CapsApplicationAlbumEntry, see also capssu.h.
+ */
+Result webConfigSetApplicationAlbumEntry(WebCommonConfig* config, CapsApplicationAlbumEntry *entry);
+
+/**
+ * @brief Sets whether JsExtension is enabled.
+ * @note Only available with config created by \ref webOfflineCreate or \ref webPageCreate, on [3.0.0+].
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetJsExtension(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets the Share AdditionalCommentText.
+ * @note Only available with config created by \ref webShareCreate on [4.0.0+].
+ * @param config WebCommonConfig object.
+ * @param str String
+ */
+Result webConfigSetAdditionalCommentText(WebCommonConfig* config, const char* str);
+
+/**
+ * @brief Sets the TouchEnabledOnContents flag.
+ * @note Only available with config created by \ref webOfflineCreate or \ref webPageCreate, on [4.0.0+].
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetTouchEnabledOnContents(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets the UserAgentAdditionalString. " " followed by this string are appended to the normal User-Agent string.
+ * @note Only available with config created by \ref webPageCreate on [4.0.0+].
+ * @param config WebCommonConfig object.
+ * @param str String
+ */
+Result webConfigSetUserAgentAdditionalString(WebCommonConfig* config, const char* str);
+
+/**
+ * @brief Sets the Share AdditionalMediaData.
+ * @note Only available with config created by \ref webShareCreate on [4.0.0+].
+ * @param config WebCommonConfig object.
+ * @param data Input data
+ * @param size Size of the input data, max size is 0x10.
+ */
+Result webConfigSetAdditionalMediaData(WebCommonConfig* config, const u8* data, size_t size);
+
+/**
+ * @brief Sets the MediaPlayerAutoClose flag.
+ * @note Only available with config created by \ref webOfflineCreate or \ref webPageCreate, on [4.0.0+].
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetMediaPlayerAutoClose(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets whether PageCache is enabled.
+ * @note Only available with config created by \ref webOfflineCreate or \ref webPageCreate, on [4.0.0+].
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetPageCache(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets whether WebAudio is enabled.
+ * @note Only available with config created by \ref webOfflineCreate or \ref webPageCreate, on [4.0.0+].
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetWebAudio(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets the FooterFixedKind.
+ * @note Only available with config created by \ref webOfflineCreate or \ref webPageCreate, on [5.0.0+].
+ * @param config WebCommonConfig object.
+ * @param kind \ref WebFooterFixedKind
+ */
+Result webConfigSetFooterFixedKind(WebCommonConfig* config, WebFooterFixedKind kind);
+
+/**
+ * @brief Sets the PageFade flag.
+ * @note Only available with config created by \ref webOfflineCreate or \ref webPageCreate, on [5.0.0+].
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetPageFade(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets the Share MediaCreatorApplicationRatingAge.
+ * @note Only available with config created by \ref webShareCreate on [5.0.0+].
+ * @param config WebCommonConfig object.
+ * @param data 0x20-byte input data
+ */
+Result webConfigSetMediaCreatorApplicationRatingAge(WebCommonConfig* config, const s8 *data);
+
+/**
+ * @brief Sets the BootLoadingIcon flag.
+ * @note Only available with config created by \ref webOfflineCreate on [5.0.0+].
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetBootLoadingIcon(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets the PageScrollIndicator flag.
+ * @note Only available with config created by \ref webOfflineCreate or \ref webPageCreate, on [5.0.0+].
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetPageScrollIndicator(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets whether MediaPlayerSpeedControl is enabled.
+ * @note Only available with config created by \ref webOfflineCreate or \ref webPageCreate, on [6.0.0+].
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetMediaPlayerSpeedControl(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Adds a pair of Share CapsAlbumEntry + optionally AdditionalMediaData. This can be used up to 4 times, for setting multiple pairs.
+ * @note Only available with config created by \ref webShareCreate on [6.0.0+].
+ * @param config WebCommonConfig object.
+ * @param entry \ref CapsAlbumEntry
+ * @param data Input data for AdditionalMediaData. Optional, can be NULL.
+ * @param size Size of the input data, max size is 0x10. Optional, can be 0.
+ */
+Result webConfigAddAlbumEntryAndMediaData(WebCommonConfig* config, const CapsAlbumEntry *entry, const u8* data, size_t size);
+
+/**
+ * @brief Sets whether the specified BootFooterButton is visible.
+ * @note Only available with config created by \ref webOfflineCreate on [6.0.0+].
+ * @param config WebCommonConfig object.
+ * @param button \ref WebFooterButtonId
+ * @param visible Visible flag.
+ */
+Result webConfigSetBootFooterButtonVisible(WebCommonConfig* config, WebFooterButtonId button, bool visible);
+
+/**
+ * @brief Sets OverrideWebAudioVolume.
+ * @note Only available with config created by \ref webOfflineCreate or \ref webPageCreate, on [6.0.0+].
+ * @param config WebCommonConfig object.
+ * @param value Value
+ */
+Result webConfigSetOverrideWebAudioVolume(WebCommonConfig* config, float value);
+
+/**
+ * @brief Sets OverrideMediaAudioVolume.
+ * @note Only available with config created by \ref webOfflineCreate or \ref webPageCreate, on [6.0.0+].
+ * @param config WebCommonConfig object.
+ * @param value Value
+ */
+Result webConfigSetOverrideMediaAudioVolume(WebCommonConfig* config, float value);
+
+/**
+ * @brief Sets \ref WebSessionBootMode.
+ * @note Only available with config created by \ref webOfflineCreate or \ref webPageCreate, on [7.0.0+].
+ * @param config WebCommonConfig object.
+ * @param mode \ref WebSessionBootMode
+ */
+Result webConfigSetBootMode(WebCommonConfig* config, WebSessionBootMode mode);
+
+/**
+ * @brief Sets whether MediaPlayerUi is enabled.
+ * @note Only available with config created by \ref webOfflineCreate on [8.0.0+].
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetMediaPlayerUi(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Sets whether TransferMemory is enabled.
+ * @note Only available with config created by \ref webPageCreate on [11.0.0+].
+ * @param config WebCommonConfig object.
+ * @param flag Flag
+ */
+Result webConfigSetTransferMemory(WebCommonConfig* config, bool flag);
+
+/**
+ * @brief Launches the {web applet} with the specified config and waits for it to exit.
+ * @param config WebCommonConfig object.
+ * @param out Optional output applet reply data, can be NULL.
+ */
+Result webConfigShow(WebCommonConfig* config, WebCommonReply *out);
+
+/**
+ * @brief Request the applet to exit after \ref webConfigShow was used, while the applet is still running. This is for use from another thread.
+ * @param config WebCommonConfig object.
+ */
+Result webConfigRequestExit(WebCommonConfig* config);
+
+/**
+ * @brief Gets the ExitReason from the specified reply.
+ * @param reply WebCommonReply object.
+ * @param exitReason Output \ref WebExitReason
+ */
+Result webReplyGetExitReason(WebCommonReply *reply, WebExitReason *exitReason);
+
+/**
+ * @brief Gets the LastUrl from the specified reply. When the applet loads a page where the beginning of the URL matches the URL from \ref webConfigSetCallbackUrl, the applet will exit and set LastUrl to that URL (exit doesn't occur when \ref webConfigSetCallbackableUrl was used).
+ * @note This is only available with ::WebExitReason_LastUrl (string is empty otherwise).
+ * @note If you want to allocate a string buffer on heap, you can call this with outstr=NULL/outstr_maxsize=0 to get the out_size, then call it again with the allocated buffer.
+ * @param reply WebCommonReply object.
+ * @param outstr Output string buffer. If NULL, the string is not loaded.
+ * @param outstr_maxsize Size of the buffer, including NUL-terminator. If outstr is set, this size must be >1. The size used for the actual string-copy is this size-1, to make sure the output is NUL-terminated (the entire buffer is cleared first).
+ * @param out_size Output string length including NUL-terminator, for the original input string in the reply loaded from a separate size field.
+ */
+Result webReplyGetLastUrl(WebCommonReply *reply, char *outstr, size_t outstr_maxsize, size_t *out_size);
+
+/**
+ * @brief Gets the SharePostResult from the specified reply.
+ * @note Only available with reply data from ShareApplet on [3.0.0+].
+ * @param reply WebCommonReply object.
+ * @param sharePostResult Output sharePostResult
+ */
+Result webReplyGetSharePostResult(WebCommonReply *reply, u32 *sharePostResult);
+
+/**
+ * @brief Gets the PostServiceName from the specified reply.
+ * @note Only available with reply data from ShareApplet on [3.0.0+].
+ * @note If you want to allocate a string buffer on heap, you can call this with outstr=NULL/outstr_maxsize=0 to get the out_size, then call it again with the allocated buffer.
+ * @param reply WebCommonReply object.
+ * @param outstr Output string buffer. If NULL, the string is not loaded.
+ * @param outstr_maxsize Size of the buffer, including NUL-terminator. If outstr is set, this size must be >1. The size used for the actual string-copy is this size-1, to make sure the output is NUL-terminated (the entire buffer is cleared first).
+ * @param out_size Output string length including NUL-terminator, for the original input string in the reply loaded from a separate size field.
+ */
+Result webReplyGetPostServiceName(WebCommonReply *reply, char *outstr, size_t outstr_maxsize, size_t *out_size);
+
+/**
+ * @brief Gets the PostId from the specified reply.
+ * @note Only available with reply data from ShareApplet on [3.0.0+].
+ * @note If you want to allocate a string buffer on heap, you can call this with outstr=NULL/outstr_maxsize=0 to get the out_size, then call it again with the allocated buffer.
+ * @param reply WebCommonReply object.
+ * @param outstr Output string buffer. If NULL, the string is not loaded.
+ * @param outstr_maxsize Size of the buffer, including NUL-terminator. If outstr is set, this size must be >1. The size used for the actual string-copy is this size-1, to make sure the output is NUL-terminated (the entire buffer is cleared first).
+ * @param out_size Output string length including NUL-terminator, for the original input string in the reply loaded from a separate size field.
+ */
+Result webReplyGetPostId(WebCommonReply *reply, char *outstr, size_t outstr_maxsize, size_t *out_size);
+
+/**
+ * @brief Gets the MediaPlayerAutoClosedByCompletion flag from the specified reply.
+ * @note Only available with reply data from Web on [8.0.0+].
+ * @param reply WebCommonReply object.
+ * @param flag Output flag
+ */
+Result webReplyGetMediaPlayerAutoClosedByCompletion(WebCommonReply *reply, bool *flag);
+
+/**
+ * @brief Creates a \ref WebSession object.
+ * @param s \ref WebSession
+ * @param config WebCommonConfig object.
+ */
+void webSessionCreate(WebSession *s, WebCommonConfig* config);
+
+/**
+ * @brief Closes a \ref WebSession object.
+ * @param s \ref WebSession
+ */
+void webSessionClose(WebSession *s);
+
+/**
+ * @brief Launches the applet for \ref WebSession.
+ * @note Only available with config created by \ref webOfflineCreate or \ref webPageCreate, on [7.0.0+].
+ * @note Do not use \ref webConfigShow when using WebSession.
+ * @param s \ref WebSession
+ * @param[out] out_event Output Event with autoclear=false, from \ref appletHolderGetExitEvent. Optional, can be NULL.
+ */
+Result webSessionStart(WebSession *s, Event **out_event);
+
+/**
+ * @brief Waits for the applet to exit.
+ * @note This must be used before \ref webSessionClose, when \ref webSessionStart was used successfully.
+ * @param s \ref WebSession
+ * @param out Optional output applet reply data, can be NULL.
+ */
+Result webSessionWaitForExit(WebSession *s, WebCommonReply *out);
+
+/**
+ * @brief Request the applet to exit.
+ * @note Use this instead of \ref webConfigRequestExit, when using WebSession.
+ * @param s \ref WebSession
+ */
+Result webSessionRequestExit(WebSession *s);
+
+/**
+ * @brief Request the applet to Appear, this is only needed with ::WebSessionBootMode_AllForegroundInitiallyHidden.
+ * @note This should not be used before \ref webSessionStart.
+ * @param s \ref WebSession
+ * @param[out] flag Whether the message was sent successfully.
+ */
+Result webSessionAppear(WebSession *s, bool *flag);
+
+/**
+ * @brief TrySendContentMessage
+ * @note This should not be used before \ref webSessionStart.
+ * @note The JS-side for this is only available when JsExtension is enabled via \ref webConfigSetJsExtension.
+ * @note The JS-side may ignore this if it's sent too soon after the applet launches.
+ * @param s \ref WebSession
+ * @param[in] content Input content NUL-terminated string.
+ * @param[in] size Size of content.
+ * @param[out] flag Whether the message was sent successfully.
+ */
+Result webSessionTrySendContentMessage(WebSession *s, const char *content, u32 size, bool *flag);
+
+/**
+ * @brief TryReceiveContentMessage
+ * @note This should not be used before \ref webSessionStart.
+ * @note The JS-side for this is only available when JsExtension is enabled via \ref webConfigSetJsExtension.
+ * @param s \ref WebSession
+ * @param[out] content Output content string, always NUL-terminated.
+ * @param[in] size Max size of content.
+ * @param[out] out_size Original content size, prior to being clamped to the specified size param.
+ * @param[out] flag Whether the message was received successfully.
+ */
+Result webSessionTryReceiveContentMessage(WebSession *s, char *content, u64 size, u64 *out_size, bool *flag);
+

nx/include/switch/arm/atomics.h

@@ -1,18 +0,0 @@
-#pragma once
-#include "../types.h"
-
-static inline u32 atomicIncrement32(u32* p) {
-    return __atomic_fetch_add(p, 1, __ATOMIC_SEQ_CST);
-}
-
-static inline u32 atomicDecrement32(u32* p) {
-    return __atomic_sub_fetch(p, 1, __ATOMIC_SEQ_CST);
-}
-
-static inline u64 atomicIncrement64(u64* p) {
-    return __atomic_fetch_add(p, 1, __ATOMIC_SEQ_CST);
-}
-
-static inline u64 atomicDecrement64(u64* p) {
-    return __atomic_sub_fetch(p, 1, __ATOMIC_SEQ_CST);
-}

nx/include/switch/arm/counter.h

@@ -26,3 +26,21 @@ static inline u64 armGetSystemTickFreq(void) {
     __asm__ ("mrs %x[data], cntfrq_el0" : [data] "=r" (ret));
     return ret;
 }
+
+/**
+ * @brief Converts from nanoseconds to CPU ticks unit.
+ * @param ns Time in nanoseconds.
+ * @return Time in CPU ticks.
+ */
+static inline u64 armNsToTicks(u64 ns) {
+    return (ns * 12) / 625;
+}
+
+/**
+ * @brief Converts from CPU ticks unit to nanoseconds.
+ * @param tick Time in ticks.
+ * @return Time in nanoseconds.
+ */
+static inline u64 armTicksToNs(u64 tick) {
+    return (tick * 625) / 12;
+}

nx/include/switch/arm/thread_context.h

@@ -34,6 +34,17 @@ typedef enum {
     RegisterGroup_All     = RegisterGroup_CpuAll  | RegisterGroup_FpuAll,  ///< All registers.
 } RegisterGroup;
 
+/// This is for \ref ThreadExceptionDump error_desc.
+typedef enum {
+    ThreadExceptionDesc_InstructionAbort = 0x100, ///< Instruction abort
+    ThreadExceptionDesc_MisalignedPC     = 0x102, ///< Misaligned PC
+    ThreadExceptionDesc_MisalignedSP     = 0x103, ///< Misaligned SP
+    ThreadExceptionDesc_SError           = 0x106, ///< SError [not in 1.0.0?]
+    ThreadExceptionDesc_BadSVC           = 0x301, ///< Bad SVC
+    ThreadExceptionDesc_Trap             = 0x104, ///< Uncategorized, CP15RTTrap, CP15RRTTrap, CP14RTTrap, CP14RRTTrap, IllegalState, SystemRegisterTrap
+    ThreadExceptionDesc_Other            = 0x101, ///< None of the above, EC <= 0x34 and not a breakpoint
+} ThreadExceptionDesc;
+
 /// Thread context structure (register dump)
 typedef struct {
     CpuRegister cpu_gprs[29];   ///< GPRs 0..28. Note: also contains AArch32 SPRs.
@@ -50,6 +61,54 @@ typedef struct {
     u64         tpidr;          ///< EL0 Read/Write Software Thread ID Register.
 } ThreadContext;
 
+/// Thread exception dump structure.
+typedef struct {
+    u32 error_desc;             ///< See \ref ThreadExceptionDesc.
+    u32 pad[3];
+
+    CpuRegister cpu_gprs[29];   ///< GPRs 0..28. Note: also contains AArch32 registers.
+    CpuRegister fp;             ///< Frame pointer.
+    CpuRegister lr;             ///< Link register.
+    CpuRegister sp;             ///< Stack pointer.
+    CpuRegister pc;             ///< Program counter (elr_el1).
+
+    u64 padding;
+
+    FpuRegister fpu_gprs[32];   ///< 32 general-purpose NEON registers.
+
+    u32 pstate;                 ///< pstate & 0xFF0FFE20
+    u32 afsr0;
+    u32 afsr1;
+    u32 esr;
+
+    CpuRegister far;            ///< Fault Address Register.
+} ThreadExceptionDump;
+
+typedef struct {
+    u64 cpu_gprs[9]; ///< GPRs 0..8.
+    u64 lr;
+    u64 sp;
+    u64 elr_el1;
+    u32 pstate;       ///< pstate & 0xFF0FFE20
+    u32 afsr0;
+    u32 afsr1;
+    u32 esr;
+    u64 far;
+} ThreadExceptionFrameA64;
+
+typedef struct {
+    u32 cpu_gprs[8]; ///< GPRs 0..7.
+    u32 sp;
+    u32 lr;
+    u32 elr_el1;
+    u32 tpidr_el0;    ///< tpidr_el0 = 1
+    u32 cpsr;         ///< cpsr & 0xFF0FFE20
+    u32 afsr0;
+    u32 afsr1;
+    u32 esr;
+    u32 far;
+} ThreadExceptionFrameA32;
+
 /**
  * @brief Determines whether a thread context belong to an AArch64 process based on the PSR.
  * @param[in] ctx Thread context to which PSTATE/cspr has been dumped to.
@@ -59,3 +118,13 @@ static inline bool threadContextIsAArch64(const ThreadContext *ctx)
 {
     return (ctx->psr & 0x10) == 0;
 }
+
+/**
+ * @brief Determines whether a ThreadExceptionDump belongs to an AArch64 process based on the PSTATE.
+ * @param[in] ctx ThreadExceptionDump.
+ * @return true if and only if the ThreadExceptionDump belongs to an AArch64 process.
+ */
+static inline bool threadExceptionIsAArch64(const ThreadExceptionDump *ctx)
+{
+    return (ctx->pstate & 0x10) == 0;
+}

nx/include/switch/audio/audio.h

@@ -8,6 +8,7 @@
 
 #include "../types.h"
 
+/// PcmFormat
 typedef enum {
     PcmFormat_Invalid = 0,
     PcmFormat_Int8 = 1,
@@ -17,3 +18,8 @@ typedef enum {
     PcmFormat_Float = 5,
     PcmFormat_Adpcm = 6,
 } PcmFormat;
+
+/// AudioDeviceName
+typedef struct {
+    char name[0x100];
+} AudioDeviceName;

nx/include/switch/audio/driver.h

@@ -62,6 +62,7 @@ struct AudioDriverWaveBuf {
 bool audrvVoiceInit(AudioDriver* d, int id, int num_channels, PcmFormat format, int sample_rate);
 void audrvVoiceDrop(AudioDriver* d, int id);
 void audrvVoiceStop(AudioDriver* d, int id);
+bool audrvVoiceIsPaused(AudioDriver* d, int id);
 bool audrvVoiceIsPlaying(AudioDriver* d, int id);
 bool audrvVoiceAddWaveBuf(AudioDriver* d, int id, AudioDriverWaveBuf* wavebuf);
 u32 audrvVoiceGetWaveBufSeq(AudioDriver* d, int id);

nx/include/switch/crypto/aes.h

@@ -0,0 +1,74 @@
+/**
+ * @file aes.h
+ * @brief Hardware accelerated AES-ECB implementation.
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+
+#ifndef AES_BLOCK_SIZE
+#define AES_BLOCK_SIZE 0x10
+#endif
+#ifndef AES_128_KEY_SIZE
+#define AES_128_KEY_SIZE   0x10
+#endif
+#ifndef AES_128_U32_PER_KEY
+#define AES_128_U32_PER_KEY (AES_128_KEY_SIZE / sizeof(u32))
+#endif
+#ifndef AES_128_NUM_ROUNDS
+#define AES_128_NUM_ROUNDS 10
+#endif
+#ifndef AES_192_KEY_SIZE
+#define AES_192_KEY_SIZE   0x18
+#endif
+#ifndef AES_192_U32_PER_KEY
+#define AES_192_U32_PER_KEY (AES_192_KEY_SIZE / sizeof(u32))
+#endif
+#ifndef AES_192_NUM_ROUNDS
+#define AES_192_NUM_ROUNDS 12
+#endif
+#ifndef AES_256_KEY_SIZE
+#define AES_256_KEY_SIZE   0x20
+#endif
+#ifndef AES_256_U32_PER_KEY
+#define AES_256_U32_PER_KEY (AES_256_KEY_SIZE / sizeof(u32))
+#endif
+#ifndef AES_256_NUM_ROUNDS
+#define AES_256_NUM_ROUNDS 14
+#endif
+
+/// Context for AES-128 operations.
+typedef struct {
+    u8 round_keys[AES_128_NUM_ROUNDS+1][AES_BLOCK_SIZE];
+} Aes128Context;
+
+/// Context for AES-192 operations.
+typedef struct {
+    u8 round_keys[AES_192_NUM_ROUNDS+1][AES_BLOCK_SIZE];
+} Aes192Context;
+
+/// Context for AES-256 operations.
+typedef struct {
+    u8 round_keys[AES_256_NUM_ROUNDS+1][AES_BLOCK_SIZE];
+} Aes256Context;
+
+/// Initialize a 128-bit AES context.
+void aes128ContextCreate(Aes128Context *out, const void *key, bool is_encryptor);
+/// Encrypt using an AES context (Requires is_encryptor when initializing)
+void aes128EncryptBlock(const Aes128Context *ctx, void *dst, const void *src);
+/// Decrypt using an AES context (Requires !is_encryptor when initializing)
+void aes128DecryptBlock(const Aes128Context *ctx, void *dst, const void *src);
+
+/// Initialize a 192-bit AES context.
+void aes192ContextCreate(Aes192Context *out, const void *key, bool is_encryptor);
+/// Encrypt using an AES context (Requires is_encryptor when initializing)
+void aes192EncryptBlock(const Aes192Context *ctx, void *dst, const void *src);
+/// Decrypt using an AES context (Requires !is_encryptor when initializing)
+void aes192DecryptBlock(const Aes192Context *ctx, void *dst, const void *src);
+
+/// Initialize a 256-bit AES context.
+void aes256ContextCreate(Aes256Context *out, const void *key, bool is_encryptor);
+/// Encrypt using an AES context (Requires is_encryptor when initializing)
+void aes256EncryptBlock(const Aes256Context *ctx, void *dst, const void *src);
+/// Decrypt using an AES context (Requires !is_encryptor when initializing)
+void aes256DecryptBlock(const Aes256Context *ctx, void *dst, const void *src);

nx/include/switch/crypto/aes_cbc.h

@@ -0,0 +1,49 @@
+/**
+ * @file aes_cbc.h
+ * @brief Hardware accelerated AES-CBC implementation.
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "aes.h"
+
+/// Context for AES-128 CBC.
+typedef struct {
+    Aes128Context aes_ctx;
+    u8 iv[AES_BLOCK_SIZE];
+    u8 buffer[AES_BLOCK_SIZE];
+    size_t num_buffered;
+} Aes128CbcContext;
+
+/// Context for AES-192 CBC.
+typedef struct {
+    Aes192Context aes_ctx;
+    u8 iv[AES_BLOCK_SIZE];
+    u8 buffer[AES_BLOCK_SIZE];
+    size_t num_buffered;
+} Aes192CbcContext;
+
+/// Context for AES-256 CBC.
+typedef struct {
+    Aes256Context aes_ctx;
+    u8 iv[AES_BLOCK_SIZE];
+    u8 buffer[AES_BLOCK_SIZE];
+    size_t num_buffered;
+} Aes256CbcContext;
+
+/// 128-bit CBC API.
+void aes128CbcContextCreate(Aes128CbcContext *out, const void *key, const void *iv, bool is_encryptor);
+void aes128CbcContextResetIv(Aes128CbcContext *ctx, const void *iv);
+size_t aes128CbcEncrypt(Aes128CbcContext *ctx, void *dst, const void *src, size_t size);
+size_t aes128CbcDecrypt(Aes128CbcContext *ctx, void *dst, const void *src, size_t size);
+
+/// 192-bit CBC API.
+void aes192CbcContextCreate(Aes192CbcContext *out, const void *key, const void *iv, bool is_encryptor);
+void aes192CbcContextResetIv(Aes192CbcContext *ctx, const void *iv);
+size_t aes192CbcEncrypt(Aes192CbcContext *ctx, void *dst, const void *src, size_t size);
+size_t aes192CbcDecrypt(Aes192CbcContext *ctx, void *dst, const void *src, size_t size);
+
+/// 256-bit CBC API.
+void aes256CbcContextCreate(Aes256CbcContext *out, const void *key, const void *iv, bool is_encryptor);
+void aes256CbcContextResetIv(Aes256CbcContext *ctx, const void *iv);
+size_t aes256CbcEncrypt(Aes256CbcContext *ctx, void *dst, const void *src, size_t size);
+size_t aes256CbcDecrypt(Aes256CbcContext *ctx, void *dst, const void *src, size_t size);

nx/include/switch/crypto/aes_ctr.h

@@ -0,0 +1,46 @@
+/**
+ * @file aes_ctr.h
+ * @brief Hardware accelerated AES-CTR implementation.
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "aes.h"
+
+/// Context for AES-128 CTR.
+typedef struct {
+    Aes128Context aes_ctx;
+    u8 ctr[AES_BLOCK_SIZE];
+    u8 enc_ctr_buffer[AES_BLOCK_SIZE];
+    size_t buffer_offset;
+} Aes128CtrContext;
+
+/// Context for AES-192 CTR.
+typedef struct {
+    Aes192Context aes_ctx;
+    u8 ctr[AES_BLOCK_SIZE];
+    u8 enc_ctr_buffer[AES_BLOCK_SIZE];
+    size_t buffer_offset;
+} Aes192CtrContext;
+
+/// Context for AES-256 CTR.
+typedef struct {
+    Aes256Context aes_ctx;
+    u8 ctr[AES_BLOCK_SIZE];
+    u8 enc_ctr_buffer[AES_BLOCK_SIZE];
+    size_t buffer_offset;
+} Aes256CtrContext;
+
+/// 128-bit CTR API.
+void aes128CtrContextCreate(Aes128CtrContext *out, const void *key, const void *ctr);
+void aes128CtrContextResetCtr(Aes128CtrContext *ctx, const void *ctr);
+void aes128CtrCrypt(Aes128CtrContext *ctx, void *dst, const void *src, size_t size);
+
+/// 192-bit CTR API.
+void aes192CtrContextCreate(Aes192CtrContext *out, const void *key, const void *ctr);
+void aes192CtrContextResetCtr(Aes192CtrContext *ctx, const void *ctr);
+void aes192CtrCrypt(Aes192CtrContext *ctx, void *dst, const void *src, size_t size);
+
+/// 256-bit CTR API.
+void aes256CtrContextCreate(Aes256CtrContext *out, const void *key, const void *ctr);
+void aes256CtrContextResetCtr(Aes256CtrContext *ctx, const void *ctr);
+void aes256CtrCrypt(Aes256CtrContext *ctx, void *dst, const void *src, size_t size);

nx/include/switch/crypto/aes_xts.h

@@ -0,0 +1,55 @@
+/**
+ * @file aes_xts.h
+ * @brief Hardware accelerated AES-XTS implementation.
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "aes.h"
+
+/// Context for AES-128 XTS.
+typedef struct {
+    Aes128Context aes_ctx;
+    Aes128Context tweak_ctx;
+    u8 tweak[AES_BLOCK_SIZE];
+    u8 buffer[AES_BLOCK_SIZE];
+    size_t num_buffered;
+} Aes128XtsContext;
+
+/// Context for AES-192 XTS.
+typedef struct {
+    Aes192Context aes_ctx;
+    Aes192Context tweak_ctx;
+    u8 tweak[AES_BLOCK_SIZE];
+    u8 buffer[AES_BLOCK_SIZE];
+    size_t num_buffered;
+} Aes192XtsContext;
+
+/// Context for AES-256 XTS.
+typedef struct {
+    Aes256Context aes_ctx;
+    Aes256Context tweak_ctx;
+    u8 tweak[AES_BLOCK_SIZE];
+    u8 buffer[AES_BLOCK_SIZE];
+    size_t num_buffered;
+} Aes256XtsContext;
+
+/// 128-bit XTS API.
+void aes128XtsContextCreate(Aes128XtsContext *out, const void *key0, const void *key1, bool is_encryptor);
+void aes128XtsContextResetTweak(Aes128XtsContext *ctx, const void *tweak);
+void aes128XtsContextResetSector(Aes128XtsContext *ctx, uint64_t sector, bool is_nintendo);
+size_t aes128XtsEncrypt(Aes128XtsContext *ctx, void *dst, const void *src, size_t size);
+size_t aes128XtsDecrypt(Aes128XtsContext *ctx, void *dst, const void *src, size_t size);
+
+/// 192-bit XTS API.
+void aes192XtsContextCreate(Aes192XtsContext *out, const void *key0, const void *key1, bool is_encryptor);
+void aes192XtsContextResetTweak(Aes192XtsContext *ctx, const void *tweak);
+void aes192XtsContextResetSector(Aes192XtsContext *ctx, uint64_t sector, bool is_nintendo);
+size_t aes192XtsEncrypt(Aes192XtsContext *ctx, void *dst, const void *src, size_t size);
+size_t aes192XtsDecrypt(Aes192XtsContext *ctx, void *dst, const void *src, size_t size);
+
+/// 256-bit XTS API.
+void aes256XtsContextCreate(Aes256XtsContext *out, const void *key0, const void *key1, bool is_encryptor);
+void aes256XtsContextResetTweak(Aes256XtsContext *ctx, const void *tweak);
+void aes256XtsContextResetSector(Aes256XtsContext *ctx, uint64_t sector, bool is_nintendo);
+size_t aes256XtsEncrypt(Aes256XtsContext *ctx, void *dst, const void *src, size_t size);
+size_t aes256XtsDecrypt(Aes256XtsContext *ctx, void *dst, const void *src, size_t size);

nx/include/switch/crypto/cmac.h

@@ -0,0 +1,67 @@
+/**
+ * @file cmac.h
+ * @brief Hardware accelerated AES-CMAC implementation.
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "aes.h"
+
+/// Context for AES-128 CMAC.
+typedef struct {
+    Aes128Context ctx;
+    u8 subkey[AES_BLOCK_SIZE];
+    u8 mac[AES_BLOCK_SIZE];
+    u8 buffer[AES_BLOCK_SIZE];
+    size_t num_buffered;
+    bool finalized;
+} Aes128CmacContext;
+
+/// Context for AES-192 CMAC.
+typedef struct {
+    Aes192Context ctx;
+    u8 subkey[AES_BLOCK_SIZE];
+    u8 mac[AES_BLOCK_SIZE];
+    u8 buffer[AES_BLOCK_SIZE];
+    size_t num_buffered;
+    bool finalized;
+} Aes192CmacContext;
+
+/// Context for AES-256 CMAC.
+typedef struct {
+    Aes256Context ctx;
+    u8 subkey[AES_BLOCK_SIZE];
+    u8 mac[AES_BLOCK_SIZE];
+    u8 buffer[AES_BLOCK_SIZE];
+    size_t num_buffered;
+    bool finalized;
+} Aes256CmacContext;
+
+/// Initialize an AES-128-CMAC context.
+void cmacAes128ContextCreate(Aes128CmacContext *out, const void *key);
+/// Updates AES-128-CMAC context with data to hash
+void cmacAes128ContextUpdate(Aes128CmacContext *ctx, const void *src, size_t size);
+/// Gets the context's output mac, finalizes the context.
+void cmacAes128ContextGetMac(Aes128CmacContext *ctx, void *dst);
+
+/// Simple all-in-one AES-128-CMAC calculator.
+void cmacAes128CalculateMac(void *dst, const void *key, const void *src, size_t size);
+
+/// Initialize an AES-192-CMAC context.
+void cmacAes192ContextCreate(Aes192CmacContext *out, const void *key);
+/// Updates AES-192-CMAC context with data to hash
+void cmacAes192ContextUpdate(Aes192CmacContext *ctx, const void *src, size_t size);
+/// Gets the context's output mac, finalizes the context.
+void cmacAes192ContextGetMac(Aes192CmacContext *ctx, void *dst);
+
+/// Simple all-in-one AES-192-CMAC calculator.
+void cmacAes192CalculateMac(void *dst, const void *key, const void *src, size_t size);
+
+/// Initialize an AES-256-CMAC context.
+void cmacAes256ContextCreate(Aes256CmacContext *out, const void *key);
+/// Updates AES-256-CMAC context with data to hash
+void cmacAes256ContextUpdate(Aes256CmacContext *ctx, const void *src, size_t size);
+/// Gets the context's output mac, finalizes the context.
+void cmacAes256ContextGetMac(Aes256CmacContext *ctx, void *dst);
+
+/// Simple all-in-one AES-256-CMAC calculator.
+void cmacAes256CalculateMac(void *dst, const void *key, const void *src, size_t size);

nx/include/switch/crypto/crc.h

@@ -0,0 +1,86 @@
+/**
+ * @file crc.h
+ * @brief Hardware accelerated CRC32 implementation.
+ * @copyright libnx Authors
+ */
+#pragma once
+#include <arm_acle.h>
+#include "../types.h"
+
+#define _CRC_ALIGN(sz, insn) \
+do { \
+    if (((uintptr_t)src_u8 & sizeof(sz)) && (u64)len >= sizeof(sz)) { \
+        crc = __crc32##insn(crc, *((const sz *)src_u8)); \
+        src_u8 += sizeof(sz); \
+        len -= sizeof(sz); \
+    } \
+} while (0)
+
+#define _CRC_REMAINDER(sz, insn) \
+do { \
+    if (len & sizeof(sz)) { \
+        crc = __crc32##insn(crc, *((const sz *)src_u8)); \
+        src_u8 += sizeof(sz); \
+    } \
+} while (0)
+
+/// Calculate a CRC32 over data using a seed.
+/// Can be used to calculate a CRC32 in chunks using an initial seed of zero for the first chunk.
+static inline u32 crc32CalculateWithSeed(u32 seed, const void *src, size_t size) {
+    const u8 *src_u8 = (const u8 *)src;
+
+    u32 crc = ~seed;
+    s64 len = size;
+
+    _CRC_ALIGN(u8,  b);
+    _CRC_ALIGN(u16, h);
+    _CRC_ALIGN(u32, w);
+
+    while ((len -= sizeof(u64)) >= 0) {
+        crc = __crc32d(crc, *((const u64 *)src_u8));
+        src_u8 += sizeof(u64);
+    }
+
+    _CRC_REMAINDER(u32, w);
+    _CRC_REMAINDER(u16, h);
+    _CRC_REMAINDER(u8,  b);
+
+    return ~crc;
+}
+
+/// Calculate a CRC32 over data.
+static inline u32 crc32Calculate(const void *src, size_t size) {
+    return crc32CalculateWithSeed(0, src, size);
+}
+
+/// Calculate a CRC32C over data using a seed.
+/// Can be used to calculate a CRC32C in chunks using an initial seed of zero for the first chunk.
+static inline u32 crc32cCalculateWithSeed(u32 seed, const void *src, size_t size) {
+    const u8 *src_u8 = (const u8 *)src;
+
+    u32 crc = ~seed;
+    s64 len = size;
+
+    _CRC_ALIGN(u8,  cb);
+    _CRC_ALIGN(u16, ch);
+    _CRC_ALIGN(u32, cw);
+
+    while ((len -= sizeof(u64)) >= 0) {
+        crc = __crc32cd(crc, *((const u64 *)src_u8));
+        src_u8 += sizeof(u64);
+    }
+
+    _CRC_REMAINDER(u32, cw);
+    _CRC_REMAINDER(u16, ch);
+    _CRC_REMAINDER(u8,  cb);
+
+    return ~crc;
+}
+
+/// Calculate a CRC32C over data.
+static inline u32 crc32cCalculate(const void *src, size_t size) {
+    return crc32cCalculateWithSeed(0, src, size);
+}
+
+#undef _CRC_REMAINDER
+#undef _CRC_ALIGN

nx/include/switch/crypto/hmac.h

@@ -0,0 +1,51 @@
+/**
+ * @file hmac.h
+ * @brief Hardware accelerated HMAC-SHA(1, 256) implementation.
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "sha1.h"
+#include "sha256.h"
+
+/// Context for HMAC-SHA1 operations.
+typedef struct {
+    Sha1Context sha_ctx;
+    u32 key[SHA1_BLOCK_SIZE / sizeof(u32)];
+    u32 mac[SHA1_HASH_SIZE / sizeof(u32)];
+    bool finalized;
+} HmacSha1Context;
+
+/// Context for HMAC-SHA256 operations.
+typedef struct {
+    Sha256Context sha_ctx;
+    u32 key[SHA256_BLOCK_SIZE / sizeof(u32)];
+    u32 mac[SHA256_HASH_SIZE / sizeof(u32)];
+    bool finalized;
+} HmacSha256Context;
+
+#ifndef HMAC_SHA1_KEY_MAX
+#define HMAC_SHA1_KEY_MAX   (sizeof(((HmacSha1Context *)NULL)->key))
+#endif
+#ifndef HMAC_SHA256_KEY_MAX
+#define HMAC_SHA256_KEY_MAX (sizeof(((HmacSha256Context *)NULL)->key))
+#endif
+
+/// Initialize a HMAC-SHA256 context.
+void hmacSha256ContextCreate(HmacSha256Context *out, const void *key, size_t key_size);
+/// Updates HMAC-SHA256 context with data to hash
+void hmacSha256ContextUpdate(HmacSha256Context *ctx, const void *src, size_t size);
+/// Gets the context's output mac, finalizes the context.
+void hmacSha256ContextGetMac(HmacSha256Context *ctx, void *dst);
+
+/// Simple all-in-one HMAC-SHA256 calculator.
+void hmacSha256CalculateMac(void *dst, const void *key, size_t key_size, const void *src, size_t size);
+
+/// Initialize a HMAC-SHA1 context.
+void hmacSha1ContextCreate(HmacSha1Context *out, const void *key, size_t key_size);
+/// Updates HMAC-SHA1 context with data to hash
+void hmacSha1ContextUpdate(HmacSha1Context *ctx, const void *src, size_t size);
+/// Gets the context's output mac, finalizes the context.
+void hmacSha1ContextGetMac(HmacSha1Context *ctx, void *dst);
+
+/// Simple all-in-one HMAC-SHA1 calculator.
+void hmacSha1CalculateMac(void *dst, const void *key, size_t key_size, const void *src, size_t size);

nx/include/switch/crypto/sha1.h

@@ -0,0 +1,34 @@
+/**
+ * @file sha1.h
+ * @brief Hardware accelerated SHA1 implementation.
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+
+#ifndef SHA1_HASH_SIZE
+#define SHA1_HASH_SIZE 0x14
+#endif
+
+#ifndef SHA1_BLOCK_SIZE
+#define SHA1_BLOCK_SIZE 0x40
+#endif
+
+/// Context for SHA1 operations.
+typedef struct {
+    u32 intermediate_hash[SHA1_HASH_SIZE / sizeof(u32)];
+    u8  buffer[SHA1_BLOCK_SIZE];
+    u64 bits_consumed;
+    size_t num_buffered;
+    bool finalized;
+} Sha1Context;
+
+/// Initialize a SHA1 context.
+void sha1ContextCreate(Sha1Context *out);
+/// Updates SHA1 context with data to hash
+void sha1ContextUpdate(Sha1Context *ctx, const void *src, size_t size);
+/// Gets the context's output hash, finalizes the context.
+void sha1ContextGetHash(Sha1Context *ctx, void *dst);
+
+/// Simple all-in-one SHA1 calculator.
+void sha1CalculateHash(void *dst, const void *src, size_t size);

nx/include/switch/crypto/sha256.h

@@ -0,0 +1,35 @@
+/**
+ * @file sha256.h
+ * @brief Hardware accelerated SHA256 implementation.
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+
+
+#ifndef SHA256_HASH_SIZE
+#define SHA256_HASH_SIZE 0x20
+#endif
+
+#ifndef SHA256_BLOCK_SIZE
+#define SHA256_BLOCK_SIZE 0x40
+#endif
+
+/// Context for SHA256 operations.
+typedef struct {
+    u32 intermediate_hash[SHA256_HASH_SIZE / sizeof(u32)];
+    u8  buffer[SHA256_BLOCK_SIZE];
+    u64 bits_consumed;
+    size_t num_buffered;
+    bool finalized;
+} Sha256Context;
+
+/// Initialize a SHA256 context.
+void sha256ContextCreate(Sha256Context *out);
+/// Updates SHA256 context with data to hash
+void sha256ContextUpdate(Sha256Context *ctx, const void *src, size_t size);
+/// Gets the context's output hash, finalizes the context.
+void sha256ContextGetHash(Sha256Context *ctx, void *dst);
+
+/// Simple all-in-one SHA256 calculator.
+void sha256CalculateHash(void *dst, const void *src, size_t size);

nx/include/switch/display/binder.h

@@ -1,22 +1,23 @@
 #pragma once
 #include "../types.h"
 #include "../kernel/event.h"
+#include "../sf/service.h"
 
 #define BINDER_FIRST_CALL_TRANSACTION 0x1
 
 typedef struct {
-    bool   created           : 1;
-    bool   initialized       : 1;
-    bool   has_transact_auto : 1;
-    s32    id;
-    size_t ipc_buffer_size;
+    bool     created;
+    bool     initialized;
+    s32      id;
+    size_t   dummy;
+    Service* relay;
 } Binder;
 
 // Note: binderClose will not close the session_handle provided to binderCreate.
 void binderCreate(Binder* b, s32 id);
 void binderClose(Binder* b);
 
-Result binderInitSession(Binder* b);
+Result binderInitSession(Binder* b, Service* relay);
 
 Result binderTransactParcel(
     Binder* b, u32 code,

nx/include/switch/display/buffer_producer.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "types.h"
+#include "binder.h"
 #include "../nvidia/fence.h"
 
 typedef struct {
@@ -10,7 +11,7 @@ typedef struct {
 } BqRect;
 
 typedef struct {
-    struct { s64 timestamp; } PACKED;
+    struct { s64 timestamp; } NX_PACKED;
     s32 isAutoTimestamp;
     BqRect crop;
     s32 scalingMode;
@@ -19,69 +20,30 @@ typedef struct {
     u32 unk;
     u32 swapInterval;
     NvMultiFence fence;
-} BqQueueBufferInput;
+} BqBufferInput;
 
 typedef struct {
     u32 width;
     u32 height;
     u32 transformHint;
     u32 numPendingBuffers;
-} BqQueueBufferOutput;
+} BqBufferOutput;
 
 typedef struct {
-    u32 magic;
     u32 width;
     u32 height;
     u32 stride;
     u32 format;
     u32 usage;
-
-    u32 pid;
-    u32 refcount;
-
-    u32 numFds;
-    u32 numInts;
-
-    struct { // Actual size is numFds*4 + numInts*4.
-        u32 unk_x0;
-        u32 nvmap_handle0;
-        u32 unk_x8;
-        u32 unk_xc;
-        u32 unk_x10;
-        u32 unk_x14;
-        u32 unk_x18;
-        u32 unk_x1c;
-        u32 unk_x20;
-        u32 width_unk0;
-        u32 buffer_size0;
-        u32 unk_x2c;
-        u32 unk_x30;
-        u32 width_unk1;
-        u32 height_unk;
-        u32 flags;
-        u32 unk_x40;
-        u32 unk_x44;
-        u32 byte_stride;
-        u32 nvmap_handle1;
-        u32 buffer_offset;
-        u32 unk_x54;
-        u32 unk_x58;
-        u32 unk_x5c;
-        u32 unk_x60;
-        u32 unk_x64;
-        u32 unk_x68;
-        u32 buffer_size1;
-        u32 unk_x70[0x33]; // Normally all-zero.
-        struct { u64 timestamp; } PACKED; // unused
-    } data;
+    NativeHandle* native_handle;
 } BqGraphicBuffer;
 
 Result bqRequestBuffer(Binder *b, s32 bufferIdx, BqGraphicBuffer *buf);
 Result bqDequeueBuffer(Binder *b, bool async, u32 width, u32 height, s32 format, u32 usage, s32 *buf, NvMultiFence *fence);
 Result bqDetachBuffer(Binder *b, s32 slot);
-Result bqQueueBuffer(Binder *b, s32 buf, BqQueueBufferInput *input, BqQueueBufferOutput *output);
-Result bqCancelBuffer(Binder *b, s32 buf, NvMultiFence *fence);
+Result bqQueueBuffer(Binder *b, s32 buf, const BqBufferInput *input, BqBufferOutput *output);
+Result bqCancelBuffer(Binder *b, s32 buf, const NvMultiFence *fence);
 Result bqQuery(Binder *b, s32 what, s32* value);
-Result bqConnect(Binder *b, s32 api, bool producerControlledByApp, BqQueueBufferOutput *output);
+Result bqConnect(Binder *b, s32 api, bool producerControlledByApp, BqBufferOutput *output);
 Result bqDisconnect(Binder *b, s32 api);
-Result bqSetPreallocatedBuffer(Binder *b, s32 buf, BqGraphicBuffer *input);
+Result bqSetPreallocatedBuffer(Binder *b, s32 buf, const BqGraphicBuffer *input);

nx/include/switch/display/framebuffer.h

@@ -0,0 +1,104 @@
+/**
+ * @file framebuffer.h
+ * @brief Framebuffer wrapper object, providing support for software rendered graphics.
+ * @author fincs
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../nvidia/map.h"
+#include "native_window.h"
+
+/// Converts red/green/blue/alpha components to packed RGBA8 (i.e. \ref PIXEL_FORMAT_RGBA_8888).
+#define RGBA8(r,g,b,a) (((r)&0xff)|(((g)&0xff)<<8)|(((b)&0xff)<<16)|(((a)&0xff)<<24))
+
+/// Same as \ref RGBA8 except with alpha=0xff.
+#define RGBA8_MAXALPHA(r,g,b) RGBA8((r),(g),(b),0xff)
+
+/// Converts red/green/blue to packed RGBX8 (i.e. \ref PIXEL_FORMAT_RGBX_8888).
+#define RGBX8(r,g,b) RGBA8((r),(g),(b),0)
+
+/// Converts red/green/blue components to packed RGB565 (i.e. \ref PIXEL_FORMAT_RGB_565)
+#define RGB565(r,g,b) (((b)&0x1f)|(((g)&0x3f)<<5)|(((r)&0x1f)<<11))
+
+/// Same as \ref RGB565 but accepting 8-bit components as input instead.
+#define RGB565_FROM_RGB8(r,g,b) RGB565((r)>>3,(g)>>2,(b)>>3)
+
+/// Converts red/green/blue/alpha components to packed BGR8 (i.e. \ref PIXEL_FORMAT_BGRA_8888).
+#define BGRA8(r,g,b,a) RGBA8((b),(g),(r),(a))
+
+/// Same as \ref BGRA8 except with alpha=0xff.
+#define BGRA8_MAXALPHA(r,g,b) RGBA8((b),(g),(r),0xff)
+
+/// Converts red/green/blue/alpha components to packed RGBA4 (i.e. \ref PIXEL_FORMAT_RGBA_4444).
+#define RGBA4(r,g,b,a) (((r)&0xf)|(((g)&0xf)<<4)|(((b)&0xf)<<8)|(((a)&0xf)<<12))
+
+/// Same as \ref RGBA4 except with alpha=0xf.
+#define RGBA4_MAXALPHA(r,g,b) RGBA4((r),(g),(b),0xf)
+
+/// Same as \ref RGBA4 but accepting 8-bit components as input instead.
+#define RGBA4_FROM_RGBA8(r,g,b,a) RGBA4((r)>>4,(g)>>4,(b)>>4,(a)>>4)
+
+/// Same as \ref RGBA4_MAXALPHA except with alpha=0xff.
+#define RGBA4_FROM_RGBA8_MAXALPHA(r,g,b) RGBA4_MAXALPHA((r)>>4,(g)>>4,(b)>>4)
+
+/// Framebuffer structure.
+typedef struct Framebuffer {
+    NWindow *win;
+    NvMap map;
+    void* buf;
+    void* buf_linear;
+    u32 stride;
+    u32 width_aligned;
+    u32 height_aligned;
+    u32 num_fbs;
+    u32 fb_size;
+    bool has_init;
+} Framebuffer;
+
+/**
+ * @brief Creates a \ref Framebuffer object.
+ * @param[out] fb Output \ref Framebuffer structure.
+ * @param[in] win Pointer to the \ref NWindow to which the \ref Framebuffer will be registered.
+ * @param[in] width Desired width of the framebuffer (usually 1280).
+ * @param[in] height Desired height of the framebuffer (usually 720).
+ * @param[in] format Desired pixel format (see PIXEL_FORMAT_* enum).
+ * @param[in] num_fbs Number of buffers to create. Pass 1 for single-buffering, 2 for double-buffering or 3 for triple-buffering.
+ * @note Framebuffer images are stored in Tegra block linear format with 16Bx2 sector ordering, read TRM chapter 20.1 for more details.
+ *       In order to use regular linear layout, consider calling \ref framebufferMakeLinear after the \ref Framebuffer object is created.
+ * @note Presently, only the following pixel formats are supported:
+ *       \ref PIXEL_FORMAT_RGBA_8888
+ *       \ref PIXEL_FORMAT_RGBX_8888
+ *       \ref PIXEL_FORMAT_RGB_565
+ *       \ref PIXEL_FORMAT_BGRA_8888
+ *       \ref PIXEL_FORMAT_RGBA_4444
+ */
+Result framebufferCreate(Framebuffer* fb, NWindow *win, u32 width, u32 height, u32 format, u32 num_fbs);
+
+/// Enables linear framebuffer mode in a \ref Framebuffer, allocating a shadow buffer in the process.
+Result framebufferMakeLinear(Framebuffer* fb);
+
+/// Closes a \ref Framebuffer object, freeing all resources associated with it.
+void framebufferClose(Framebuffer* fb);
+
+/**
+ * @brief Begins rendering a frame in a \ref Framebuffer.
+ * @param[in] fb Pointer to \ref Framebuffer structure.
+ * @param[out] out_stride Output variable containing the distance in bytes between rows of pixels in memory.
+ * @return Pointer to buffer to which new graphics data should be written to.
+ * @note When this function is called, a buffer will be dequeued from the corresponding \ref NWindow.
+ * @note This function will return pointers to different buffers, depending on the number of buffers it was initialized with.
+ * @note If \ref framebufferMakeLinear was used, this function will instead return a pointer to the shadow linear buffer.
+ *       In this case, the offset of a pixel is \p y * \p out_stride + \p x * \p bytes_per_pixel.
+ * @note Each call to \ref framebufferBegin must be paired with a \ref framebufferEnd call.
+ */
+void* framebufferBegin(Framebuffer* fb, u32* out_stride);
+
+/**
+ * @brief Finishes rendering a frame in a \ref Framebuffer.
+ * @param[in] fb Pointer to \ref Framebuffer structure.
+ * @note When this function is called, the written image data will be flushed and queued (presented) in the corresponding \ref NWindow.
+ * @note If \ref framebufferMakeLinear was used, this function will copy the image from the shadow linear buffer to the actual framebuffer,
+ *       converting it in the process to the layout expected by the compositor.
+ * @note Each call to \ref framebufferBegin must be paired with a \ref framebufferEnd call.
+ */
+void framebufferEnd(Framebuffer* fb);

nx/include/switch/display/gfx.h

@@ -1,119 +0,0 @@
-/**
- * @file gfx.h
- * @brief High-level graphics API.
- * This API exposes a framebuffer (technically speaking, a windowbuffer) to be used for drawing graphics.
- * @author yellows8
- * @copyright libnx Authors
- */
-#pragma once
-#include "../types.h"
-#include "../nvidia/fence.h"
-
-/// Converts red, green, blue, and alpha components to packed RGBA8.
-#define RGBA8(r,g,b,a)  (((r)&0xff)|(((g)&0xff)<<8)|(((b)&0xff)<<16)|(((a)&0xff)<<24))
-
-/// Same as \ref RGBA8 except with alpha=0xff.
-#define RGBA8_MAXALPHA(r,g,b) RGBA8(r,g,b,0xff)
-
-/// GfxMode set by \ref gfxSetMode. The default is GfxMode_LinearDouble. Note that the text-console (see console.h) sets this to GfxMode_TiledDouble.
-typedef enum
-{
-    GfxMode_TiledDouble, ///< Double-buffering with raw tiled (block-linear) framebuffer.
-    GfxMode_LinearDouble ///< Double-buffering with linear framebuffer, which is transferred to the actual framebuffer by \ref gfxFlushBuffers().
-} GfxMode;
-
-/// Framebuffer pixel-format is RGBA8888, there's no known way to change this.
-
-/**
- * @brief Initializes the graphics subsystem.
- * @warning Do not use \ref viInitialize when using this function.
- */
-Result gfxInitDefault(void);
-
-/**
- * @brief Uninitializes the graphics subsystem.
- * @warning Do not use \ref viExit when using this function.
- */
-void gfxExit(void);
-
-/**
- * @brief Sets the resolution to be used when initializing the graphics subsystem.
- * @param[in] width Horizontal resolution, in pixels.
- * @param[in] height Vertical resolution, in pixels.
- * @note The default resolution is 720p.
- * @note This can only be used before calling \ref gfxInitDefault, this will use \ref fatalSimple otherwise. If the input is 0, the default resolution will be used during \ref gfxInitDefault. This sets the maximum resolution for the framebuffer, used during \ref gfxInitDefault. This is also used as the current resolution when crop isn't set. The width/height are reset to the default when \ref gfxExit is used.
- * @note Normally you should only use this when you need a maximum resolution larger than the default, see above.
- * @note The width and height are aligned to 4.
- */
-void gfxInitResolution(u32 width, u32 height);
-
-/// Wrapper for \ref gfxInitResolution with resolution=1080p. Use this if you want to support 1080p or >720p in docked-mode.
-void gfxInitResolutionDefault(void);
-
-/// Configure framebuffer crop, by default crop is all-zero. Use all-zero input to reset to default. \ref gfxExit resets this to the default.
-/// When the input is invalid this returns without changing the crop data, this includes the input values being larger than the framebuf width/height.
-/// This will update the display width/height returned by \ref gfxGetFramebuffer, with that width/height being reset to the default when required.
-/// \ref gfxGetFramebufferDisplayOffset uses absolute x/y, it will not adjust for non-zero crop left/top.
-/// When used during frame-drawing, this should be called before \ref gfxGetFramebuffer.
-/// The right and bottom params are aligned to 4.
-void gfxConfigureCrop(s32 left, s32 top, s32 right, s32 bottom);
-
-/// Wrapper for \ref gfxConfigureCrop. Use this to set the resolution, within the bounds of the maximum resolution. Use all-zero input to reset to default.
-void gfxConfigureResolution(s32 width, s32 height);
-
-/// If enabled, \ref gfxConfigureResolution will be used with the input resolution for the current OperationMode. Then \ref gfxConfigureResolution will automatically be used with the specified resolution each time OperationMode changes.
-void gfxConfigureAutoResolution(bool enable, s32 handheld_width, s32 handheld_height, s32 docked_width, s32 docked_height);
-
-/// Wrapper for \ref gfxConfigureAutoResolution. handheld_resolution=720p, docked_resolution={all-zero for using current maximum resolution}.
-void gfxConfigureAutoResolutionDefault(bool enable);
-
-/// Waits for vertical sync.
-void gfxWaitForVsync(void);
-
-/// Appends one or more fences that the display service will wait on before rendering the current framebuffer. Note that only up to 4 fences can be submitted.
-void gfxAppendFence(NvMultiFence* mf);
-
-/// Swaps the framebuffers.
-void gfxSwapBuffers(void);
-
-/// Get the specified framebuffer nvmap handle where index specifies the buffer number beginning with the back buffer, with optional output ptr for the offset in the buffer.
-u32 gfxGetFramebufferHandle(u32 index, u32* offset);
-
-/// Get the current framebuffer address, with optional output ptrs for the display framebuffer width/height. The display width/height is adjusted by \ref gfxConfigureCrop and \ref gfxConfigureResolution.
-u8* gfxGetFramebuffer(u32* width, u32* height);
-
-/// Get the framebuffer width/height without crop.
-void gfxGetFramebufferResolution(u32* width, u32* height);
-
-/// Use this to get the actual byte-size of the framebuffer for use with memset/etc.
-size_t gfxGetFramebufferSize(void);
-
-/// Use this to get the actual byte-pitch of the framebuffer for use with memset/etc.
-u32 gfxGetFramebufferPitch(void);
-
-/// Sets the \ref GfxMode.
-void gfxSetMode(GfxMode mode);
-
-/// Configures transform. See the NATIVE_WINDOW_TRANSFORM_* enums in buffer_producer.h. The default is 0.
-void gfxConfigureTransform(u32 transform);
-
-/// Flushes the framebuffer in the data cache. When \ref GfxMode is GfxMode_LinearDouble, this also transfers the linear-framebuffer to the actual framebuffer.
-void gfxFlushBuffers(void);
-
-/// Use this to get the pixel-offset in the framebuffer. Returned value is in pixels, not bytes.
-/// This implements tegra blocklinear, with hard-coded constants etc.
-/// Do not use this when \ref GfxMode is GfxMode_LinearDouble.
-static inline u32 gfxGetFramebufferDisplayOffset(u32 x, u32 y) {
-    u32 tmp_pos;
-
-    extern size_t g_gfx_framebuf_aligned_width;
-
-    //if (x >= g_gfx_framebuf_width || y >= g_gfx_framebuf_display_height) return (gfxGetFramebufferSize()-4)/4;//Return the last pixel-offset in the buffer, the data located here is not displayed due to alignment. (Disabled for perf)
-
-    tmp_pos = ((y & 127) / 16) + (x/16*8) + ((y/16/8)*(g_gfx_framebuf_aligned_width/16*8));
-    tmp_pos *= 16*16 * 4;
-
-    tmp_pos += ((y%16)/8)*512 + ((x%16)/8)*256 + ((y%8)/2)*64 + ((x%8)/4)*32 + (y%2)*16 + (x%4)*4;//This line is a modified version of code from the Tegra X1 datasheet.
-
-    return tmp_pos / 4;
-}

nx/include/switch/display/native_window.h

@@ -0,0 +1,190 @@
+/**
+ * @file native_window.h
+ * @brief Native window (NWindow) wrapper object, used for presenting images to the display (or other sinks).
+ * @author fincs
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../kernel/mutex.h"
+#include "../kernel/event.h"
+#include "../services/vi.h"
+#include "../nvidia/graphic_buffer.h"
+#include "types.h"
+#include "binder.h"
+#include "buffer_producer.h"
+
+/// Native window structure.
+typedef struct NWindow {
+    u32 magic;
+    Binder bq;
+    Event event;
+    Mutex mutex;
+    u64 slots_configured;
+    u64 slots_requested;
+    s32 cur_slot;
+    u32 width;
+    u32 height;
+    u32 format;
+    u32 usage;
+    BqRect crop;
+    u32 scaling_mode;
+    u32 transform;
+    u32 sticky_transform;
+    u32 default_width;
+    u32 default_height;
+    u32 swap_interval;
+    bool is_connected;
+    bool producer_controlled_by_app;
+    bool consumer_running_behind;
+} NWindow;
+
+///@name Basic functions
+///@{
+
+/// Checks whether a pointer refers to a valid \ref NWindow object.
+bool nwindowIsValid(NWindow* nw);
+
+/**
+ * @brief Retrieves the default \ref NWindow object.
+ * @return Pointer to the default \ref NWindow object.
+ * @note When this function is used/referenced, libnx will initialize VI services
+ *       and create a \ref NWindow object from a \ref ViLayer created on the default \ref ViDisplay;
+ *       all of this happening automatically during application startup (i.e. before main is called).
+ *       If creating the default \ref NWindow fails, libnx will throw a LibnxError_BadGfxInit fatal error.
+ *       Likewise, after main returns (or exit is called) libnx will clean up all resources used by it.
+ */
+NWindow* nwindowGetDefault(void);
+
+/**
+ * @brief Creates a \ref NWindow.
+ * @param[out] nw Output \ref NWindow structure.
+ * @param[in] binder_session Service object for the Android IGraphicBufferProducer binder session.
+ * @param[in] binder_id Android IGraphicBufferProducer binder session ID.
+ * @param[in] producer_controlled_by_app Specifies whether the producer is controlled by the application.
+ */
+Result nwindowCreate(NWindow* nw, Service* binder_session, s32 binder_id, bool producer_controlled_by_app);
+
+/**
+ * @brief Creates a \ref NWindow operating on a \ref ViLayer.
+ * @param[out] nw Output \ref NWindow structure.
+ * @param[in] layer Pointer to \ref ViLayer structure (such as the one returned by \ref viCreateLayer).
+ */
+Result nwindowCreateFromLayer(NWindow* nw, const ViLayer* layer);
+
+/// Closes a \ref NWindow, freeing all resources associated with it.
+void nwindowClose(NWindow* nw);
+
+///@}
+
+///@name Window configuration
+///@{
+
+/**
+ * @brief Retrieves the dimensions of a \ref NWindow.
+ * @param[in] nw Pointer to \ref NWindow structure.
+ * @param[out] out_width Output variable containing the width of the \ref NWindow.
+ * @param[out] out_height Output variable containing the height of the \ref NWindow.
+ * @note After creation, a \ref NWindow reports a default size (usually 1280x720).
+ *       This size can be overriden by calling \ref nwindowSetDimensions.
+ */
+Result nwindowGetDimensions(NWindow* nw, u32* out_width, u32* out_height);
+
+/**
+ * @brief Sets the dimensions of a \ref NWindow.
+ * @param[in] nw Pointer to \ref NWindow structure.
+ * @param[in] width Desired width of the \ref NWindow.
+ * @param[in] height Desired width of the \ref NWindow.
+ * @note This function cannot be called when there are buffers registered with the \ref NWindow.
+ */
+Result nwindowSetDimensions(NWindow* nw, u32 width, u32 height);
+
+/**
+ * @brief Configures the crop applied to images presented through a \ref NWindow.
+ * @param[in] nw Pointer to \ref NWindow structure.
+ * @param[in] left X coordinate of the left margin of the crop bounding box.
+ * @param[in] top Y coordinate of the top margin of the crop bounding box.
+ * @param[in] right X coordinate of the right margin of the crop bounding box.
+ * @param[in] bottom Y coordinate of the bottom margin of the crop bounding box.
+ * @note Passing zero to all parameters disables the crop functionality. This is also the default.
+ * @note The bounding box defined by the parameters will be adjusted to fit within the dimensions of the \ref NWindow.
+ * @note \p left must be less or equal than \p right.
+ * @note \p top must be less or equal than \p bottom.
+ */
+Result nwindowSetCrop(NWindow* nw, s32 left, s32 top, s32 right, s32 bottom);
+
+/**
+ * @brief Configures the transformation applied to images presented through a \ref NWindow.
+ * @param[in] nw Pointer to \ref NWindow structure.
+ * @param[in] transform Android transformation mode (see NATIVE_WINDOW_TRANSFORM_* enum)
+ * @note The default transformation is 0 (i.e. no transformation applied)
+ */
+Result nwindowSetTransform(NWindow* nw, u32 transform);
+
+/**
+ * @brief Configures the swap interval of a \ref NWindow.
+ * @param[in] nw Pointer to \ref NWindow structure.
+ * @param[in] swap_interval Value specifying the number of display refreshes (VBlanks) that must occur between presenting images.
+ * @note The default swap interval is 1.
+ * @note If the \ref NWindow has three or more buffers configured (with \ref nwindowConfigureBuffer), it is possible to pass 0
+ *       to disable the swap interval feature and present images as fast as allowed by the compositor. Otherwise, the system
+ *       enforces a minimum of 1 as the swap interval.
+ */
+Result nwindowSetSwapInterval(NWindow* nw, u32 swap_interval);
+
+/// Checks whether the consumer of a \ref NWindow is running behind.
+static inline bool nwindowIsConsumerRunningBehind(NWindow* nw)
+{
+    return nw->consumer_running_behind;
+}
+
+///@}
+
+///@name Buffer configuration and presentation
+///@{
+
+/**
+ * @brief Registers a \ref NvGraphicBuffer with a \ref NWindow.
+ * @param[in] nw Pointer to \ref NWindow structure.
+ * @param[in] slot ID of the slot to configure (starting from 0).
+ * @param[in] buf Pointer to \ref NvGraphicBuffer structure.
+ * @note When a buffer is registered, it is added to the internal queue of buffers used for presenting.
+ * @note All buffers registered with a \ref NWindow must have the same dimensions, format and usage.
+ *       If \ref nwindowSetDimensions has not been previously called, the \ref NWindow will automatically
+ *       adopt the dimensions of the first buffer registered with it. Otherwise, said buffer will need
+ *       to match the dimensions that were previously configured.
+ */
+Result nwindowConfigureBuffer(NWindow* nw, s32 slot, NvGraphicBuffer* buf);
+
+/**
+ * @brief Dequeues a buffer from a \ref NWindow.
+ * @param[in] nw Pointer to \ref NWindow structure.
+ * @param[out] out_slot Output variable containing the ID of the slot that has been dequeued.
+ * @param[out] out_fence Output variable containing a \ref NvMultiFence that will be signalled by
+ *             the compositor when the buffer is ready to be written to. Pass NULL to wait instead
+ *             on this fence before this function returns.
+ * @note For \p out_fence=NULL to work, \ref nvFenceInit must have been previously called.
+ */
+Result nwindowDequeueBuffer(NWindow* nw, s32* out_slot, NvMultiFence* out_fence);
+
+/**
+ * @brief Cancels a buffer previously dequeued with \ref nwindowDequeueBuffer.
+ * @param[in] nw Pointer to \ref NWindow structure.
+ * @param[in] slot ID of the slot to cancel. This must match the output of the previous \ref nwindowDequeueBuffer call.
+ * @param[in] fence Pointer to the \ref NvMultiFence that will be waited on by the compositor before cancelling the buffer.
+ *                  Pass NULL if there is no such fence.
+ */
+Result nwindowCancelBuffer(NWindow* nw, s32 slot, const NvMultiFence* fence);
+
+/**
+ * @brief Queues a buffer previously dequeued with \ref nwindowDequeueBuffer, making it ready for presentation.
+ * @param[in] nw Pointer to \ref NWindow structure.
+ * @param[in] slot ID of the slot to queue. This must match the output of the previous \ref nwindowDequeueBuffer call.
+ * @param[in] fence Pointer to the \ref NvMultiFence that will be waited on by the compositor before queuing/presenting the buffer.
+ *                  Pass NULL if there is no such fence.
+ */
+Result nwindowQueueBuffer(NWindow* nw, s32 slot, const NvMultiFence* fence);
+
+/// Releases all buffers registered with a \ref NWindow.
+Result nwindowReleaseBuffers(NWindow* nw);
+
+///@}

nx/include/switch/display/nvgfx.h

@@ -1,7 +0,0 @@
-#pragma once
-#include "../types.h"
-
-Result nvgfxInitialize(void);
-void nvgfxExit(void);
-Result nvgfxSubmitGpfifo(void);
-Result nvgfxGetFramebuffer(u8 **buffer, size_t *size, u32 *handle);

nx/include/switch/display/parcel.h

@@ -24,7 +24,7 @@ typedef struct {
 void parcelCreate(Parcel *ctx);
 Result parcelTransact(Binder *session, u32 code, Parcel *in_parcel, Parcel *reply_parcel);
 
-void* parcelWriteData(Parcel *ctx, void* data, size_t data_size);
+void* parcelWriteData(Parcel *ctx, const void* data, size_t data_size);
 void* parcelReadData(Parcel *ctx, void* data, size_t data_size);
 
 void parcelWriteInt32(Parcel *ctx, s32 val);
@@ -36,5 +36,5 @@ u32 parcelReadUInt32(Parcel *ctx);
 void parcelWriteInterfaceToken(Parcel *ctx, const char *str);
 
 void* parcelReadFlattenedObject(Parcel *ctx, size_t *size);
-void* parcelWriteFlattenedObject(Parcel *ctx, void* data, size_t size);
+void* parcelWriteFlattenedObject(Parcel *ctx, const void* data, size_t size);
 

nx/include/switch/display/types.h

@@ -1,3 +1,8 @@
+/**
+ * @file display/types.h
+ * @brief Definitions for Android-related types and enumerations.
+ * @copyright libnx Authors
+ */
 #pragma once
 #include "../types.h"
 
@@ -133,3 +138,10 @@ enum {
     /* rotate source image 270 degrees clock-wise */
     NATIVE_WINDOW_TRANSFORM_ROT_270 = HAL_TRANSFORM_ROT_270,
 };
+
+// From Android native_handle.h.
+typedef struct {
+    int version;
+    int num_fds;
+    int num_ints;
+} NativeHandle;

nx/include/switch/kernel/barrier.h

@@ -0,0 +1,30 @@
+/**
+ * @file barrier.h
+ * @brief Multi-threading Barrier
+ * @author tatehaga
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "mutex.h"
+#include "condvar.h"
+
+/// Barrier structure.
+typedef struct Barrier {
+    u64 count;  ///< Number of threads to reach the barrier.
+    u64 total;  ///< Number of threads to wait on.
+    Mutex mutex;
+    CondVar condvar;
+} Barrier;
+
+/**
+ * @brief Initializes a barrier and the number of threads to wait on.
+ * @param b Barrier object.
+ * @param thread_count Initial value for the number of threads the barrier must wait for.
+ */
+void barrierInit(Barrier *b, u64 thread_count);
+
+/**
+ * @brief Forces threads to wait until all threads have called barrierWait.
+ * @param b Barrier object.
+ */
+void barrierWait(Barrier *b);

nx/include/switch/kernel/condvar.h

@@ -40,7 +40,7 @@ Result condvarWaitTimeout(CondVar* c, Mutex* m, u64 timeout);
  */
 static inline Result condvarWait(CondVar* c, Mutex* m)
 {
-    return condvarWaitTimeout(c, m, U64_MAX);
+    return condvarWaitTimeout(c, m, UINT64_MAX);
 }
 
 /**
@@ -51,7 +51,8 @@ static inline Result condvarWait(CondVar* c, Mutex* m)
  */
 static inline Result condvarWake(CondVar* c, int num)
 {
-    return svcSignalProcessWideKey(c, num);
+    svcSignalProcessWideKey(c, num);
+    return 0;
 }
 
 /**

nx/include/switch/kernel/detect.h

@@ -1,21 +1,24 @@
 /**
  * @file detect.h
- * @brief Kernel version detection
+ * @brief Kernel capability detection
  * @author plutoo
  * @copyright libnx Authors
  */
 #pragma once
 #include "../types.h"
+#include "../result.h"
+#include "svc.h"
 
-/// Returns true if the kernel version is equal to or above 2.0.0.
-bool kernelAbove200(void);
-/// Returns true if the kernel version is equal to or above 3.0.0.
-bool kernelAbove300(void);
-/// Returns true if the kernel version is equal to or above 4.0.0.
-bool kernelAbove400(void);
-/// Returns true if the kernel version is equal to or above 5.0.0.
-bool kernelAbove500(void);
-/// Returns true if the kernel version is equal to or above 6.0.0.
-bool kernelAbove600(void);
 /// Returns true if the process has a debugger attached.
-bool detectDebugger(void);
+NX_INLINE bool detectDebugger(void) {
+    u64 tmp = 0;
+    Result rc = svcGetInfo(&tmp, InfoType_DebuggerAttached, INVALID_HANDLE, 0);
+    return R_SUCCEEDED(rc) && tmp != 0;
+}
+
+/// Returns true if the underlying kernel is Mesosphère.
+NX_INLINE bool detectMesosphere(void) {
+    u64 dummy = 0;
+    Result rc = svcGetInfo(&dummy, 65000, INVALID_HANDLE, 0); // InfoType_MesosphereMeta
+    return R_SUCCEEDED(rc);
+}

nx/include/switch/kernel/event.h

@@ -1,19 +1,84 @@
-// Copyright 2018 plutoo
+/**
+ * @file event.h
+ * @brief Kernel-mode event synchronization primitive.
+ * @author plutoo
+ * @copyright libnx Authors
+ */
 #pragma once
 #include "../types.h"
 #include "../result.h"
-#include "../kernel/svc.h"
+#include "wait.h"
 
+/// Kernel-mode event structure.
 typedef struct {
-    Handle revent;
-    Handle wevent;
-    bool autoclear;
+    Handle revent;  ///< Read-only event handle
+    Handle wevent;  ///< Write-only event handle
+    bool autoclear; ///< Autoclear flag
 } Event;
 
+/// Creates a \ref Waiter for a kernel-mode event.
+static inline Waiter waiterForEvent(Event* t)
+{
+    Waiter wait_obj;
+    wait_obj.type = t->autoclear ? WaiterType_HandleWithClear : WaiterType_Handle;
+    wait_obj.handle = t->revent;
+    return wait_obj;
+}
+
+/**
+ * @brief Creates a kernel-mode event.
+ * @param[out] t Pointer to \ref Event structure.
+ * @param[in] autoclear Autoclear flag.
+ * @return Result code.
+ * @warning This is a privileged operation; in normal circumstances applications shouldn't use this function.
+ */
 Result eventCreate(Event* t, bool autoclear);
+
+/**
+ * @brief Loads a kernel-mode event obtained from IPC.
+ * @param[out] t Pointer to \ref Event structure.
+ * @param[in] handle Read-only event handle.
+ * @param[in] autoclear Autoclear flag.
+ */
 void   eventLoadRemote(Event* t, Handle handle, bool autoclear);
+
+/**
+ * @brief Closes a kernel-mode event.
+ * @param[in] t Pointer to \ref Event structure.
+ */
 void   eventClose(Event* t);
 
+/**
+ * @brief Returns whether an \ref Event is initialized.
+ * @param[in] t Pointer to \ref Event structure.
+ * @return Initialization status.
+ */
+static inline bool eventActive(Event* t)
+{
+    return t->revent != INVALID_HANDLE;
+}
+
+/**
+ * @brief Waits on a kernel-mode event.
+ * @param[in] t Pointer to \ref Event structure.
+ * @param[in] timeout Timeout in nanoseconds (pass UINT64_MAX to wait indefinitely).
+ * @return Result code.
+ */
 Result eventWait(Event* t, u64 timeout);
+
+/**
+ * @brief Signals a kernel-mode event.
+ * @param[in] t Pointer to \ref Event structure.
+ * @return Result code.
+ * @note This function only works for events initialized with \ref eventCreate, it doesn't work with events initialized with \ref eventLoadRemote.
+ * @warning This is a privileged operation; in normal circumstances applications shouldn't use this function.
+ */
 Result eventFire(Event* t);
+
+/**
+ * @brief Clears a kernel-mode event.
+ * @param[in] t Pointer to \ref Event structure.
+ * @return Result code.
+ * @note This function shouldn't be used on autoclear events.
+ */
 Result eventClear(Event* t);

nx/include/switch/kernel/ipc.h

@@ -1,716 +0,0 @@
-/**
- * @file ipc.h
- * @brief Inter-process communication handling
- * @author plutoo
- * @copyright libnx Authors
- */
-#pragma once
-#include "../result.h"
-#include "../arm/tls.h"
-#include "../kernel/svc.h"
-
-/// IPC input header magic
-#define SFCI_MAGIC 0x49434653
-/// IPC output header magic
-#define SFCO_MAGIC 0x4f434653
-
-/// IPC invalid object ID
-#define IPC_INVALID_OBJECT_ID UINT32_MAX
-
-///@name IPC request building
-///@{
-
-/// IPC command (request) structure.
-#define IPC_MAX_BUFFERS 8
-#define IPC_MAX_OBJECTS 8
-
-typedef enum {
-    BufferType_Normal=0,  ///< Regular buffer.
-    BufferType_Type1=1,   ///< Allows ProcessMemory and shared TransferMemory.
-    BufferType_Invalid=2,
-    BufferType_Type3=3    ///< Same as Type1 except remote process is not allowed to use device-mapping.
-} BufferType;
-
-typedef enum {
-    BufferDirection_Send=0,
-    BufferDirection_Recv=1,
-    BufferDirection_Exch=2,
-} BufferDirection;
-
-typedef enum {
-    IpcCommandType_Invalid = 0,
-    IpcCommandType_LegacyRequest = 1,
-    IpcCommandType_Close = 2,
-    IpcCommandType_LegacyControl = 3,
-    IpcCommandType_Request = 4,
-    IpcCommandType_Control = 5,
-    IpcCommandType_RequestWithContext = 6,
-    IpcCommandType_ControlWithContext = 7,
-} IpcCommandType;
-
-typedef enum {
-    DomainMessageType_Invalid = 0,
-    DomainMessageType_SendMessage = 1,
-    DomainMessageType_Close = 2,
-} DomainMessageType;
-
-/// IPC domain message header.
-typedef struct {
-    u8  Type;
-    u8  NumObjectIds;
-    u16 Length;
-    u32 ThisObjectId;
-    u32 Pad[2];
-} DomainMessageHeader;
-
-typedef struct {
-    size_t NumSend; // A
-    size_t NumRecv; // B
-    size_t NumExch; // W
-    const void* Buffers[IPC_MAX_BUFFERS];
-    size_t BufferSizes[IPC_MAX_BUFFERS];
-    BufferType BufferTypes[IPC_MAX_BUFFERS];
-
-    size_t NumStaticIn;  // X
-    size_t NumStaticOut; // C
-    const void* Statics[IPC_MAX_BUFFERS];
-    size_t StaticSizes[IPC_MAX_BUFFERS];
-    u8     StaticIndices[IPC_MAX_BUFFERS];
-
-    bool   SendPid;
-    size_t NumHandlesCopy;
-    size_t NumHandlesMove;
-    Handle Handles[IPC_MAX_OBJECTS];
-
-    size_t NumObjectIds;
-    u32    ObjectIds[IPC_MAX_OBJECTS];
-} IpcCommand;
-
-/**
- * @brief Initializes an IPC command structure.
- * @param cmd IPC command structure.
- */
-static inline void ipcInitialize(IpcCommand* cmd) {
-    *cmd = (IpcCommand){0};
-}
-
-/// IPC buffer descriptor.
-typedef struct {
-    u32 Size;   ///< Size of the buffer.
-    u32 Addr;   ///< Lower 32-bits of the address of the buffer
-    u32 Packed; ///< Packed data (including higher bits of the address)
-} IpcBufferDescriptor;
-
-/// IPC static send-buffer descriptor.
-typedef struct {
-    u32 Packed; ///< Packed data (including higher bits of the address)
-    u32 Addr;   ///< Lower 32-bits of the address
-} IpcStaticSendDescriptor;
-
-/// IPC static receive-buffer descriptor.
-typedef struct {
-    u32 Addr;   ///< Lower 32-bits of the address of the buffer
-    u32 Packed; ///< Packed data (including higher bits of the address)
-} IpcStaticRecvDescriptor;
-
-/**
- * @brief Adds a buffer to an IPC command structure.
- * @param cmd IPC command structure.
- * @param buffer Address of the buffer.
- * @param size Size of the buffer.
- * @param type Buffer type.
- */
-static inline void ipcAddSendBuffer(IpcCommand* cmd, const void* buffer, size_t size, BufferType type) {
-    size_t off = cmd->NumSend;
-    cmd->Buffers[off] = buffer;
-    cmd->BufferSizes[off] = size;
-    cmd->BufferTypes[off] = type;
-    cmd->NumSend++;
-}
-
-/**
- * @brief Adds a receive-buffer to an IPC command structure.
- * @param cmd IPC command structure.
- * @param buffer Address of the buffer.
- * @param size Size of the buffer.
- * @param type Buffer type.
- */
-static inline void ipcAddRecvBuffer(IpcCommand* cmd, void* buffer, size_t size, BufferType type) {
-    size_t off = cmd->NumSend + cmd->NumRecv;
-    cmd->Buffers[off] = buffer;
-    cmd->BufferSizes[off] = size;
-    cmd->BufferTypes[off] = type;
-    cmd->NumRecv++;
-}
-
-/**
- * @brief Adds an exchange-buffer to an IPC command structure.
- * @param cmd IPC command structure.
- * @param buffer Address of the buffer.
- * @param size Size of the buffer.
- * @param type Buffer type.
- */
-static inline void ipcAddExchBuffer(IpcCommand* cmd, void* buffer, size_t size, BufferType type) {
-    size_t off = cmd->NumSend + cmd->NumRecv + cmd->NumExch;
-    cmd->Buffers[off] = buffer;
-    cmd->BufferSizes[off] = size;
-    cmd->BufferTypes[off] = type;
-    cmd->NumExch++;
-}
-
-/**
- * @brief Adds a static-buffer to an IPC command structure.
- * @param cmd IPC command structure.
- * @param buffer Address of the buffer.
- * @param size Size of the buffer.
- * @param index Index of buffer.
- */
-static inline void ipcAddSendStatic(IpcCommand* cmd, const void* buffer, size_t size, u8 index) {
-    size_t off = cmd->NumStaticIn;
-    cmd->Statics[off] = buffer;
-    cmd->StaticSizes[off] = size;
-    cmd->StaticIndices[off] = index;
-    cmd->NumStaticIn++;
-}
-
-/**
- * @brief Adds a static-receive-buffer to an IPC command structure.
- * @param cmd IPC command structure.
- * @param buffer Address of the buffer.
- * @param size Size of the buffer.
- * @param index Index of buffer.
- */
-static inline void ipcAddRecvStatic(IpcCommand* cmd, void* buffer, size_t size, u8 index) {
-    size_t off = cmd->NumStaticIn + cmd->NumStaticOut;
-    cmd->Statics[off] = buffer;
-    cmd->StaticSizes[off] = size;
-    cmd->StaticIndices[off] = index;
-    cmd->NumStaticOut++;
-}
-
-/**
- * @brief Adds a smart-buffer (buffer + static-buffer pair) to an IPC command structure.
- * @param cmd IPC command structure.
- * @param ipc_buffer_size IPC buffer size.
- * @param buffer Address of the buffer.
- * @param size Size of the buffer.
- * @param index Index of buffer.
- */
-static inline void ipcAddSendSmart(IpcCommand* cmd, size_t ipc_buffer_size, const void* buffer, size_t size, u8 index) {
-    if (ipc_buffer_size != 0 && size <= ipc_buffer_size) {
-        ipcAddSendBuffer(cmd, NULL, 0, BufferType_Normal);
-        ipcAddSendStatic(cmd, buffer, size, index);
-    } else {
-        ipcAddSendBuffer(cmd, buffer, size, BufferType_Normal);
-        ipcAddSendStatic(cmd, NULL, 0, index);
-    }
-}
-
-/**
- * @brief Adds a smart-receive-buffer (buffer + static-receive-buffer pair) to an IPC command structure.
- * @param cmd IPC command structure.
- * @param ipc_buffer_size IPC buffer size.
- * @param buffer Address of the buffer.
- * @param size Size of the buffer.
- * @param index Index of buffer.
- */
-static inline void ipcAddRecvSmart(IpcCommand* cmd, size_t ipc_buffer_size, void* buffer, size_t size, u8 index) {
-    if (ipc_buffer_size != 0 && size <= ipc_buffer_size) {
-        ipcAddRecvBuffer(cmd, NULL, 0, BufferType_Normal);
-        ipcAddRecvStatic(cmd, buffer, size, index);
-    } else {
-        ipcAddRecvBuffer(cmd, buffer, size, BufferType_Normal);
-        ipcAddRecvStatic(cmd, NULL, 0, index);
-    }
-}
-
-/**
- * @brief Tags an IPC command structure to send the PID.
- * @param cmd IPC command structure.
- */
-static inline void ipcSendPid(IpcCommand* cmd) {
-    cmd->SendPid = true;
-}
-
-/**
- * @brief Adds a copy-handle to be sent through an IPC command structure.
- * @param cmd IPC command structure.
- * @param h Handle to send.
- * @remark The receiving process gets a copy of the handle.
- */
-static inline void ipcSendHandleCopy(IpcCommand* cmd, Handle h) {
-    cmd->Handles[cmd->NumHandlesCopy++] = h;
-}
-
-/**
- * @brief Adds a move-handle to be sent through an IPC command structure.
- * @param cmd IPC command structure.
- * @param h Handle to send.
- * @remark The sending process loses ownership of the handle, which is transferred to the receiving process.
- */
-static inline void ipcSendHandleMove(IpcCommand* cmd, Handle h) {
-    cmd->Handles[cmd->NumHandlesCopy + cmd->NumHandlesMove++] = h;
-}
-
-/**
- * @brief Prepares the header of an IPC command structure.
- * @param cmd IPC command structure.
- * @param sizeof_raw Size in bytes of the raw data structure to embed inside the IPC request
- * @return Pointer to the raw embedded data structure in the request, ready to be filled out.
- */
-static inline void* ipcPrepareHeader(IpcCommand* cmd, size_t sizeof_raw) {
-    u32* buf = (u32*)armGetTls();
-    size_t i;
-    *buf++ = IpcCommandType_Request | (cmd->NumStaticIn << 16) | (cmd->NumSend << 20) | (cmd->NumRecv << 24) | (cmd->NumExch << 28);
-
-    u32* fill_in_size_later = buf;
-
-    if (cmd->NumStaticOut > 0) {
-        *buf = (cmd->NumStaticOut + 2) << 10;
-    }
-    else {
-        *buf = 0;
-    }
-
-    if (cmd->SendPid || cmd->NumHandlesCopy > 0 || cmd->NumHandlesMove > 0) {
-        *buf++ |= 0x80000000;
-        *buf++ = (!!cmd->SendPid) | (cmd->NumHandlesCopy << 1) | (cmd->NumHandlesMove << 5);
-
-        if (cmd->SendPid)
-            buf += 2;
-
-        for (i=0; i<(cmd->NumHandlesCopy + cmd->NumHandlesMove); i++)
-            *buf++ = cmd->Handles[i];
-    }
-    else {
-        buf++;
-    }
-
-    for (i=0; i<cmd->NumStaticIn; i++, buf+=2) {
-        IpcStaticSendDescriptor* desc = (IpcStaticSendDescriptor*) buf;
-
-        uintptr_t ptr = (uintptr_t) cmd->Statics[i];
-        desc->Addr = ptr;
-        desc->Packed = cmd->StaticIndices[i] | (cmd->StaticSizes[i] << 16) |
-            (((ptr >> 32) & 15) << 12) | (((ptr >> 36) & 15) << 6);
-    }
-
-    for (i=0; i<(cmd->NumSend + cmd->NumRecv + cmd->NumExch); i++, buf+=3) {
-        IpcBufferDescriptor* desc = (IpcBufferDescriptor*) buf;
-        desc->Size = cmd->BufferSizes[i];
-
-        uintptr_t ptr = (uintptr_t) cmd->Buffers[i];
-        desc->Addr = ptr;
-        desc->Packed = cmd->BufferTypes[i] |
-            (((ptr >> 32) & 15) << 28) | ((ptr >> 36) << 2);
-    }
-
-    u32 padding = ((16 - (((uintptr_t) buf) & 15)) & 15) / 4;
-    u32* raw = (u32*) (buf + padding);
-
-    size_t raw_size = (sizeof_raw/4) + 4;
-    buf += raw_size;
-
-    u16* buf_u16 = (u16*) buf;
-
-    for (i=0; i<cmd->NumStaticOut; i++) {
-        size_t off = cmd->NumStaticIn + i;
-        size_t sz = (uintptr_t) cmd->StaticSizes[off];
-
-        buf_u16[i] = (sz > 0xFFFF) ? 0 : sz;
-    }
-
-    size_t u16s_size = ((2*cmd->NumStaticOut) + 3)/4;
-    buf += u16s_size;
-    raw_size += u16s_size;
-
-    *fill_in_size_later |= raw_size;
-
-    for (i=0; i<cmd->NumStaticOut; i++, buf+=2) {
-        IpcStaticRecvDescriptor* desc = (IpcStaticRecvDescriptor*) buf;
-        size_t off = cmd->NumStaticIn + i;
-
-        uintptr_t ptr = (uintptr_t) cmd->Statics[off];
-        desc->Addr = ptr;
-        desc->Packed = (ptr >> 32) | (cmd->StaticSizes[off] << 16);
-    }
-
-    return (void*) raw;
-}
-
-/**
- * @brief Dispatches an IPC request.
- * @param session IPC session handle.
- * @return Result code.
- */
-static inline Result ipcDispatch(Handle session) {
-    return svcSendSyncRequest(session);
-}
-
-///@}
-
-///@name IPC response parsing
-///@{
-
-/// IPC parsed command (response) structure.
-typedef struct {
-    IpcCommandType CommandType;               ///< Type of the command  
-    
-    bool HasPid;                              ///< true if the 'Pid' field is filled out.
-    u64  Pid;                                 ///< PID included in the response (only if HasPid is true)
-
-    size_t NumHandles;                        ///< Number of handles copied.
-    Handle Handles[IPC_MAX_OBJECTS];          ///< Handles.
-    bool   WasHandleCopied[IPC_MAX_OBJECTS];  ///< true if the handle was moved, false if it was copied.
-
-    bool   IsDomainMessage;                   ///< true if the the message is a Domain message.
-    DomainMessageType MessageType;            ///< Type of the domain message.
-    u32    MessageLength;                     ///< Size of rawdata (for domain messages).
-    u32    ThisObjectId;                      ///< Object ID to call the command on (for domain messages).
-    size_t NumObjectIds;                      ///< Number of object IDs (for domain messages).
-    u32    ObjectIds[IPC_MAX_OBJECTS];        ///< Object IDs (for domain messages).
-
-    size_t NumBuffers;                        ///< Number of buffers in the response.
-    void*  Buffers[IPC_MAX_BUFFERS];          ///< Pointers to the buffers.
-    size_t BufferSizes[IPC_MAX_BUFFERS];      ///< Sizes of the buffers.
-    BufferType BufferTypes[IPC_MAX_BUFFERS];  ///< Types of the buffers.
-    BufferDirection BufferDirections[IPC_MAX_BUFFERS]; ///< Direction of each buffer.
-
-    size_t NumStatics;                        ///< Number of statics in the response.
-    void*  Statics[IPC_MAX_BUFFERS];          ///< Pointers to the statics.
-    size_t StaticSizes[IPC_MAX_BUFFERS];      ///< Sizes of the statics.
-    u8     StaticIndices[IPC_MAX_BUFFERS];    ///< Indices of the statics.
-    
-    size_t NumStaticsOut;                     ///< Number of output statics available in the response.
-
-    void*  Raw;                               ///< Pointer to the raw embedded data structure in the response.
-    void*  RawWithoutPadding;                 ///< Pointer to the raw embedded data structure, without padding.
-    size_t RawSize;                           ///< Size of the raw embedded data.
-} IpcParsedCommand;
-
-/**
- * @brief Parse an IPC command response into an IPC parsed command structure.
- * @param IPC parsed command structure to fill in.
- * @return Result code.
- */
-static inline Result ipcParse(IpcParsedCommand* r) {
-    u32* buf = (u32*)armGetTls();
-    u32 ctrl0 = *buf++;
-    u32 ctrl1 = *buf++;
-    size_t i;
-    
-    r->IsDomainMessage = false;
-
-    r->CommandType = (IpcCommandType) (ctrl0 & 0xffff);
-    r->HasPid = false;
-    r->RawSize = (ctrl1 & 0x1ff) * 4;
-    r->NumHandles = 0;
-    
-    r->NumStaticsOut = (ctrl1 >> 10) & 15;
-    if (r->NumStaticsOut >> 1) r->NumStaticsOut--; // Value 2  -> Single descriptor
-    if (r->NumStaticsOut >> 1) r->NumStaticsOut--; // Value 3+ -> (Value - 2) descriptors
-
-    if (ctrl1 & 0x80000000) {
-        u32 ctrl2 = *buf++;
-
-        if (ctrl2 & 1) {
-            r->HasPid = true;
-            r->Pid = *buf++;
-            r->Pid |= ((u64)(*buf++)) << 32;
-        }
-
-        size_t num_handles_copy = ((ctrl2 >> 1) & 15);
-        size_t num_handles_move = ((ctrl2 >> 5) & 15);
-
-        size_t num_handles = num_handles_copy + num_handles_move;
-        u32* buf_after_handles = buf + num_handles;
-
-        if (num_handles > IPC_MAX_OBJECTS)
-            num_handles = IPC_MAX_OBJECTS;
-
-        for (i=0; i<num_handles; i++)
-        {
-            r->Handles[i] = *(buf+i);
-            r->WasHandleCopied[i] = (i < num_handles_copy);
-        }
-
-        r->NumHandles = num_handles;
-        buf = buf_after_handles;
-    }
-
-    size_t num_statics = (ctrl0 >> 16) & 15;
-    u32* buf_after_statics = buf + num_statics*2;
-
-    if (num_statics > IPC_MAX_BUFFERS)
-        num_statics = IPC_MAX_BUFFERS;
-
-    for (i=0; i<num_statics; i++, buf+=2) {
-        IpcStaticSendDescriptor* desc = (IpcStaticSendDescriptor*) buf;
-        u64 packed = (u64) desc->Packed;
-
-        r->Statics[i] = (void*) (desc->Addr | (((packed >> 12) & 15) << 32) | (((packed >> 6) & 15) << 36));
-        r->StaticSizes[i]   = packed >> 16;
-        r->StaticIndices[i] = packed & 63;
-    }
-
-    r->NumStatics = num_statics;
-    buf = buf_after_statics;
-
-    size_t num_bufs_send = (ctrl0 >> 20) & 15;
-    size_t num_bufs_recv = (ctrl0 >> 24) & 15;
-    size_t num_bufs_exch = (ctrl0 >> 28) & 15;
-
-    size_t num_bufs = num_bufs_send + num_bufs_recv + num_bufs_exch;
-    r->Raw = (void*)(((uintptr_t)(buf + num_bufs*3) + 15) &~ 15);
-    r->RawWithoutPadding = (void*)((uintptr_t)(buf + num_bufs*3));
-
-    if (num_bufs > IPC_MAX_BUFFERS)
-        num_bufs = IPC_MAX_BUFFERS;
-
-    for (i=0; i<num_bufs; i++, buf+=3) {
-        IpcBufferDescriptor* desc = (IpcBufferDescriptor*) buf;
-        u64 packed = (u64) desc->Packed;
-
-        r->Buffers[i] = (void*) (desc->Addr | ((packed >> 28) << 32) | (((packed >> 2) & 15) << 36));
-        r->BufferSizes[i] = desc->Size;
-        r->BufferTypes[i] = (BufferType) (packed & 3);
-
-        if (i < num_bufs_send)
-            r->BufferDirections[i] = BufferDirection_Send;
-        else if (i < (num_bufs_send + num_bufs_recv))
-            r->BufferDirections[i] = BufferDirection_Recv;
-        else
-            r->BufferDirections[i] = BufferDirection_Exch;
-    }
-
-    r->NumBuffers = num_bufs;
-    return 0;
-}
-
-/**
- * @brief Queries the size of an IPC pointer buffer.
- * @param session IPC session handle.
- * @param size Output variable in which to store the size.
- * @return Result code.
- */
-static inline Result ipcQueryPointerBufferSize(Handle session, size_t *size) {
-    u32* buf = (u32*)armGetTls();
-
-    buf[0] = IpcCommandType_Control;
-    buf[1] = 8;
-    buf[2] = 0;
-    buf[3] = 0;
-    buf[4] = SFCI_MAGIC;
-    buf[5] = 0;
-    buf[6] = 3;
-    buf[7] = 0;
-
-    Result rc = ipcDispatch(session);
-
-    if (R_SUCCEEDED(rc)) {
-        IpcParsedCommand r;
-        ipcParse(&r);
-
-        struct ipcQueryPointerBufferSizeResponse {
-            u64 magic;
-            u64 result;
-            u32 size;
-        } *raw = (struct ipcQueryPointerBufferSizeResponse*)r.Raw;
-
-        rc = raw->result;
-
-        if (R_SUCCEEDED(rc)) {
-            *size = raw->size & 0xffff;
-        }
-    }
-
-    return rc;
-}
-
-/**
- * @brief Closes the IPC session with proper clean up.
- * @param session IPC session handle.
- * @return Result code.
- */
-static inline Result ipcCloseSession(Handle session) {
-    u32* buf = (u32*)armGetTls();
-    buf[0] = IpcCommandType_Close;
-    buf[1] = 0;
-    return ipcDispatch(session);
-}
-
-/**
- * @brief Clones an IPC session.
- * @param session IPC session handle.
- * @param unk Unknown.
- * @param new_session_out Output cloned IPC session handle.
- * @return Result code.
- */
-static inline Result ipcCloneSession(Handle session, u32 unk, Handle* new_session_out) {
-    u32* buf = (u32*)armGetTls();
-
-    buf[0] = IpcCommandType_Control;
-    buf[1] = 9;
-    buf[2] = 0;
-    buf[3] = 0;
-    buf[4] = SFCI_MAGIC;
-    buf[5] = 0;
-    buf[6] = 4;
-    buf[7] = 0;
-    buf[8] = unk;
-
-    Result rc = ipcDispatch(session);
-
-    if (R_SUCCEEDED(rc)) {
-        IpcParsedCommand r;
-        ipcParse(&r);
-
-        struct ipcCloneSessionResponse {
-            u64 magic;
-            u64 result;
-        } *raw = (struct ipcCloneSessionResponse*)r.Raw;
-
-        rc = raw->result;
-
-        if (R_SUCCEEDED(rc) && new_session_out) {
-            *new_session_out = r.Handles[0];
-        }
-    }
-
-    return rc;
-}
-
-///@}
-
-///@name IPC domain handling
-///@{
-
-/**
- * @brief Converts an IPC session handle into a domain.
- * @param session IPC session handle.
- * @param object_id_out Output variable in which to store the object ID.
- * @return Result code.
- */
-static inline Result ipcConvertSessionToDomain(Handle session, u32* object_id_out) {
-    u32* buf = (u32*)armGetTls();
-
-    buf[0] = IpcCommandType_Control;
-    buf[1] = 8;
-    buf[4] = SFCI_MAGIC;
-    buf[5] = 0;
-    buf[6] = 0;
-    buf[7] = 0;
-
-    Result rc = ipcDispatch(session);
-
-    if (R_SUCCEEDED(rc)) {
-        IpcParsedCommand r;
-        ipcParse(&r);
-
-        struct ipcConvertSessionToDomainResponse {
-            u64 magic;
-            u64 result;
-            u32 object_id;
-        } *raw = (struct ipcConvertSessionToDomainResponse*)r.Raw;
-
-        rc = raw->result;
-
-        if (R_SUCCEEDED(rc)) {
-            *object_id_out = raw->object_id;
-        }
-    }
-
-    return rc;
-}
-
-/**
- * @brief Adds an object ID to be sent through an IPC domain command structure.
- * @param cmd IPC domain command structure.
- * @param object_id Object ID to send.
- */
-static inline void ipcSendObjectId(IpcCommand* cmd, u32 object_id) {
-    cmd->ObjectIds[cmd->NumObjectIds++] = object_id;
-}
-
-/**
- * @brief Prepares the header of an IPC command structure (domain version).
- * @param cmd IPC command structure.
- * @param sizeof_raw Size in bytes of the raw data structure to embed inside the IPC request
- * @oaram object_id Domain object ID.
- * @return Pointer to the raw embedded data structure in the request, ready to be filled out.
- */
-static inline void* ipcPrepareHeaderForDomain(IpcCommand* cmd, size_t sizeof_raw, u32 object_id) {
-    void* raw = ipcPrepareHeader(cmd, sizeof_raw + sizeof(DomainMessageHeader));
-    DomainMessageHeader* hdr = (DomainMessageHeader*) raw;
-    u32 *object_ids = (u32*)(((uintptr_t) raw) + sizeof(DomainMessageHeader) + sizeof_raw);
-
-    hdr->Type = DomainMessageType_SendMessage;
-    hdr->NumObjectIds = (u8)cmd->NumObjectIds;
-    hdr->Length = sizeof_raw;
-    hdr->ThisObjectId = object_id;
-    hdr->Pad[0] = hdr->Pad[1] = 0;
-
-    for(size_t i = 0; i < cmd->NumObjectIds; i++)
-        object_ids[i] = cmd->ObjectIds[i];
-    return (void*)(((uintptr_t) raw) + sizeof(DomainMessageHeader));
-}
-
-/**
- * @brief Parse an IPC command response into an IPC parsed command structure (domain version).
- * @param IPC parsed command structure to fill in.
- * @return Result code.
- */
-static inline Result ipcParseForDomain(IpcParsedCommand* r) {
-    Result rc = ipcParse(r);
-    DomainMessageHeader *hdr;
-    u32 *object_ids;
-    if(R_FAILED(rc))
-        return rc;
-
-    hdr = (DomainMessageHeader*) r->Raw;
-    object_ids = (u32*)(((uintptr_t) hdr) + sizeof(DomainMessageHeader) + hdr->Length);
-    r->Raw = (void*)(((uintptr_t) r->Raw) + sizeof(DomainMessageHeader));
-
-    r->IsDomainMessage = true;
-    r->MessageType = (DomainMessageType)(hdr->Type);
-    switch (r->MessageType) {
-        case DomainMessageType_SendMessage:
-        case DomainMessageType_Close:
-            break;
-        default:
-            return MAKERESULT(Module_Libnx, LibnxError_DomainMessageUnknownType);
-    }
-    r->ThisObjectId = hdr->ThisObjectId;
-    r->NumObjectIds = hdr->NumObjectIds > 8 ? 8 : hdr->NumObjectIds;
-    if ((uintptr_t)object_ids + sizeof(u32) * r->NumObjectIds - (uintptr_t)armGetTls() >= 0x100) {
-        return MAKERESULT(Module_Libnx, LibnxError_DomainMessageTooManyObjectIds);
-    }
-    for(size_t i = 0; i < r->NumObjectIds; i++)
-        r->ObjectIds[i] = object_ids[i];
-
-    return rc;
-}
-
-/**
- * @brief Closes a domain object by ID.
- * @param session IPC session handle.
- * @param object_id ID of the object to close.
- * @return Result code.
- */
-static inline Result ipcCloseObjectById(Handle session, u32 object_id) {
-    IpcCommand c;
-    DomainMessageHeader* hdr;
-
-    ipcInitialize(&c);
-    hdr = (DomainMessageHeader*)ipcPrepareHeader(&c, sizeof(DomainMessageHeader));
-
-    hdr->Type = 2;
-    hdr->NumObjectIds = 0;
-    hdr->Length = 0;
-    hdr->ThisObjectId = object_id;
-    hdr->Pad[0] = hdr->Pad[1] = 0;
-
-    return ipcDispatch(session); // this command has no associated response
-}
-
-///@}

nx/include/switch/kernel/jit.h

@@ -6,11 +6,12 @@
  */
 #pragma once
 #include "../types.h"
+#include "virtmem.h"
 
 /// JIT implementation type.
 typedef enum {
-    JitType_CodeMemory, ///< JIT supported using svcSetProcessMemoryPermission
-    JitType_JitMemory,  ///< JIT supported using 4.0.0+ code-memory syscalls (this isn't usable on 5.0.0+ so JitType_CodeMemory is used instead).
+    JitType_SetProcessMemoryPermission, ///< JIT supported using svcSetProcessMemoryPermission
+    JitType_CodeMemory,                 ///< JIT supported using [4.0.0+] CodeMemory syscalls
 } JitType;
 
 /// JIT buffer object.
@@ -21,7 +22,10 @@ typedef struct {
     void*   rx_addr;
     void*   rw_addr;
     bool    is_executable;
-    Handle  handle;
+    union {
+        Handle              handle;
+        VirtmemReservation* rv;
+    };
 } Jit;
 
 /**
@@ -58,11 +62,15 @@ Result jitClose(Jit* j);
  * @param j JIT buffer.
  * @return Pointer to alias of the JIT buffer that can be written to.
  */
-void* jitGetRwAddr(Jit* j);
+NX_CONSTEXPR void* jitGetRwAddr(Jit* j) {
+    return j->rw_addr;
+}
 
 /**
  * @brief Gets the address of the executable memory alias of a JIT buffer.
  * @param j JIT buffer.
  * @return Pointer to alias of the JIT buffer that can be executed.
  */
-void* jitGetRxAddr(Jit* j);
+NX_CONSTEXPR void* jitGetRxAddr(Jit* j) {
+    return j->rx_addr;
+}

nx/include/switch/kernel/levent.h

@@ -0,0 +1,54 @@
+/**
+ * @file levent.h
+ * @brief Light event synchronization primitive [4.0.0+]
+ * @author fincs
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+#include "../result.h"
+#include "svc.h"
+
+/// User-mode light event structure.
+typedef struct LEvent {
+    u32  counter;
+    bool autoclear;
+} LEvent;
+
+/**
+ * @brief Initializes a user-mode light event.
+ * @param[out] le Pointer to \ref LEvent structure.
+ * @param[in] signaled Whether the event starts off in signaled state.
+ * @param[in] autoclear Autoclear flag.
+ */
+NX_CONSTEXPR void leventInit(LEvent* le, bool signaled, bool autoclear) {
+    le->counter = signaled ? 2 : 0;
+    le->autoclear = autoclear;
+}
+
+/**
+ * @brief Waits on a user-mode light event.
+ * @param[in] le Pointer to \ref LEvent structure.
+ * @param[in] timeout_ns Timeout in nanoseconds (pass UINT64_MAX to wait indefinitely).
+ * @return true if wait succeeded, false if wait timed out.
+ */
+bool leventWait(LEvent* le, u64 timeout_ns);
+
+/**
+ * @brief Polls a user-mode light event.
+ * @param[in] le Pointer to \ref LEvent structure.
+ * @return true if event is signaled, false otherwise.
+ */
+bool leventTryWait(LEvent* le);
+
+/**
+ * @brief Signals a user-mode light event.
+ * @param[in] le Pointer to \ref LEvent structure.
+ */
+void leventSignal(LEvent* le);
+
+/**
+ * @brief Clears a user-mode light event.
+ * @param[in] le Pointer to \ref LEvent structure.
+ */
+void leventClear(LEvent* le);

nx/include/switch/kernel/mutex.h

@@ -20,7 +20,7 @@ typedef _LOCK_RECURSIVE_T RMutex;
  */
 static inline void mutexInit(Mutex* m)
 {
-    *m = 0;
+    *m = INVALID_HANDLE;
 }
 
 /**
@@ -42,6 +42,13 @@ bool mutexTryLock(Mutex* m);
  */
 void mutexUnlock(Mutex* m);
 
+/**
+ * @brief Gets whether the current thread owns the mutex.
+ * @param m Mutex object.
+ * @return 1 if the mutex is locked by the current thread, and 0 otherwise.
+ */
+bool mutexIsLockedByCurrentThread(const Mutex* m);
+
 /**
  * @brief Initializes a recursive mutex.
  * @param m Recursive mutex object.

nx/include/switch/kernel/rwlock.h

@@ -1,17 +1,23 @@
 /**
  * @file rwlock.h
  * @brief Read/write lock synchronization primitive.
- * @author plutoo
+ * @author plutoo, SciresM
  * @copyright libnx Authors
  */
 #pragma once
 #include "../kernel/mutex.h"
+#include "../kernel/condvar.h"
 
 /// Read/write lock structure.
 typedef struct {
-    RMutex r;
-    RMutex g;
-    u64 b;
+    Mutex mutex;
+    CondVar condvar_reader_wait;
+    CondVar condvar_writer_wait;
+    u32 read_lock_count;
+    u32 read_waiter_count;
+    u32 write_lock_count;
+    u32 write_waiter_count;
+    u32 write_owner_tag;
 } RwLock;
 
 /**
@@ -26,6 +32,13 @@ void rwlockInit(RwLock* r);
  */
 void rwlockReadLock(RwLock* r);
 
+/**
+ * @brief Attempts to lock the read/write lock for reading without waiting.
+ * @param r Read/write lock object.
+ * @return 1 if the mutex has been acquired successfully, and 0 on contention.
+ */
+bool rwlockTryReadLock(RwLock* r);
+
 /**
  * @brief Unlocks the read/write lock for reading.
  * @param r Read/write lock object.
@@ -38,8 +51,30 @@ void rwlockReadUnlock(RwLock* r);
  */
 void rwlockWriteLock(RwLock* r);
 
+/**
+ * @brief Attempts to lock the read/write lock for writing without waiting.
+ * @param r Read/write lock object.
+ * @return 1 if the mutex has been acquired successfully, and 0 on contention.
+ */
+bool rwlockTryWriteLock(RwLock* r);
+
 /**
  * @brief Unlocks the read/write lock for writing.
  * @param r Read/write lock object.
  */
 void rwlockWriteUnlock(RwLock* r);
+
+/**
+ * @brief Checks if the write lock is held by the current thread.
+ * @param r Read/write lock object.
+ * @return 1 if the current hold holds the write lock, and 0 if it does not.
+ */
+bool rwlockIsWriteLockHeldByCurrentThread(RwLock* r);
+
+/**
+ * @brief Checks if the read/write lock is owned by the current thread.
+ * @param r Read/write lock object.
+ * @return 1 if the current hold holds the write lock or if it holds read locks acquired
+ *         while it held the write lock, and 0 if it does not.
+ */
+bool rwlockIsOwnedByCurrentThread(RwLock* r);

nx/include/switch/kernel/svc.h

@@ -13,6 +13,9 @@
 /// Pseudo handle for the current thread.
 #define CUR_THREAD_HANDLE 0xFFFF8000
 
+/// Maximum number of objects that can be waited on by \ref svcWaitSynchronization (Horizon kernel limitation).
+#define MAX_WAIT_OBJECTS 0x40
+
 /// Memory type enumeration (lower 8 bits of \ref MemoryState)
 typedef enum {
     MemType_Unmapped=0x00,            ///< Unmapped memory.
@@ -37,6 +40,8 @@ typedef enum {
     MemType_KernelStack=0x13,         ///< Mapped in kernel during \ref svcCreateThread.
     MemType_CodeReadOnly=0x14,        ///< Mapped in kernel during \ref svcControlCodeMemory.
     MemType_CodeWritable=0x15,        ///< Mapped in kernel during \ref svcControlCodeMemory.
+    MemType_Coverage=0x16,            ///< Not available.
+    MemType_Insecure=0x17,            ///< Mapped in kernel during \ref svcMapInsecurePhysicalMemory.
 } MemoryType;
 
 /// Memory state bitmasks.
@@ -64,10 +69,11 @@ typedef enum {
 
 /// Memory attribute bitmasks.
 typedef enum {
-    MemAttr_IsBorrowed=BIT(0),     ///< Is borrowed memory.
-    MemAttr_IsIpcMapped=BIT(1),    ///< Is IPC mapped (when IpcRefCount > 0).
-    MemAttr_IsDeviceMapped=BIT(2), ///< Is device mapped (when DeviceRefCount > 0).
-    MemAttr_IsUncached=BIT(3),     ///< Is uncached.
+    MemAttr_IsBorrowed=BIT(0),         ///< Is borrowed memory.
+    MemAttr_IsIpcMapped=BIT(1),        ///< Is IPC mapped (when IpcRefCount > 0).
+    MemAttr_IsDeviceMapped=BIT(2),     ///< Is device mapped (when DeviceRefCount > 0).
+    MemAttr_IsUncached=BIT(3),         ///< Is uncached.
+    MemAttr_IsPermissionLocked=BIT(4), ///< Is permission locked.
 } MemoryAttribute;
 
 /// Memory permission bitmasks.
@@ -88,15 +94,36 @@ typedef struct {
     u32 type;            ///< Memory type (see lower 8 bits of \ref MemoryState).
     u32 attr;            ///< Memory attributes (see \ref MemoryAttribute).
     u32 perm;            ///< Memory permissions (see \ref Permission).
-    u32 device_refcount; ///< Device reference count.
     u32 ipc_refcount;    ///< IPC reference count.
+    u32 device_refcount; ///< Device reference count.
     u32 padding;         ///< Padding.
 } MemoryInfo;
 
+/// Physical memory information structure.
+typedef struct {
+    u64 physical_address; ///< Physical address.
+    u64 virtual_address;  ///< Virtual address.
+    u64 size;             ///< Size.
+} PhysicalMemoryInfo;
+
 /// Secure monitor arguments.
 typedef struct {
     u64 X[8]; ///< Values of X0 through X7.
-} PACKED SecmonArgs;
+} NX_PACKED SecmonArgs;
+
+/// Break reasons
+typedef enum {
+    BreakReason_Panic         = 0,
+    BreakReason_Assert        = 1,
+    BreakReason_User          = 2,
+    BreakReason_PreLoadDll    = 3,
+    BreakReason_PostLoadDll   = 4,
+    BreakReason_PreUnloadDll  = 5,
+    BreakReason_PostUnloadDll = 6,
+    BreakReason_CppException  = 7,
+
+    BreakReason_NotificationOnlyFlag = 0x80000000,
+} BreakReason;
 
 /// Code memory mapping operations
 typedef enum {
@@ -115,6 +142,12 @@ typedef enum {
     LimitableResource_Sessions=4,         ///<How many sessions can a process own.
 } LimitableResource;
 
+/// Thread Activity.
+typedef enum {
+    ThreadActivity_Runnable = 0, ///< Thread can run.
+    ThreadActivity_Paused   = 1, ///< Thread is paused.
+} ThreadActivity;
+
 /// Process Information.
 typedef enum {
     ProcessInfoType_ProcessState=0,       ///<What state is a process in.
@@ -122,16 +155,22 @@ typedef enum {
 
 /// Process States.
 typedef enum {
-    ProcessState_Created=0,        ///<Newly-created process.
-    ProcessState_DebugAttached=1,  ///<Process attached to debugger.
-    ProcessState_DebugDetached=2,  ///<Process detached from debugger.
-    ProcessState_Crashed=3,        ///<Process that has just creashed.
-    ProcessState_Running=4,        ///<Process executing normally.
-    ProcessState_Exiting=5,        ///<Process has begun exiting.
-    ProcessState_Exited=6,         ///<Process has finished exiting.
-    ProcessState_DebugSuspended=7, ///<Process execution suspended by debugger.
+    ProcessState_Created=0,             ///<Newly-created process, not yet started.
+    ProcessState_CreatedAttached=1,     ///<Newly-created process, not yet started but attached to debugger.
+    ProcessState_Running=2,             ///<Process that is running normally (and detached from any debugger).
+    ProcessState_Crashed=3,             ///<Process that has just crashed.
+    ProcessState_RunningAttached=4,     ///<Process that is running normally, attached to a debugger.
+    ProcessState_Exiting=5,             ///<Process has begun exiting.
+    ProcessState_Exited=6,              ///<Process has finished exiting.
+    ProcessState_DebugSuspended=7,      ///<Process execution suspended by debugger.
 } ProcessState;
 
+/// Process Activity.
+typedef enum {
+    ProcessActivity_Runnable = 0, ///< Process can run.
+    ProcessActivity_Paused   = 1, ///< Process is paused.
+} ProcessActivity;
+
 /// Debug Thread Parameters.
 typedef enum {
     DebugThreadParam_ActualPriority=0,
@@ -141,15 +180,125 @@ typedef enum {
     DebugThreadParam_CoreMask=4,
 } DebugThreadParam;
 
+/// GetInfo IDs.
+typedef enum {
+    InfoType_CoreMask                       = 0,  ///< Bitmask of allowed Core IDs.
+    InfoType_PriorityMask                   = 1,  ///< Bitmask of allowed Thread Priorities.
+    InfoType_AliasRegionAddress             = 2,  ///< Base of the Alias memory region.
+    InfoType_AliasRegionSize                = 3,  ///< Size of the Alias memory region.
+    InfoType_HeapRegionAddress              = 4,  ///< Base of the Heap memory region.
+    InfoType_HeapRegionSize                 = 5,  ///< Size of the Heap memory region.
+    InfoType_TotalMemorySize                = 6,  ///< Total amount of memory available for process.
+    InfoType_UsedMemorySize                 = 7,  ///< Amount of memory currently used by process.
+    InfoType_DebuggerAttached               = 8,  ///< Whether current process is being debugged.
+    InfoType_ResourceLimit                  = 9,  ///< Current process's resource limit handle.
+    InfoType_IdleTickCount                  = 10, ///< Number of idle ticks on CPU.
+    InfoType_RandomEntropy                  = 11, ///< [2.0.0+] Random entropy for current process.
+    InfoType_AslrRegionAddress              = 12, ///< [2.0.0+] Base of the process's address space.
+    InfoType_AslrRegionSize                 = 13, ///< [2.0.0+] Size of the process's address space.
+    InfoType_StackRegionAddress             = 14, ///< [2.0.0+] Base of the Stack memory region.
+    InfoType_StackRegionSize                = 15, ///< [2.0.0+] Size of the Stack memory region.
+    InfoType_SystemResourceSizeTotal        = 16, ///< [3.0.0+] Total memory allocated for process memory management.
+    InfoType_SystemResourceSizeUsed         = 17, ///< [3.0.0+] Amount of memory currently used by process memory management.
+    InfoType_ProgramId                      = 18, ///< [3.0.0+] Program ID for the process.
+    InfoType_InitialProcessIdRange          = 19, ///< [4.0.0-4.1.0] Min/max initial process IDs.
+    InfoType_UserExceptionContextAddress    = 20, ///< [5.0.0+] Address of the process's exception context (for break).
+    InfoType_TotalNonSystemMemorySize       = 21, ///< [6.0.0+] Total amount of memory available for process, excluding that for process memory management.
+    InfoType_UsedNonSystemMemorySize        = 22, ///< [6.0.0+] Amount of memory used by process, excluding that for process memory management.
+    InfoType_IsApplication                  = 23, ///< [9.0.0+] Whether the specified process is an Application.
+    InfoType_FreeThreadCount                = 24, ///< [11.0.0+] The number of free threads available to the process's resource limit.
+    InfoType_ThreadTickCount                = 25, ///< [13.0.0+] Number of ticks spent on thread.
+    InfoType_IsSvcPermitted                 = 26, ///< [14.0.0+] Does process have access to SVC (only usable with \ref svcSynchronizePreemptionState at present).
+    InfoType_IoRegionHint                   = 27, ///< [16.0.0+] Low bits of the physical address for a KIoRegion.
+    InfoType_AliasRegionExtraSize           = 28, ///< [18.0.0+] Extra size added to the reserved region.
+
+    InfoType_TransferMemoryHint             = 34, ///< [19.0.0+] Low bits of the process address for a KTransferMemory.
+
+    InfoType_ThreadTickCountDeprecated      = 0xF0000002, ///< [1.0.0-12.1.0] Number of ticks spent on thread.
+} InfoType;
+
+/// GetSystemInfo IDs.
+typedef enum {
+    SystemInfoType_TotalPhysicalMemorySize  = 0, ///< Total amount of DRAM available to system.
+    SystemInfoType_UsedPhysicalMemorySize   = 1, ///< Current amount of DRAM used by system.
+    SystemInfoType_InitialProcessIdRange    = 2, ///< Min/max initial process IDs.
+} SystemInfoType;
+
+/// GetInfo Idle/Thread Tick Count Sub IDs.
+typedef enum {
+    TickCountInfo_Core0 = 0,       ///< Tick count on core 0.
+    TickCountInfo_Core1 = 1,       ///< Tick count on core 1.
+    TickCountInfo_Core2 = 2,       ///< Tick count on core 2.
+    TickCountInfo_Core3 = 3,       ///< Tick count on core 3.
+
+    TickCountInfo_Total = UINT64_MAX, ///< Tick count on all cores.
+} TickCountInfo;
+
+/// GetInfo InitialProcessIdRange Sub IDs.
+typedef enum {
+    InitialProcessIdRangeInfo_Minimum = 0, ///< Lowest initial process ID.
+    InitialProcessIdRangeInfo_Maximum = 1, ///< Highest initial process ID.
+} InitialProcessIdRangeInfo;
+
+/// GetSystemInfo PhysicalMemory Sub IDs.
+typedef enum {
+    PhysicalMemorySystemInfo_Application  = 0, ///< Memory allocated for application usage.
+    PhysicalMemorySystemInfo_Applet       = 1, ///< Memory allocated for applet usage.
+    PhysicalMemorySystemInfo_System       = 2, ///< Memory allocated for system usage.
+    PhysicalMemorySystemInfo_SystemUnsafe = 3, ///< Memory allocated for unsafe system usage (accessible to devices).
+} PhysicalMemorySystemInfo;
+
+/// SleepThread yield types.
+typedef enum {
+    YieldType_WithoutCoreMigration = 0l,  ///< Yields to another thread on the same core.
+    YieldType_WithCoreMigration    = -1l, ///< Yields to another thread (possibly on a different core).
+    YieldType_ToAnyThread          = -2l, ///< Yields and performs forced load-balancing.
+} YieldType;
+
+/// SignalToAddress behaviors.
+typedef enum {
+    SignalType_Signal                                          = 0, ///< Signals the address.
+    SignalType_SignalAndIncrementIfEqual                       = 1, ///< Signals the address and increments its value if equal to argument.
+    SignalType_SignalAndModifyBasedOnWaitingThreadCountIfEqual = 2, ///< Signals the address and updates its value if equal to argument.
+} SignalType;
+
+/// WaitForAddress behaviors.
+typedef enum {
+    ArbitrationType_WaitIfLessThan             = 0, ///< Wait if the 32-bit value is less than argument.
+    ArbitrationType_DecrementAndWaitIfLessThan = 1, ///< Decrement the 32-bit value and wait if it is less than argument.
+    ArbitrationType_WaitIfEqual                = 2, ///< Wait if the 32-bit value is equal to argument.
+    ArbitrationType_WaitIfEqual64              = 3, ///< [19.0.0+] Wait if the 64-bit value is equal to argument.
+} ArbitrationType;
+
+/// Context of a scheduled thread.
+typedef struct {
+    u64 fp; ///< Frame Pointer for the thread.
+    u64 sp; ///< Stack Pointer for the thread.
+    u64 lr; ///< Link Register for the thread.
+    u64 pc; ///< Program Counter for the thread.
+} LastThreadContext;
+
+/// Memory mapping type.
+typedef enum {
+    MemoryMapping_IoRegister = 0, ///< Mapping IO registers.
+    MemoryMapping_Uncached   = 1, ///< Mapping normal memory without cache.
+    MemoryMapping_Memory     = 2, ///< Mapping normal memory.
+} MemoryMapping;
+
+/// Io Pools.
+typedef enum {
+    IoPoolType_PcieA2 = 0, ///< Physical address range 0x12000000-0x1FFFFFFF
+} IoPoolType;
+
 ///@name Memory management
 ///@{
 
 /**
  * @brief Set the process heap to a given size. It can both extend and shrink the heap.
  * @param[out] out_addr Variable to which write the address of the heap (which is randomized and fixed by the kernel)
- * @param[in] size Size of the heap, must be a multiple of 0x2000000 and [2.0.0+] less than 0x18000000.
+ * @param[in] size Size of the heap, must be a multiple of 0x200000 and [2.0.0+] less than 0x18000000.
  * @return Result code.
- * @note Syscall number 0x00.
+ * @note Syscall number 0x01.
  */
 Result svcSetHeapSize(void** out_addr, u64 size);
 
@@ -161,7 +310,7 @@ Result svcSetHeapSize(void** out_addr, u64 size);
  * @return Result code.
  * @remark Perm_X is not allowed. Setting write-only is not allowed either (Perm_W).
  *         This can be used to move back and forth between Perm_None, Perm_R and Perm_Rw.
- * @note Syscall number 0x01.
+ * @note Syscall number 0x02.
  */
 Result svcSetMemoryPermission(void* addr, u64 size, u32 perm);
 
@@ -172,8 +321,8 @@ Result svcSetMemoryPermission(void* addr, u64 size, u32 perm);
  * @param[in] val0 State0
  * @param[in] val1 State1
  * @return Result code.
- * @remark See <a href="http://switchbrew.org/index.php?title=SVC#svcSetMemoryAttribute">switchbrew.org Wiki</a> for more details.
- * @note Syscall number 0x02.
+ * @remark See <a href="https://switchbrew.org/wiki/SVC#svcSetMemoryAttribute">switchbrew.org Wiki</a> for more details.
+ * @note Syscall number 0x03.
  */
 Result svcSetMemoryAttribute(void* addr, u64 size, u32 val0, u32 val1);
 
@@ -201,7 +350,7 @@ Result svcUnmapMemory(void* dst_addr, void* src_addr, u64 size);
 /**
  * @brief Query information about an address. Will always fetch the lowest page-aligned mapping that contains the provided address.
  * @param[out] meminfo_ptr \ref MemoryInfo structure which will be filled in.
- * @param[out] page_info Page information which will be filled in.
+ * @param[out] pageinfo Page information which will be filled in.
  * @param[in] addr Address to query.
  * @return Result code.
  * @note Syscall number 0x06.
@@ -218,7 +367,7 @@ Result svcQueryMemory(MemoryInfo* meminfo_ptr, u32 *pageinfo, u64 addr);
  * @note Syscall number 0x07.
  */
 
-void NORETURN svcExitProcess(void);
+void NX_NORETURN svcExitProcess(void);
 
 /**
  * @brief Creates a thread.
@@ -238,21 +387,21 @@ Result svcStartThread(Handle handle);
  * @brief Exits the current thread.
  * @note Syscall number 0x0A.
  */
-void NORETURN svcExitThread(void);
+void NX_NORETURN svcExitThread(void);
 
 /**
  * @brief Sleeps the current thread for the specified amount of time.
- * @return Result code.
+ * @param[in] nano Number of nanoseconds to sleep, or \ref YieldType for yield.
  * @note Syscall number 0x0B.
  */
-Result svcSleepThread(u64 nano);
+void svcSleepThread(s64 nano);
 
 /**
  * @brief Gets a thread's priority.
  * @return Result code.
  * @note Syscall number 0x0C.
  */
-Result svcGetThreadPriority(u32* priority, Handle handle);
+Result svcGetThreadPriority(s32* priority, Handle handle);
 
 /**
  * @brief Sets a thread's priority.
@@ -266,7 +415,7 @@ Result svcSetThreadPriority(Handle handle, u32 priority);
  * @return Result code.
  * @note Syscall number 0x0E.
  */
-Result svcGetThreadCoreMask(s32* preferred_core, u32* affinity_mask, Handle handle);
+Result svcGetThreadCoreMask(s32* preferred_core, u64* affinity_mask, Handle handle);
 
 /**
  * @brief Sets a thread's core mask.
@@ -362,6 +511,8 @@ Result svcResetSignal(Handle handle);
  * @brief Waits on one or more synchronization objects, optionally with a timeout.
  * @return Result code.
  * @note Syscall number 0x18.
+ * @note \p handleCount must not be greater than \ref MAX_WAIT_OBJECTS. This is a Horizon kernel limitation.
+ * @note This is the raw syscall, which can be cancelled by \ref svcCancelSynchronization or other means. \ref waitHandles or \ref waitMultiHandle should normally be used instead.
  */
 Result svcWaitSynchronization(s32* index, const Handle* handles, s32 handleCount, u64 timeout);
 
@@ -369,6 +520,7 @@ Result svcWaitSynchronization(s32* index, const Handle* handles, s32 handleCount
  * @brief Waits on a single synchronization object, optionally with a timeout.
  * @return Result code.
  * @note Wrapper for \ref svcWaitSynchronization.
+ * @note This is the raw syscall, which can be cancelled by \ref svcCancelSynchronization or other means. \ref waitSingleHandle should normally be used instead.
  */
 static inline Result svcWaitSynchronizationSingle(Handle handle, u64 timeout) {
     s32 tmp;
@@ -405,10 +557,9 @@ Result svcWaitProcessWideKeyAtomic(u32* key, u32* tag_location, u32 self_tag, u6
 
 /**
  * @brief Performs a condition variable wake-up operation in userspace.
- * @return Result code.
  * @note Syscall number 0x1D.
  */
-Result svcSignalProcessWideKey(u32* key, s32 num);
+void svcSignalProcessWideKey(u32* key, s32 num);
 
 ///@}
 
@@ -434,6 +585,13 @@ u64 svcGetSystemTick(void);
  */
 Result svcConnectToNamedPort(Handle* session, const char* name);
 
+/**
+ * @brief Sends a light IPC synchronization request to a session.
+ * @return Result code.
+ * @note Syscall number 0x20.
+ */
+Result svcSendSyncRequestLight(Handle session);
+
 /**
  * @brief Sends an IPC synchronization request to a session.
  * @return Result code.
@@ -482,14 +640,14 @@ Result svcGetThreadId(u64 *threadID, Handle handle);
 ///@{
 
 /**
- * @brief Breaks execution. Panic.
- * @param[in] breakReason Break reason.
- * @param[in] inval1 First break parameter.
- * @param[in] inval2 Second break parameter.
+ * @brief Breaks execution.
+ * @param[in] breakReason Break reason (see \ref BreakReason).
+ * @param[in] address Address of the buffer to pass to the debugger.
+ * @param[in] size Size of the buffer to pass to the debugger.
  * @return Result code.
  * @note Syscall number 0x26.
  */
-Result svcBreak(u32 breakReason, u64 inval1, u64 inval2);
+Result svcBreak(u32 breakReason, uintptr_t address, uintptr_t size);
 
 ///@}
 
@@ -510,6 +668,13 @@ Result svcOutputDebugString(const char *str, u64 size);
 ///@name Miscellaneous
 ///@{
 
+/**
+ * @brief Returns from an exception.
+ * @param[in] res Result code.
+ * @note Syscall number 0x28.
+ */
+void NX_NORETURN svcReturnFromException(Result res);
+
 /**
  * @brief Retrieves information about the system, or a certain kernel object.
  * @param[out] out Variable to which store the information.
@@ -517,10 +682,32 @@ Result svcOutputDebugString(const char *str, u64 size);
  * @param[in] handle Handle of the object to retrieve information from, or \ref INVALID_HANDLE to retrieve information about the system.
  * @param[in] id1 Second ID of the property to retrieve.
  * @return Result code.
- * @remark The full list of property IDs can be found on the <a href="http://switchbrew.org/index.php?title=SVC#svcGetInfo">switchbrew.org wiki</a>.
+ * @remark The full list of property IDs can be found on the <a href="https://switchbrew.org/wiki/SVC#svcGetInfo">switchbrew.org wiki</a>.
  * @note Syscall number 0x29.
  */
-Result svcGetInfo(u64* out, u64 id0, Handle handle, u64 id1);
+Result svcGetInfo(u64* out, u32 id0, Handle handle, u64 id1);
+
+///@}
+
+///@name Cache Management
+///@{
+
+/**
+ * @brief Flushes the entire data cache (by set/way).
+ * @note Syscall number 0x2A.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ * @warning This syscall is dangerous, and should not be used.
+ */
+void svcFlushEntireDataCache(void);
+
+/**
+ * @brief Flushes data cache for a virtual address range.
+ * @param[in] address Address of region to flush.
+ * @param[in] size Size of region to flush.
+ * @remark armDCacheFlush should be used instead of this syscall whenever possible.
+ * @note Syscall number 0x2B.
+ */
+Result svcFlushDataCache(void *address, size_t size);
 
 ///@}
 
@@ -530,21 +717,46 @@ Result svcGetInfo(u64* out, u64 id0, Handle handle, u64 id1);
 /**
  * @brief Maps new heap memory at the desired address. [3.0.0+]
  * @return Result code.
- * @note Syscall number 0x2A.
- * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ * @note Syscall number 0x2C.
  */
 Result svcMapPhysicalMemory(void *address, u64 size);
 
 /**
  * @brief Undoes the effects of \ref svcMapPhysicalMemory. [3.0.0+]
  * @return Result code.
- * @note Syscall number 0x2B.
- * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ * @note Syscall number 0x2D.
  */
 Result svcUnmapPhysicalMemory(void *address, u64 size);
 
 ///@}
 
+///@name Process and thread management
+///@{
+
+/**
+ * @brief Gets information about a thread that will be scheduled in the future. [5.0.0+]
+ * @param[out] out_context Output \ref LastThreadContext for the thread that will be scheduled.
+ * @param[out] out_thread_id Output thread id for the thread that will be scheduled.
+ * @param[in] debug Debug handle.
+ * @param[in] ns Nanoseconds in the future to get scheduled thread at.
+ * @return Result code.
+ * @note Syscall number 0x2E.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+Result svcGetDebugFutureThreadInfo(LastThreadContext *out_context, u64 *out_thread_id, Handle debug, s64 ns);
+
+/**
+ * @brief Gets information about the previously-scheduled thread.
+ * @param[out] out_context Output \ref LastThreadContext for the previously scheduled thread.
+ * @param[out] out_tls_address Output tls address for the previously scheduled thread.
+ * @param[out] out_flags Output flags for the previously scheduled thread.
+ * @return Result code.
+ * @note Syscall number 0x2F.
+ */
+Result svcGetLastThreadInfo(LastThreadContext *out_context, u64 *out_tls_address, u32 *out_flags);
+
+///@}
+
 ///@name Resource Limit Management
 ///@{
 
@@ -554,7 +766,7 @@ Result svcUnmapPhysicalMemory(void *address, u64 size);
  * @note Syscall number 0x30.
  * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
  */
-Result svcGetResourceLimitLimitValue(u64 *out, Handle reslimit_h, LimitableResource which);
+Result svcGetResourceLimitLimitValue(s64 *out, Handle reslimit_h, LimitableResource which);
 
 /**
  * @brief Gets the maximum value a LimitableResource can have, for a Resource Limit handle.
@@ -562,7 +774,7 @@ Result svcGetResourceLimitLimitValue(u64 *out, Handle reslimit_h, LimitableResou
  * @note Syscall number 0x31.
  * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
  */
-Result svcGetResourceLimitCurrentValue(u64 *out, Handle reslimit_h, LimitableResource which);
+Result svcGetResourceLimitCurrentValue(s64 *out, Handle reslimit_h, LimitableResource which);
 
 ///@}
 
@@ -574,7 +786,7 @@ Result svcGetResourceLimitCurrentValue(u64 *out, Handle reslimit_h, LimitableRes
  * @return Result code.
  * @note Syscall number 0x32.
  */
-Result svcSetThreadActivity(Handle thread, bool paused);
+Result svcSetThreadActivity(Handle thread, ThreadActivity paused);
 
 /**
  * @brief Dumps the registers of a thread paused by @ref svcSetThreadActivity (register groups: all).
@@ -588,6 +800,110 @@ Result svcGetThreadContext3(ThreadContext* ctx, Handle thread);
 
 ///@}
 
+///@name Synchronization
+///@{
+
+/**
+ * @brief Arbitrates an address depending on type and value. [4.0.0+]
+ * @param[in] address Address to arbitrate.
+ * @param[in] arb_type \ref ArbitrationType to use.
+ * @param[in] value Value to arbitrate on.
+ * @param[in] timeout Maximum time in nanoseconds to wait.
+ * @return Result code.
+ * @note Syscall number 0x34.
+ */
+Result svcWaitForAddress(void *address, u32 arb_type, s64 value, s64 timeout);
+
+/**
+ * @brief Signals (and updates) an address depending on type and value. [4.0.0+]
+ * @param[in] address Address to arbitrate.
+ * @param[in] signal_type \ref SignalType to use.
+ * @param[in] value Value to arbitrate on.
+ * @param[in] count Number of waiting threads to signal.
+ * @return Result code.
+ * @note Syscall number 0x35.
+ */
+Result svcSignalToAddress(void *address, u32 signal_type, s32 value, s32 count);
+
+///@}
+
+///@name Miscellaneous
+///@{
+
+/**
+ * @brief Sets thread preemption state (used during abort/panic). [8.0.0+]
+ * @note Syscall number 0x36.
+ */
+void svcSynchronizePreemptionState(void);
+
+///@}
+
+///@name Resource Limit Management
+///@{
+
+/**
+ * @brief Gets the peak value a LimitableResource has had, for a Resource Limit handle. [11.0.0+]
+ * @return Result code.
+ * @note Syscall number 0x37.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+Result svcGetResourceLimitPeakValue(s64 *out, Handle reslimit_h, LimitableResource which);
+
+///@}
+
+///@name Memory Management
+///@{
+
+/**
+ * @brief Creates an IO Pool. [13.0.0+]
+ * @return Result code.
+ * @note Syscall number 0x39.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+Result svcCreateIoPool(Handle *out_handle, u32 pool_type);
+
+/**
+ * @brief Creates an IO Region. [13.0.0+]
+ * @return Result code.
+ * @note Syscall number 0x3A.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+Result svcCreateIoRegion(Handle *out_handle, Handle io_pool_h, u64 physical_address, u64 size, u32 memory_mapping, u32 perm);
+
+///@}
+
+///@name Debugging
+///@{
+/**
+ * @brief Causes the kernel to dump debug information. [1.0.0-3.0.2]
+ * @param[in] dump_info_type Type of information to dump.
+ * @param[in] arg0 Argument to the debugging operation.
+ * @note Syscall number 0x3C.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+void svcDumpInfo(u32 dump_info_type, u64 arg0);
+
+/**
+ * @brief Performs a debugging operation on the kernel. [4.0.0+]
+ * @param[in] kern_debug_type Type of debugging operation to perform.
+ * @param[in] arg0 First argument to the debugging operation.
+ * @param[in] arg1 Second argument to the debugging operation.
+ * @param[in] arg2 Third argument to the debugging operation.
+ * @note Syscall number 0x3C.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+void svcKernelDebug(u32 kern_debug_type, u64 arg0, u64 arg1, u64 arg2);
+
+/**
+ * @brief Performs a debugging operation on the kernel. [4.0.0+]
+ * @param[in] kern_trace_state Type of tracing the kernel should perform.
+ * @note Syscall number 0x3D.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+void svcChangeKernelTraceState(u32 kern_trace_state);
+
+///@}
+                                                                                                                                                                                                                      \
 ///@name Inter-process communication (IPC)
 ///@{
 
@@ -607,6 +923,15 @@ Result svcCreateSession(Handle *server_handle, Handle *client_handle, u32 unk0,
  */
 Result svcAcceptSession(Handle *session_handle, Handle port_handle);
 
+/**
+ * @brief Performs light IPC input/output.
+ * @return Result code.
+ * @param[in] handle Server or port handle to act on.
+ * @note Syscall number 0x42.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+Result svcReplyAndReceiveLight(Handle handle);
+
 /**
  * @brief Performs IPC input/output.
  * @return Result code.
@@ -641,6 +966,22 @@ Result svcCreateEvent(Handle* server_handle, Handle* client_handle);
 ///@name Memory management
 ///@{
 
+/**
+ * @brief Maps an IO Region. [13.0.0+]
+ * @return Result code.
+ * @note Syscall number 0x46.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+Result svcMapIoRegion(Handle io_region_h, void *address, u64 size, u32 perm);
+
+/**
+ * @brief Undoes the effects of \ref svcMapIoRegion. [13.0.0+]
+ * @return Result code.
+ * @note Syscall number 0x47.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+Result svcUnmapIoRegion(Handle io_region_h, void *address, u64 size);
+
 /**
  * @brief Maps unsafe memory (usable for GPU DMA) for a system module at the desired address. [5.0.0+]
  * @return Result code.
@@ -689,6 +1030,18 @@ Result svcControlCodeMemory(Handle code_handle, CodeMapOperation op, void* dst_a
 
 ///@}
 
+///@name Power Management
+///@{
+
+/**
+ * @brief Causes the system to enter deep sleep.
+ * @note Syscall number 0x4D.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+void svcSleepSystem(void);
+
+///@}
+
 ///@name Device memory-mapped I/O (MMIO)
 ///@{
 
@@ -702,6 +1055,19 @@ Result svcReadWriteRegister(u32* outVal, u64 regAddr, u32 rwMask, u32 inVal);
 
 ///@}
 
+///@name Process and thread management
+///@{
+
+/**
+ * @brief Configures the pause/unpause status of a process.
+ * @return Result code.
+ * @note Syscall number 0x4F.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+Result svcSetProcessActivity(Handle process, ProcessActivity paused);
+
+///@}
+
 ///@name Inter-process memory sharing
 ///@{
 
@@ -748,15 +1114,25 @@ Result svcCreateInterruptEvent(Handle* handle, u64 irqNum, u32 flag);
  * @note Syscall number 0x54.
  * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
  */
-Result svcQueryPhysicalAddress(u64 out[3], u64 virtaddr);
+Result svcQueryPhysicalAddress(PhysicalMemoryInfo *out, u64 virtaddr);
 
 /**
  * @brief Returns a virtual address mapped to a given IO range.
  * @return Result code.
  * @note Syscall number 0x55.
  * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ * @warning Only exists on [10.0.0+]. For older versions use \ref svcLegacyQueryIoMapping.
  */
-Result svcQueryIoMapping(u64* virtaddr, u64 physaddr, u64 size);
+Result svcQueryMemoryMapping(u64* virtaddr, u64* out_size, u64 physaddr, u64 size);
+
+/**
+ * @brief Returns a virtual address mapped to a given IO range.
+ * @return Result code.
+ * @note Syscall number 0x55.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ * @warning Only exists on [1.0.0-9.2.0]. For newer versions use \ref svcQueryMemoryMapping.
+ */
+Result svcLegacyQueryIoMapping(u64* virtaddr, u64 physaddr, u64 size);
 
 ///@}
 
@@ -794,7 +1170,7 @@ Result svcDetachDeviceAddressSpace(u64 device, Handle handle);
  * @note Syscall number 0x59.
  * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
  */
-Result svcMapDeviceAddressSpaceByForce(Handle handle, Handle proc_handle, u64 map_addr, u64 dev_size, u64 dev_addr, u32 perm);
+Result svcMapDeviceAddressSpaceByForce(Handle handle, Handle proc_handle, u64 map_addr, u64 dev_size, u64 dev_addr, u32 option);
 
 /**
  * @brief Maps an attached device address space to an userspace address.
@@ -803,7 +1179,16 @@ Result svcMapDeviceAddressSpaceByForce(Handle handle, Handle proc_handle, u64 ma
  * @note Syscall number 0x5A.
  * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
  */
-Result svcMapDeviceAddressSpaceAligned(Handle handle, Handle proc_handle, u64 map_addr, u64 dev_size, u64 dev_addr, u32 perm);
+Result svcMapDeviceAddressSpaceAligned(Handle handle, Handle proc_handle, u64 map_addr, u64 dev_size, u64 dev_addr, u32 option);
+
+/**
+ * @brief Maps an attached device address space to an userspace address. [1.0.0-12.1.0]
+ * @return Result code.
+ * @remark The userspace destination address must have the \ref MemState_MapDeviceAlignedAllowed bit set.
+ * @note Syscall number 0x5B.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+Result svcMapDeviceAddressSpace(u64 *out_mapped_size, Handle handle, Handle proc_handle, u64 map_addr, u64 dev_size, u64 dev_addr, u32 perm);
 
 /**
  * @brief Unmaps an attached device address space from an userspace address.
@@ -815,6 +1200,38 @@ Result svcUnmapDeviceAddressSpace(Handle handle, Handle proc_handle, u64 map_add
 
 ///@}
 
+///@name Cache Management
+///@{
+
+/**
+ * @brief Invalidates data cache for a virtual address range within a process.
+ * @param[in] address Address of region to invalidate.
+ * @param[in] size Size of region to invalidate.
+ * @note Syscall number 0x5D.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+Result svcInvalidateProcessDataCache(Handle process, uintptr_t address, size_t size);
+
+/**
+ * @brief Stores data cache for a virtual address range within a process.
+ * @param[in] address Address of region to store.
+ * @param[in] size Size of region to store.
+ * @note Syscall number 0x5E.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+Result svcStoreProcessDataCache(Handle process, uintptr_t address, size_t size);
+
+/**
+ * @brief Flushes data cache for a virtual address range within a process.
+ * @param[in] address Address of region to flush.
+ * @param[in] size Size of region to flush.
+ * @note Syscall number 0x5F.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+Result svcFlushProcessDataCache(Handle process, uintptr_t address, size_t size);
+
+///@}
+
 ///@name Debugging
 ///@{
 
@@ -834,20 +1251,28 @@ Result svcDebugActiveProcess(Handle* debug, u64 processID);
  */
 Result svcBreakDebugProcess(Handle debug);
 
+/**
+ * @brief Terminates the process of an active debugging session.
+ * @return Result code.
+ * @note Syscall number 0x62.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+Result svcTerminateDebugProcess(Handle debug);
+
 /**
  * @brief Gets an incoming debug event from a debugging session.
  * @return Result code.
  * @note Syscall number 0x63.
  * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
  */
-Result svcGetDebugEvent(u8* event_out, Handle debug);
+Result svcGetDebugEvent(void* event_out, Handle debug);
 
 /**
  * @brief Continues a debugging session.
  * @return Result code.
  * @note Syscall number 0x64.
  * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
- * @warning Only exists on 3.0.0+. For older versions use \ref svcContinueDebugEventPre300.
+ * @warning Only exists on [3.0.0+]. For older versions use \ref svcLegacyContinueDebugEvent.
  */
 Result svcContinueDebugEvent(Handle debug, u32 flags, u64* tid_list, u32 num_tids);
 
@@ -856,7 +1281,7 @@ Result svcContinueDebugEvent(Handle debug, u32 flags, u64* tid_list, u32 num_tid
  * @return Result code.
  * @note Syscall number 0x64.
  * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
- * @warning Only exists on 1.0.0-2.3.0. For newer versions use \ref svcContinueDebugEvent.
+ * @warning Only exists on [1.0.0-2.3.0]. For newer versions use \ref svcContinueDebugEvent.
  */
 Result svcLegacyContinueDebugEvent(Handle debug, u32 flags, u64 threadID);
 
@@ -865,7 +1290,7 @@ Result svcLegacyContinueDebugEvent(Handle debug, u32 flags, u64 threadID);
  * @return Result code.
  * @param[out] ctx Output thread context (register dump).
  * @param[in] debug Debug handle.
- * @param[in] threadId ID of the thread to dump the context of.
+ * @param[in] threadID ID of the thread to dump the context of.
  * @param[in] flags Register groups to select, combination of @ref RegisterGroup flags.
  * @note Syscall number 0x67.
  * @warning Official kernel will not dump any CPU GPR if the thread is currently executing a system call (except @ref svcBreak and @ref svcReturnFromException).
@@ -877,7 +1302,7 @@ Result svcGetDebugThreadContext(ThreadContext* ctx, Handle debug, u64 threadID,
  * @brief Gets the context (dump the registers) of a thread in a debugging session.
  * @return Result code.
  * @param[in] debug Debug handle.
- * @param[in] threadId ID of the thread to set the context of.
+ * @param[in] threadID ID of the thread to set the context of.
  * @param[in] ctx Input thread context (register dump).
  * @param[in] flags Register groups to select, combination of @ref RegisterGroup flags.
  * @note Syscall number 0x68.
@@ -897,7 +1322,7 @@ Result svcSetDebugThreadContext(Handle debug, u64 threadID, const ThreadContext*
  * @note Syscall number 0x65.
  * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
  */
-Result svcGetProcessList(u32 *num_out, u64 *pids_out, u32 max_pids);
+Result svcGetProcessList(s32 *num_out, u64 *pids_out, u32 max_pids);
 
 /**
  * @brief Retrieves a list of all threads for a debug handle (or zero).
@@ -905,7 +1330,7 @@ Result svcGetProcessList(u32 *num_out, u64 *pids_out, u32 max_pids);
  * @note Syscall number 0x66.
  * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
  */
-Result svcGetThreadList(u32 *num_out, u64 *tids_out, u32 max_tids, Handle debug);
+Result svcGetThreadList(s32 *num_out, u64 *tids_out, u32 max_tids, Handle debug);
 
 ///@}
 
@@ -934,7 +1359,15 @@ Result svcReadDebugProcessMemory(void* buffer, Handle debug, u64 addr, u64 size)
  * @note Syscall number 0x6B.
  * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
  */
-Result svcWriteDebugProcessMemory(Handle debug, void* buffer, u64 addr, u64 size);
+Result svcWriteDebugProcessMemory(Handle debug, const void* buffer, u64 addr, u64 size);
+
+/**
+ * @brief Sets one of the hardware breakpoints.
+ * @return Result code.
+ * @note Syscall number 0x6C.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+Result svcSetHardwareBreakPoint(u32 which, u64 flags, u64 value);
 
 /**
  * @brief Gets parameters from a thread in a debugging session.
@@ -956,7 +1389,7 @@ Result svcGetDebugThreadParam(u64* out_64, u32* out_32, Handle debug, u64 thread
  * @param[in] handle Handle of the object to retrieve information from, or \ref INVALID_HANDLE to retrieve information about the system.
  * @param[in] id1 Second ID of the property to retrieve.
  * @return Result code.
- * @remark The full list of property IDs can be found on the <a href="http://switchbrew.org/index.php?title=SVC#svcGetSystemInfo">switchbrew.org wiki</a>.
+ * @remark The full list of property IDs can be found on the <a href="https://switchbrew.org/wiki/SVC#svcGetSystemInfo">switchbrew.org wiki</a>.
  * @note Syscall number 0x6F.
  * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
  */
@@ -1035,6 +1468,18 @@ Result svcMapProcessMemory(void* dst, Handle proc, u64 src, u64 size);
  */
 Result svcUnmapProcessMemory(void* dst, Handle proc, u64 src, u64 size);
 
+/**
+ * @brief Equivalent to \ref svcQueryMemory, for another process.
+ * @param[out] meminfo_ptr \ref MemoryInfo structure which will be filled in.
+ * @param[out] pageinfo Page information which will be filled in.
+ * @param[in] proc Process handle.
+ * @param[in] addr Address to query.
+ * @return Result code.
+ * @note Syscall number 0x76.
+ * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
+ */
+Result svcQueryProcessMemory(MemoryInfo* meminfo_ptr, u32 *pageinfo, Handle proc, u64 addr);
+
 /**
  * @brief Maps normal heap in a certain process as executable code (used when loading NROs).
  * @param[in] proc Process handle (cannot be \ref CUR_PROCESS_HANDLE).
@@ -1070,7 +1515,7 @@ Result svcUnmapProcessCodeMemory(Handle proc, u64 dst, u64 src, u64 size);
  * @note Syscall number 0x79.
  * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
  */
-Result svcCreateProcess(Handle* out, void* proc_info, u32* caps, u64 cap_num);
+Result svcCreateProcess(Handle* out, const void* proc_info, const u32* caps, u64 cap_num);
 
 /**
  * @brief Starts executing a freshly created process.
@@ -1094,7 +1539,7 @@ Result svcTerminateProcess(Handle proc);
  * @note Syscall number 0x7C.
  * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
  */
-Result svcGetProcessInfo(u64 *out, Handle proc, ProcessInfoType which);
+Result svcGetProcessInfo(s64 *out, Handle proc, ProcessInfoType which);
 
 ///@}
 
@@ -1125,10 +1570,28 @@ Result svcSetResourceLimitLimitValue(Handle reslimit, LimitableResource which, u
 /**
  * @brief Calls a secure monitor function (TrustZone, EL3).
  * @param regs Arguments to pass to the secure monitor.
- * @return Return value from the secure monitor.
  * @note Syscall number 0x7F.
  * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
  */
-u64 svcCallSecureMonitor(SecmonArgs* regs);
+void svcCallSecureMonitor(SecmonArgs* regs);
 
 ///@}
+
+///@name Memory management
+///@{
+
+/**
+ * @brief Maps new insecure memory at the desired address. [15.0.0+]
+ * @return Result code.
+ * @note Syscall number 0x90.
+ */
+Result svcMapInsecurePhysicalMemory(void *address, u64 size);
+
+/**
+ * @brief Undoes the effects of \ref svcMapInsecureMemory. [15.0.0+]
+ * @return Result code.
+ * @note Syscall number 0x91.
+ */
+Result svcUnmapInsecurePhysicalMemory(void *address, u64 size);
+
+///@}

nx/include/switch/kernel/thread.h

@@ -7,28 +7,40 @@
 #pragma once
 #include "../types.h"
 #include "../arm/thread_context.h"
+#include "wait.h"
 
 /// Thread information structure.
-typedef struct {
-    Handle handle;       ///< Thread handle.
-    void*  stack_mem;    ///< Pointer to stack memory.
-    void*  stack_mirror; ///< Pointer to stack memory mirror.
-    size_t stack_sz;     ///< Stack size.
+typedef struct Thread {
+    Handle handle;         ///< Thread handle.
+    bool   owns_stack_mem; ///< Whether the stack memory is automatically allocated.
+    void*  stack_mem;      ///< Pointer to stack memory.
+    void*  stack_mirror;   ///< Pointer to stack memory mirror.
+    size_t stack_sz;       ///< Stack size.
+    void** tls_array;
+    struct Thread* next;
+    struct Thread** prev_next;
 } Thread;
 
+/// Creates a \ref Waiter for a \ref Thread.
+static inline Waiter waiterForThread(Thread* t)
+{
+    return waiterForHandle(t->handle);
+}
+
 /**
  * @brief Creates a thread.
  * @param t Thread information structure which will be filled in.
  * @param entry Entrypoint of the thread.
  * @param arg Argument to pass to the entrypoint.
- * @param stack_sz Stack size (rounded up to page alignment).
+ * @param stack_mem Memory to use as backing for stack/tls/reent. Must be page-aligned. NULL argument means to allocate new memory.
+ * @param stack_sz  If stack_mem is NULL, size to use for stack. If stack_mem is non-NULL, size to use for stack + reent + tls (must be page-aligned).
  * @param prio Thread priority (0x00~0x3F); 0x2C is the usual priority of the main thread, 0x3B is a special priority on cores 0..2 that enables preemptive multithreading (0x3F on core 3).
  * @param cpuid ID of the core on which to create the thread (0~3); or -2 to use the default core for the current process.
  * @return Result code.
  */
 Result threadCreate(
-    Thread* t, ThreadFunc entry, void* arg, size_t stack_sz, int prio,
-    int cpuid);
+    Thread* t, ThreadFunc entry, void* arg, void *stack_mem, size_t stack_sz,
+    int prio, int cpuid);
 
 /**
  * @brief Starts the execution of a thread.
@@ -37,6 +49,11 @@ Result threadCreate(
  */
 Result threadStart(Thread* t);
 
+/**
+ * @brief Exits the current thread immediately.
+ */
+void NX_NORETURN threadExit(void);
+
 /**
  * @brief Waits for a thread to finish executing.
  * @param t Thread information structure.
@@ -73,3 +90,42 @@ Result threadResume(Thread* t);
  * @warning Official kernel will not dump x0..x18 if the thread is currently executing a system call, and prior to 6.0.0 doesn't dump TPIDR_EL0.
  */
 Result threadDumpContext(ThreadContext* ctx, Thread* t);
+
+/**
+ * @brief Gets a pointer to the current thread structure.
+ * @return Thread information structure.
+ */
+Thread *threadGetSelf(void);
+
+/**
+ * @brief Gets the raw handle to the current thread.
+ * @return The current thread's handle.
+ */
+Handle threadGetCurHandle(void);
+
+/**
+ * @brief Allocates a TLS slot.
+ * @param destructor Function to run automatically when a thread exits.
+ * @return TLS slot ID on success, or a negative value on failure.
+ */
+s32 threadTlsAlloc(void (* destructor)(void*));
+
+/**
+ * @brief Retrieves the value stored in a TLS slot.
+ * @param slot_id TLS slot ID.
+ * @return Value.
+ */
+void* threadTlsGet(s32 slot_id);
+
+/**
+ * @brief Stores the specified value into a TLS slot.
+ * @param slot_id TLS slot ID.
+ * @param value Value.
+ */
+void threadTlsSet(s32 slot_id, void* value);
+
+/**
+ * @brief Frees a TLS slot.
+ * @param slot_id TLS slot ID.
+ */
+void threadTlsFree(s32 slot_id);

nx/include/switch/kernel/tmem.h

@@ -27,6 +27,16 @@ typedef struct {
  */
 Result tmemCreate(TransferMemory* t, size_t size, Permission perm);
 
+/**
+ * @brief Creates a transfer memory object from existing memory.
+ * @param t Transfer memory information structure that will be filled in.
+ * @param buf Pointer to a page-aligned buffer.
+ * @param size Size of the transfer memory object to create.
+ * @param perm Permissions with which to protect the transfer memory in the local process.
+ * @return Result code.
+ */
+Result tmemCreateFromMemory(TransferMemory* t, void* buf, size_t size, Permission perm);
+
 /**
  * @brief Loads a transfer memory object coming from a remote process.
  * @param t Transfer memory information structure which will be filled in.
@@ -62,6 +72,21 @@ static inline void* tmemGetAddr(TransferMemory* t){
     return t->map_addr;
 }
 
+/**
+ * @brief Closes handle of a transfer memory object.
+ * @param t Transfer memory information structure.
+ * @return Result code.
+ */
+Result tmemCloseHandle(TransferMemory* t);
+
+/**
+ * @brief Waits until source backing memory permissions match perm.
+ * @param t Transfer memory information structure.
+ * @param perm Permissions which the source backing memory is expected to have before return.
+ * @return Result code.
+ */
+Result tmemWaitForPermission(TransferMemory* t, Permission perm);
+
 /**
  * @brief Frees up resources used by a transfer memory object, unmapping and closing handles, etc.
  * @param t Transfer memory information structure.

nx/include/switch/kernel/uevent.h

@@ -0,0 +1,47 @@
+/**
+ * @file uevent.h
+ * @brief User-mode event synchronization primitive.
+ * @author plutoo
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "wait.h"
+
+typedef struct UEvent UEvent;
+
+/// User-mode event object.
+struct UEvent {
+    Waitable waitable;
+    bool signal;
+    bool auto_clear;
+};
+
+/// Creates a waiter for a user-mode event.
+static inline Waiter waiterForUEvent(UEvent* e)
+{
+    Waiter wait_obj;
+    wait_obj.type = WaiterType_Waitable;
+    wait_obj.waitable = &e->waitable;
+    return wait_obj;
+}
+
+/**
+ * @brief Creates a user-mode event.
+ * @param[out] e UEvent object.
+ * @param[in] auto_clear Whether to automatically clear the event.
+ * @note It is safe to wait on this event with several threads simultaneously.
+ * @note If more than one thread is listening on it, at least one thread will get the signal. No other guarantees.
+ */
+void ueventCreate(UEvent* e, bool auto_clear);
+
+/**
+ * @brief Clears the event signal.
+ * @param[in] e UEvent object.
+ */
+void ueventClear(UEvent* e);
+
+/**
+ * @brief Signals the event.
+ * @param[in] e UEvent object.
+ */
+void ueventSignal(UEvent* e);

nx/include/switch/kernel/utimer.h

@@ -0,0 +1,58 @@
+/**
+ * @file utimer.h
+ * @brief User-mode timer synchronization primitive.
+ * @author plutoo
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "wait.h"
+
+typedef struct UTimer UTimer;
+
+/// Valid types for a user-mode timer.
+typedef enum {
+    TimerType_OneShot,   ///< Timers of this kind fire once and then stop automatically.
+    TimerType_Repeating, ///< Timers of this kind fire periodically.
+} TimerType;
+
+/// User-mode timer object.
+struct UTimer {
+    Waitable waitable;
+    TimerType type : 8;
+    bool started : 1;
+    u64 next_tick;
+    u64 interval;
+};
+
+/// Creates a waiter for a user-mode timer.
+static inline Waiter waiterForUTimer(UTimer* t)
+{
+    Waiter wait_obj;
+    wait_obj.type = WaiterType_Waitable;
+    wait_obj.waitable = &t->waitable;
+    return wait_obj;
+}
+
+/**
+ * @brief Creates a user-mode timer.
+ * @param[out] t UTimer object.
+ * @param[in] interval Interval (in nanoseconds).
+ * @param[in] type Type of timer to create (see \ref TimerType).
+ * @note The timer is stopped when it is created. Use \ref utimerStart to start it.
+ * @note It is safe to wait on this timer with several threads simultaneously.
+ * @note If more than one thread is listening on it, at least one thread will get the signal. No other guarantees.
+ * @note For a repeating timer: If the timer triggers twice before you wait on it, you will only get one signal.
+ */
+void utimerCreate(UTimer* t, u64 interval, TimerType type);
+
+/**
+ * @brief Starts the timer.
+ * @param[in] t UTimer object.
+ */
+void utimerStart(UTimer* t);
+
+/**
+ * @brief Stops the timer.
+ * @param[in] t UTimer object.
+ */
+void utimerStop(UTimer* t);

nx/include/switch/kernel/virtmem.h

@@ -7,30 +7,55 @@
 #pragma once
 #include "../types.h"
 
+/// Address space reservation type (see \ref virtmemAddReservation)
+typedef struct VirtmemReservation VirtmemReservation;
+
+/// Locks the virtual memory manager mutex.
+void virtmemLock(void);
+
+/// Unlocks the virtual memory manager mutex.
+void virtmemUnlock(void);
+
 /**
- * @brief Reserves a slice of general purpose address space.
- * @param size The size of the slice of address space that will be reserved (rounded up to page alignment).
+ * @brief Finds a random slice of free general purpose address space.
+ * @param size Desired size of the slice (rounded up to page alignment).
+ * @param guard_size Desired size of the unmapped guard areas surrounding the slice  (rounded up to page alignment).
  * @return Pointer to the slice of address space, or NULL on failure.
+ * @note The virtual memory manager mutex must be held during the find-and-map process (see \ref virtmemLock and \ref virtmemUnlock).
  */
-void* virtmemReserve(size_t size);
+void* virtmemFindAslr(size_t size, size_t guard_size);
 
 /**
- * @brief Relinquishes a slice of address space reserved with virtmemReserve (currently no-op).
- * @param addr Pointer to the slice.
- * @param size Size of the slice.
- */
-void  virtmemFree(void* addr, size_t size);
-
-/**
- * @brief Reserves a slice of address space inside the alias memory mapping region(s) (for use with svcMapMemory).
- * @param size The size of the slice of address space that will be reserved (rounded up to page alignment).
+ * @brief Finds a random slice of free stack address space.
+ * @param size Desired size of the slice (rounded up to page alignment).
+ * @param guard_size Desired size of the unmapped guard areas surrounding the slice  (rounded up to page alignment).
  * @return Pointer to the slice of address space, or NULL on failure.
+ * @note The virtual memory manager mutex must be held during the find-and-map process (see \ref virtmemLock and \ref virtmemUnlock).
  */
-void* virtmemReserveMap(size_t size);
+void* virtmemFindStack(size_t size, size_t guard_size);
 
 /**
- * @brief Relinquishes a slice of address space reserved with virtmemReserveMap (currently no-op).
- * @param addr Pointer to the slice.
- * @param size Size of the slice.
+ * @brief Finds a random slice of free code memory address space.
+ * @param size Desired size of the slice (rounded up to page alignment).
+ * @param guard_size Desired size of the unmapped guard areas surrounding the slice  (rounded up to page alignment).
+ * @return Pointer to the slice of address space, or NULL on failure.
+ * @note The virtual memory manager mutex must be held during the find-and-map process (see \ref virtmemLock and \ref virtmemUnlock).
  */
-void  virtmemFreeMap(void* addr, size_t size);
+void* virtmemFindCodeMemory(size_t size, size_t guard_size);
+
+/**
+ * @brief Reserves a range of memory address space.
+ * @param mem Pointer to the address space slice.
+ * @param size Size of the slice.
+ * @return Pointer to a reservation object, or NULL on failure.
+ * @remark This function is intended to be used in lieu of a memory map operation when the memory won't be mapped straight away.
+ * @note The virtual memory manager mutex must be held during the find-and-reserve process (see \ref virtmemLock and \ref virtmemUnlock).
+ */
+VirtmemReservation* virtmemAddReservation(void* mem, size_t size);
+
+/**
+ * @brief Releases a memory address space reservation.
+ * @param rv Reservation to release.
+ * @note The virtual memory manager mutex must be held before calling this function (see \ref virtmemLock and \ref virtmemUnlock).
+ */
+void virtmemRemoveReservation(VirtmemReservation* rv);

nx/include/switch/kernel/wait.h

@@ -0,0 +1,118 @@
+/**
+ * @file wait.h
+ * @brief User mode synchronization primitive waiting operations.
+ * @author plutoo
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "mutex.h"
+
+// Implementation details.
+
+typedef struct Waitable Waitable;
+typedef struct WaitableMethods WaitableMethods;
+typedef struct WaitableNode WaitableNode;
+
+struct WaitableNode {
+    WaitableNode* prev;
+    WaitableNode* next;
+};
+
+struct Waitable {
+    const WaitableMethods* vt;
+    WaitableNode list;
+    Mutex mutex;
+};
+
+typedef enum {
+    WaiterType_Handle,
+    WaiterType_HandleWithClear,
+    WaiterType_Waitable,
+} WaiterType;
+
+// User-facing API starts here.
+
+/// Waiter structure, representing any generic waitable synchronization object; both kernel-mode and user-mode.
+typedef struct {
+    WaiterType type;
+
+    union {
+        Handle handle;
+        Waitable* waitable;
+    };
+} Waiter;
+
+/// Creates a \ref Waiter for a kernel-mode \ref Handle.
+static inline Waiter waiterForHandle(Handle h)
+{
+    Waiter wait_obj;
+    wait_obj.type = WaiterType_Handle;
+    wait_obj.handle = h;
+    return wait_obj;
+}
+
+/**
+ * @brief Waits for an arbitrary number of generic waitable synchronization objects, optionally with a timeout.
+ * @param[out] idx_out Variable that will received the index of the signalled object.
+ * @param[in] objects Array containing \ref Waiter structures.
+ * @param[in] num_objects Number of objects in the array.
+ * @param[in] timeout Timeout (in nanoseconds).
+ * @return Result code.
+ * @note The number of objects must not be greater than \ref MAX_WAIT_OBJECTS. This is a Horizon kernel limitation.
+ */
+Result waitObjects(s32* idx_out, const Waiter* objects, s32 num_objects, u64 timeout);
+
+/**
+ * @brief Waits for an arbitrary number of kernel synchronization objects, optionally with a timeout. This function replaces \ref svcWaitSynchronization.
+ * @param[out] idx_out Variable that will received the index of the signalled object.
+ * @param[in] handles Array containing handles.
+ * @param[in] num_handles Number of handles in the array.
+ * @param[in] timeout Timeout (in nanoseconds).
+ * @return Result code.
+ * @note The number of objects must not be greater than \ref MAX_WAIT_OBJECTS. This is a Horizon kernel limitation.
+ */
+Result waitHandles(s32* idx_out, const Handle* handles, s32 num_handles, u64 timeout);
+
+/**
+ * @brief Helper macro for \ref waitObjects that accepts \ref Waiter structures as variadic arguments instead of as an array.
+ * @param[out] idx_out The index of the signalled waiter.
+ * @param[in] timeout Timeout (in nanoseconds).
+ * @note The number of objects must not be greater than \ref MAX_WAIT_OBJECTS. This is a Horizon kernel limitation.
+ */
+#define waitMulti(idx_out, timeout, ...) ({ \
+    Waiter __objects[] = { __VA_ARGS__ }; \
+    waitObjects((idx_out), __objects, sizeof(__objects) / sizeof(Waiter), (timeout)); \
+})
+
+/**
+ * @brief Helper macro for \ref waitHandles that accepts handles as variadic arguments instead of as an array.
+ * @param[out] idx_out The index of the signalled handle.
+ * @param[in] timeout Timeout (in nanoseconds).
+ * @note The number of objects must not be greater than \ref MAX_WAIT_OBJECTS. This is a Horizon kernel limitation.
+ */
+#define waitMultiHandle(idx_out, timeout, ...) ({ \
+    Handle __handles[] = { __VA_ARGS__ }; \
+    waitHandles((idx_out), __handles, sizeof(__handles) / sizeof(Handle), (timeout)); \
+})
+
+/**
+ * @brief Waits on a single generic waitable synchronization object, optionally with a timeout.
+ * @param[in] w \ref Waiter structure.
+ * @param[in] timeout Timeout (in nanoseconds).
+ */
+static inline Result waitSingle(Waiter w, u64 timeout)
+{
+    s32 idx;
+    return waitObjects(&idx, &w, 1, timeout);
+}
+
+/**
+ * @brief Waits for a single kernel synchronization object, optionally with a timeout.
+ * @param[in] h \ref Handle of the object.
+ * @param[in] timeout Timeout (in nanoseconds).
+ */
+static inline Result waitSingleHandle(Handle h, u64 timeout)
+{
+    s32 idx;
+    return waitHandles(&idx, &h, 1, timeout);
+}

nx/include/switch/nacp.h

@@ -12,40 +12,83 @@ typedef struct {
     char author[0x100];
 } NacpLanguageEntry;
 
+/// ApplicationNeighborDetectionGroupConfiguration
 typedef struct {
-    NacpLanguageEntry lang[16];
+    u64 group_id;                                                                              ///< GroupId
+    u8 key[0x10];
+} NacpApplicationNeighborDetectionGroupConfiguration;
 
-    u8  x3000_unk[0x24];////Normally all-zero?
-    u32 x3024_unk;
-    u32 x3028_unk;
-    u32 x302C_unk;
-    u32 x3030_unk;
-    u32 x3034_unk;
-    u64 titleID0;
+/// NeighborDetectionClientConfiguration
+typedef struct {
+    NacpApplicationNeighborDetectionGroupConfiguration send_group_configuration;               ///< SendGroupConfiguration
+    NacpApplicationNeighborDetectionGroupConfiguration receivable_group_configurations[0x10];  ///< ReceivableGroupConfigurations
+} NacpNeighborDetectionClientConfiguration;
 
-    u8 x3040_unk[0x20];
-    char version[0x10];
+/// ApplicationJitConfiguration
+typedef struct {
+    u64 flags;                                                                           ///< Flags
+    u64 memory_size;                                                                     ///< MemorySize
+} NacpApplicationJitConfiguration;
 
-    u64 titleID_DlcBase;
-    u64 titleID1;
-
-    u32 x3080_unk;
-    u32 x3084_unk;
-    u32 x3088_unk;
-    u8 x308C_unk[0x24];//zeros?
-
-    u64 titleID2;
-    u64 titleIDs[7];//"Array of application titleIDs, normally the same as the above app-titleIDs. Only set for game-updates?"
-
-    u32 x30F0_unk;
-    u32 x30F4_unk;
-
-    u64 titleID3;//"Application titleID. Only set for game-updates?"
-
-    char bcatPassphrase[0x40];
-    u8 x3140_unk[0xEC0];//Normally all-zero?
+/// ns ApplicationControlProperty
+typedef struct {
+    NacpLanguageEntry lang[16];                                                          ///< \ref NacpLanguageEntry
+    u8 isbn[0x25];                                                                       ///< Isbn
+    u8 startup_user_account;                                                             ///< StartupUserAccount
+    u8 user_account_switch_lock;                                                         ///< UserAccountSwitchLock
+    u8 add_on_content_registration_type;                                                 ///< AddOnContentRegistrationType
+    u32 attribute_flag;                                                                  ///< AttributeFlag
+    u32 supported_language_flag;                                                         ///< SupportedLanguageFlag
+    u32 parental_control_flag;                                                           ///< ParentalControlFlag
+    u8 screenshot;                                                                       ///< Screenshot
+    u8 video_capture;                                                                    ///< VideoCapture
+    u8 data_loss_confirmation;                                                           ///< DataLossConfirmation
+    u8 play_log_policy;                                                                  ///< PlayLogPolicy
+    u64 presence_group_id;                                                               ///< PresenceGroupId
+    s8 rating_age[0x20];                                                                 ///< RatingAge
+    char display_version[0x10];                                                          ///< DisplayVersion
+    u64 add_on_content_base_id;                                                          ///< AddOnContentBaseId
+    u64 save_data_owner_id;                                                              ///< SaveDataOwnerId
+    u64 user_account_save_data_size;                                                     ///< UserAccountSaveDataSize
+    u64 user_account_save_data_journal_size;                                             ///< UserAccountSaveDataJournalSize
+    u64 device_save_data_size;                                                           ///< DeviceSaveDataSize
+    u64 device_save_data_journal_size;                                                   ///< DeviceSaveDataJournalSize
+    u64 bcat_delivery_cache_storage_size;                                                ///< BcatDeliveryCacheStorageSize
+    u64 application_error_code_category;                                                 ///< ApplicationErrorCodeCategory
+    u64 local_communication_id[0x8];                                                     ///< LocalCommunicationId
+    u8 logo_type;                                                                        ///< LogoType
+    u8 logo_handling;                                                                    ///< LogoHandling
+    u8 runtime_add_on_content_install;                                                   ///< RuntimeAddOnContentInstall
+    u8 runtime_parameter_delivery;                                                       ///< RuntimeParameterDelivery
+    u8 reserved_x30f4[0x2];                                                              ///< Reserved
+    u8 crash_report;                                                                     ///< CrashReport
+    u8 hdcp;                                                                             ///< Hdcp
+    u64 pseudo_device_id_seed;                                                           ///< SeedForPseudoDeviceId
+    char bcat_passphrase[0x41];                                                          ///< BcatPassphrase
+    u8 startup_user_account_option;                                                      ///< StartupUserAccountOption
+    u8 reserved_for_user_account_save_data_operation[0x6];                               ///< ReservedForUserAccountSaveDataOperation
+    u64 user_account_save_data_size_max;                                                 ///< UserAccountSaveDataSizeMax
+    u64 user_account_save_data_journal_size_max;                                         ///< UserAccountSaveDataJournalSizeMax
+    u64 device_save_data_size_max;                                                       ///< DeviceSaveDataSizeMax
+    u64 device_save_data_journal_size_max;                                               ///< DeviceSaveDataJournalSizeMax
+    u64 temporary_storage_size;                                                          ///< TemporaryStorageSize
+    u64 cache_storage_size;                                                              ///< CacheStorageSize
+    u64 cache_storage_journal_size;                                                      ///< CacheStorageJournalSize
+    u64 cache_storage_data_and_journal_size_max;                                         ///< CacheStorageDataAndJournalSizeMax
+    u16 cache_storage_index_max;                                                         ///< CacheStorageIndexMax
+    u8 reserved_x318a[0x6];                                                              ///< Reserved
+    u64 play_log_queryable_application_id[0x10];                                         ///< PlayLogQueryableApplicationId
+    u8 play_log_query_capability;                                                        ///< PlayLogQueryCapability
+    u8 repair_flag;                                                                      ///< RepairFlag
+    u8 program_index;                                                                    ///< ProgramIndex
+    u8 required_network_service_license_on_launch;                                       ///< RequiredNetworkServiceLicenseOnLaunchFlag
+    u32 reserved_x3214;                                                                  ///< Reserved
+    NacpNeighborDetectionClientConfiguration neighbor_detection_client_configuration;    ///< NeighborDetectionClientConfiguration
+    NacpApplicationJitConfiguration jit_configuration;                                   ///< JitConfiguration
+    u8 reserved_x33c0[0xc40];                                                            ///< Reserved
 } NacpStruct;
 
 /// Get the NacpLanguageEntry from the input nacp corresponding to the current system language (this may fallback to other languages when needed). Output langentry is NULL if none found / content of entry is empty.
+/// If you're using ns you may want to use \ref nsGetApplicationDesiredLanguage instead.
 Result nacpGetLanguageEntry(NacpStruct* nacp, NacpLanguageEntry** langentry);
 

nx/include/switch/nvidia/address_space.h

@@ -1,25 +1,21 @@
 #pragma once
 #include "types.h"
+#include "ioctl.h"
 
 typedef struct NvAddressSpace {
     u32  fd;
+    u32  page_size;
     bool has_init;
 } NvAddressSpace;
 
-typedef enum {
-    NvPageSize_4K  = 0x1000,
-    NvPageSize_64K = 0x10000
-} NvPageSize;
-
-Result nvAddressSpaceCreate(NvAddressSpace* a);
+Result nvAddressSpaceCreate(NvAddressSpace* a, u32 page_size);
 void   nvAddressSpaceClose(NvAddressSpace* a);
 
-Result nvAddressSpaceReserveAlign(NvAddressSpace* a, NvPageSize align, u32 pages, NvPageSize page_sz, iova_t* iova_out);
-Result nvAddressSpaceReserveAtFixedAddr(NvAddressSpace* a, iova_t addr, u32 pages, NvPageSize page_sz);
-Result nvAddressSpaceReserveFull(NvAddressSpace* a);
+Result nvAddressSpaceAlloc(NvAddressSpace* a, bool sparse, u64 size, iova_t* iova_out);
+Result nvAddressSpaceAllocFixed(NvAddressSpace* a, bool sparse, u64 size, iova_t iova);
+Result nvAddressSpaceFree(NvAddressSpace* a, iova_t iova, u64 size);
 
-Result nvAddressSpaceMapBuffer(NvAddressSpace* a, u32 fd, u32 flags, NvKind kind, iova_t* iova_out);
-Result nvAddressSpaceUnmapBuffer(NvAddressSpace* a, iova_t iova);
-
-struct NvChannel;
-Result nvAddressSpaceBindToChannel(NvAddressSpace* a, struct NvChannel* channel);
+Result nvAddressSpaceMap(NvAddressSpace* a, u32 nvmap_handle, bool is_gpu_cacheable, NvKind kind, iova_t* iova_out);
+Result nvAddressSpaceMapFixed(NvAddressSpace* a, u32 nvmap_handle, bool is_gpu_cacheable, NvKind kind, iova_t iova);
+Result nvAddressSpaceModify(NvAddressSpace* a, iova_t iova, u64 offset, u64 size, NvKind kind);
+Result nvAddressSpaceUnmap(NvAddressSpace* a, iova_t iova);

nx/include/switch/nvidia/buffer.h

@@ -1,30 +0,0 @@
-#pragma once
-#include "types.h"
-#include "address_space.h"
-
-typedef struct NvAddressSpace NvAddressSpace;
-
-typedef struct NvBuffer {
-    u32    fd;
-    u32    size;
-    void*  cpu_addr;
-    iova_t gpu_addr;
-    iova_t gpu_addr_texture;
-    NvAddressSpace* addr_space;
-    NvKind kind;
-    bool   has_init;
-    bool   is_cacheable;
-} NvBuffer;
-
-Result nvBufferInit(void);
-u32    nvBufferGetNvmapFd(void);
-void   nvBufferExit(void);
-
-Result nvBufferCreate(NvBuffer* m, size_t size, u32 align, bool is_cacheable, NvKind kind, NvAddressSpace* as);
-void   nvBufferFree(NvBuffer* m);
-
-void*  nvBufferGetCpuAddr(NvBuffer* m);
-iova_t nvBufferGetGpuAddr(NvBuffer* m);
-
-Result nvBufferMapAsTexture(NvBuffer* m, NvKind kind);
-iova_t nvBufferGetGpuAddrTexture(NvBuffer* m);

nx/include/switch/nvidia/channel.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "types.h"
+#include "ioctl.h"
 
 typedef struct NvChannel {
     u32  fd;
@@ -11,4 +12,3 @@ void   nvChannelClose(NvChannel* c);
 
 Result nvChannelSetPriority(NvChannel* c, NvChannelPriority prio);
 Result nvChannelSetTimeout(NvChannel* c, u32 timeout);
-Result nvChannelSetNvmapFd(NvChannel* c);

nx/include/switch/nvidia/fence.h

@@ -10,6 +10,7 @@ typedef struct {
 
 Result nvFenceInit(void);
 void nvFenceExit(void);
+u32 nvFenceGetFd(void);
 
 Result nvFenceWait(NvFence* f, s32 timeout_us);
 

nx/include/switch/nvidia/gpu.h

@@ -0,0 +1,16 @@
+#pragma once
+#include "types.h"
+#include "ioctl.h"
+
+Result nvGpuInit(void);
+void nvGpuExit(void);
+
+const nvioctl_gpu_characteristics* nvGpuGetCharacteristics(void);
+u32 nvGpuGetZcullCtxSize(void);
+const nvioctl_zcull_info* nvGpuGetZcullInfo(void);
+const u32* nvGpuGetTpcMasks(u32 *num_masks_out);
+
+Result nvGpuZbcGetActiveSlotMask(u32 *out_slot, u32 *out_mask);
+Result nvGpuZbcAddColor(const u32 color_l2[4], const u32 color_ds[4], u32 format);
+Result nvGpuZbcAddDepth(float depth);
+Result nvGpuGetTimestamp(u64 *ts);

nx/include/switch/nvidia/gpu/3d_ctx.h

@@ -1,11 +0,0 @@
-#pragma once
-
-typedef struct NvGpu NvGpu;
-
-typedef struct {
-    NvGpu* parent;
-    u64    obj_id;
-} Nv3DContext;
-
-Result nv3DContextCreate(Nv3DContext* t, NvGpu* parent);
-void   nv3DContextClose(Nv3DContext* t);

nx/include/switch/nvidia/gpu/cmd_list.h

@@ -1,20 +0,0 @@
-#pragma once
-
-typedef struct NvGpu NvGpu;
-
-typedef struct {
-    NvBuffer buffer;
-    size_t   offset;
-    size_t   num_cmds;
-    size_t   max_cmds;
-    NvGpu*   parent;
-} NvCmdList;
-
-Result nvCmdListCreate(NvCmdList* c, NvGpu* parent, size_t max_cmds);
-void   nvCmdListClose(NvCmdList* c);
-
-iova_t nvCmdListGetGpuAddr(NvCmdList* c);
-u64    nvCmdListGetListSize(NvCmdList* c);
-
-void   nvCmdListReset(NvCmdList* c);
-u32*   nvCmdListInsert(NvCmdList* c, size_t num_cmds);

nx/include/switch/nvidia/gpu/error_notifier.h

@@ -1,14 +0,0 @@
-#pragma once
-
-typedef struct NvGpu NvGpu;
-
-typedef struct {
-    NvGpu* parent;
-    Event  event;
-    bool   has_init;
-} NvErrorNotifier;
-
-Result nvErrorNotifierCreate(NvErrorNotifier* t, NvGpu* parent);
-void   nvErrorNotifierClose(NvErrorNotifier* t);
-Result nvErrorNotifierWait(NvErrorNotifier* t, u64 timeout);
-Result nvErrorNotifierGetError(NvErrorNotifier* t, NvError* out);

nx/include/switch/nvidia/gpu/gpfifo.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#define GPFIFO_QUEUE_SIZE        0x800
-#define GPFIFO_ENTRY_NOT_MAIN    BIT(9)
-#define GPFIFO_ENTRY_NO_PREFETCH BIT(31)
-
-typedef struct {
-    NvChannel* parent;
-    u32 syncpt_id;
-    u32 num_entries;
-    nvioctl_gpfifo_entry entries[GPFIFO_QUEUE_SIZE];
-} NvGpfifo;
-
-Result nvGpfifoCreate(NvGpfifo* f, NvChannel* parent);
-void   nvGpfifoClose(NvGpfifo* f);
-
-Result nvGpfifoAppendEntry(NvGpfifo* f, iova_t start, size_t num_cmds, u32 flags);
-Result nvGpfifoAppendCmdList(NvGpfifo* f, NvCmdList* cmd_list, u32 flags);
-Result nvGpfifoFlush(NvGpfifo* f, u32 fence_incr, NvFence* fence_out);

nx/include/switch/nvidia/gpu/gpu.h

@@ -1,13 +0,0 @@
-#pragma once
-
-typedef struct NvGpu {
-    NvAddressSpace addr_space;
-    NvChannel gpu_channel;
-    NvGpfifo gpfifo;
-    NvZcullContext zcull_ctx;
-    Nv3DContext _3d_ctx;
-    NvErrorNotifier error_notifier;
-} NvGpu;
-
-Result nvGpuCreate(NvGpu* g);
-void   nvGpuClose(NvGpu* g);

nx/include/switch/nvidia/gpu/zcull_ctx.h

@@ -1,11 +0,0 @@
-#pragma once
-
-typedef struct NvGpu NvGpu;
-
-typedef struct {
-    NvGpu*   parent;
-    NvBuffer ctx_buf;
-} NvZcullContext;
-
-Result nvZcullContextCreate(NvZcullContext* z, NvGpu* parent);
-void   nvZcullContextClose(NvZcullContext* z);

nx/include/switch/nvidia/gpu_channel.h

@@ -0,0 +1,44 @@
+#pragma once
+#include "../kernel/event.h"
+#include "channel.h"
+#include "fence.h"
+
+#define GPFIFO_QUEUE_SIZE        0x800
+#define GPFIFO_ENTRY_NOT_MAIN    BIT(9)
+#define GPFIFO_ENTRY_NO_PREFETCH BIT(31)
+
+typedef struct NvGpuChannel
+{
+    NvChannel base;
+    Event error_event;
+    u64 object_id;
+    NvFence fence;
+    u32 fence_incr;
+    nvioctl_gpfifo_entry entries[GPFIFO_QUEUE_SIZE];
+    u32 num_entries;
+} NvGpuChannel;
+
+Result nvGpuChannelCreate(NvGpuChannel* c, struct NvAddressSpace* as, NvChannelPriority prio);
+void   nvGpuChannelClose(NvGpuChannel* c);
+
+Result nvGpuChannelZcullBind(NvGpuChannel* c, iova_t iova);
+Result nvGpuChannelAppendEntry(NvGpuChannel* c, iova_t start, size_t num_cmds, u32 flags, u32 flush_threshold);
+Result nvGpuChannelKickoff(NvGpuChannel* c);
+Result nvGpuChannelGetErrorNotification(NvGpuChannel* c, NvNotification* notif);
+Result nvGpuChannelGetErrorInfo(NvGpuChannel* c, NvError* error);
+
+static inline u32 nvGpuChannelGetSyncpointId(NvGpuChannel* c)
+{
+    return c->fence.id;
+}
+
+static inline void nvGpuChannelGetFence(NvGpuChannel* c, NvFence* fence_out)
+{
+    fence_out->id = c->fence.id;
+    fence_out->value = c->fence.value + c->fence_incr;
+}
+
+static inline void nvGpuChannelIncrFence(NvGpuChannel* c)
+{
+    ++c->fence_incr;
+}

nx/include/switch/nvidia/graphic_buffer.h

@@ -0,0 +1,39 @@
+#pragma once
+#include "../display/types.h"
+#include "types.h"
+
+typedef struct {
+    u32 width;
+    u32 height;
+    NvColorFormat color_format;
+    NvLayout layout;
+    u32 pitch;
+    u32 unused; // usually this field contains the nvmap handle, but it's completely unused/overwritten during marshalling
+    u32 offset;
+    NvKind kind;
+    u32 block_height_log2;
+    NvDisplayScanFormat scan;
+    u32 second_field_offset;
+    u64 flags;
+    u64 size;
+    u32 unk[6]; // compression related
+} NvSurface;
+
+typedef struct {
+    NativeHandle header;
+    s32 unk0;       // -1
+    s32 nvmap_id;   // nvmap object id
+    u32 unk2;       // 0
+    u32 magic;      // 0xDAFFCAFF
+    u32 pid;        // 42
+    u32 type;       // ?
+    u32 usage;      // GRALLOC_USAGE_* bitmask
+    u32 format;     // PIXEL_FORMAT_*
+    u32 ext_format; // copy of the above (in most cases)
+    u32 stride;     // in pixels!
+    u32 total_size; // in bytes
+    u32 num_planes; // usually 1
+    u32 unk12;      // 0
+    NvSurface planes[3];
+    u64 unused;     // official sw writes a pointer to bookkeeping data here, but it's otherwise completely unused/overwritten during marshalling
+} NvGraphicBuffer;

nx/include/switch/nvidia/info.h

@@ -1,7 +0,0 @@
-#pragma once
-#include "types.h"
-
-Result nvInfoInit(void);
-void nvInfoExit(void);
-
-u32 nvInfoGetZcullCtxSize(void);

nx/include/switch/nvidia/ioctl.h

@@ -44,6 +44,29 @@
 #define __nv_out
 #define __nv_inout
 
+typedef struct {
+    u32 width_align_pixels;            // 0x20  (32)
+    u32 height_align_pixels;           // 0x20  (32)
+    u32 pixel_squares_by_aliquots;     // 0x400 (1024)
+    u32 aliquot_total;                 // 0x800 (2048)
+    u32 region_byte_multiplier;        // 0x20  (32)
+    u32 region_header_size;            // 0x20  (32)
+    u32 subregion_header_size;         // 0xC0  (192)
+    u32 subregion_width_align_pixels;  // 0x20  (32)
+    u32 subregion_height_align_pixels; // 0x40  (64)
+    u32 subregion_count;               // 0x10  (16)
+} nvioctl_zcull_info;
+
+typedef struct {
+    u32 color_ds[4];
+    u32 color_l2[4];
+    u32 depth;
+    u32 ref_cnt;
+    u32 format;
+    u32 type;
+    u32 size;
+} nvioctl_zbc_entry;
+
 typedef struct {
     u32 arch;                           // 0x120 (NVGPU_GPU_ARCH_GM200)
     u32 impl;                           // 0xB (NVGPU_GPU_IMPL_GM20B)
@@ -90,9 +113,14 @@ typedef struct {
 } nvioctl_va_region;
 
 typedef struct {
-    u32 mask;        // always 0x07
-    u32 flush;       // active flush bit field
-} nvioctl_l2_state;
+    u32 slot;        // always 0x07 (?)
+    u32 mask;
+} nvioctl_zbc_slot_mask;
+
+typedef struct {
+    u64 timestamp;
+    u64 reserved;
+} nvioctl_gpu_time;
 
 typedef struct {
     u32 id;
@@ -106,6 +134,54 @@ typedef struct {
     };
 } nvioctl_gpfifo_entry;
 
+typedef struct {
+    u32 mem;
+    u32 offset;
+    u32 words;
+} nvioctl_cmdbuf;
+
+typedef struct {
+    u32 cmdbuf_mem;
+    u32 cmdbuf_offset;
+    u32 target;
+    u32 target_offset;
+} nvioctl_reloc;
+
+typedef struct {
+    u32 shift;
+} nvioctl_reloc_shift;
+
+typedef struct {
+    u32 syncpt_id;
+    u32 syncpt_incrs;
+    u32 waitbase_id; // Always -1
+    u32 next; //< Next valid incr index, or -1
+    u32 prev; //< Previous valid incr index, or -1
+} nvioctl_syncpt_incr;
+
+typedef struct {
+    u32 handle;
+    u32 iova;
+} nvioctl_command_buffer_map;
+
+typedef struct {
+    u32 rate;
+    u32 moduleid;
+} nvioctl_clk_rate;
+
+#define NVGPU_ZBC_TYPE_INVALID     0
+#define NVGPU_ZBC_TYPE_COLOR       1
+#define NVGPU_ZBC_TYPE_DEPTH       2
+
+// Used with nvioctlNvmap_Param().
+typedef enum nvioctl_map_param {
+    NvMapParam_Size = 1,
+    NvMapParam_Alignment = 2,
+    NvMapParam_Base = 3,
+    NvMapParam_Heap = 4,
+    NvMapParam_Kind = 5
+} NvMapParam;
+
 // Used with nvioctlChannel_AllocObjCtx().
 typedef enum nvioctl_channel_obj_classnum {
     NvClassNumber_2D = 0x902D,
@@ -131,28 +207,40 @@ typedef enum {
     NvZcullConfig_PartOfRegularBuffer = 3
 } NvZcullConfig;
 
+// Used with nvioctlNvhostAsGpu_AllocSpace().
+typedef enum {
+    NvAllocSpaceFlags_FixedOffset = 1,
+    NvAllocSpaceFlags_Sparse = 2,
+} NvAllocSpaceFlags;
+
 // Used with nvioctlNvhostAsGpu_MapBufferEx().
 typedef enum {
     NvMapBufferFlags_FixedOffset = 1,
     NvMapBufferFlags_IsCacheable = 4,
+    NvMapBufferFlags_Modify = 0x100,
 } NvMapBufferFlags;
 
 typedef enum {
-    NvErrorType_FifoErrorIdleTimeout=8,
-    NvErrorType_GrErrorSwNotify=13,
-    NvErrorType_GrSemaphoreTimeout=24,
-    NvErrorType_GrIllegalNotify=25,
-    NvErrorType_FifoErrorMmuErrFlt=31,
-    NvErrorType_PbdmaError=32,
-    NvErrorType_ResetChannelVerifError=43,
-    NvErrorType_PbdmaPushbufferCrcMismatch=80
-} NvErrorType;
+    NvNotificationType_FifoErrorIdleTimeout=8,
+    NvNotificationType_GrErrorSwNotify=13,
+    NvNotificationType_GrSemaphoreTimeout=24,
+    NvNotificationType_GrIllegalNotify=25,
+    NvNotificationType_FifoErrorMmuErrFlt=31,
+    NvNotificationType_PbdmaError=32,
+    NvNotificationType_ResetChannelVerifError=43,
+    NvNotificationType_PbdmaPushbufferCrcMismatch=80
+} NvNotificationType;
 
 typedef struct {
-    u64 tickstamp;
-    u32 error_type;
-    u16 unk16;
+    u64 timestamp;
+    u32 info32; // see NvNotificationType
+    u16 info16;
     u16 status; // always -1
+} NvNotification;
+
+typedef struct {
+    u32 type;
+    u32 info[31];
 } NvError;
 
 Result nvioctlNvhostCtrl_SyncptRead(u32 fd, u32 id, u32* out);
@@ -165,22 +253,27 @@ Result nvioctlNvhostCtrl_EventRegister(u32 fd, u32 event_id);
 Result nvioctlNvhostCtrl_EventUnregister(u32 fd, u32 event_id);
 
 Result nvioctlNvhostCtrlGpu_ZCullGetCtxSize(u32 fd, u32 *out);
-Result nvioctlNvhostCtrlGpu_ZCullGetInfo(u32 fd, u32 out[40>>2]);
+Result nvioctlNvhostCtrlGpu_ZCullGetInfo(u32 fd, nvioctl_zcull_info *out);
+Result nvioctlNvhostCtrlGpu_ZbcSetTable(u32 fd, const u32 color_ds[4], const u32 color_l2[4], u32 depth, u32 format, u32 type);
+Result nvioctlNvhostCtrlGpu_ZbcQueryTable(u32 fd, u32 index, nvioctl_zbc_entry *out);
 Result nvioctlNvhostCtrlGpu_GetCharacteristics(u32 fd, nvioctl_gpu_characteristics *out);
-Result nvioctlNvhostCtrlGpu_GetTpcMasks(u32 fd, u32 inval, u32 out[24>>2]);
-Result nvioctlNvhostCtrlGpu_GetL2State(u32 fd, nvioctl_l2_state *out);
+Result nvioctlNvhostCtrlGpu_GetTpcMasks(u32 fd, void *buffer, size_t size);
+Result nvioctlNvhostCtrlGpu_ZbcGetActiveSlotMask(u32 fd, nvioctl_zbc_slot_mask *out);
+Result nvioctlNvhostCtrlGpu_GetGpuTime(u32 fd, nvioctl_gpu_time *out);
 
 Result nvioctlNvhostAsGpu_BindChannel(u32 fd, u32 channel_fd);
-Result nvioctlNvhostAsGpu_AllocSpace(u32 fd, u32 pages, u32 page_size, u32 flags, u64 align, u64 *offset);
+Result nvioctlNvhostAsGpu_AllocSpace(u32 fd, u32 pages, u32 page_size, u32 flags, u64 align_or_offset, u64 *offset);
+Result nvioctlNvhostAsGpu_FreeSpace(u32 fd, u64 offset, u32 pages, u32 page_size);
 Result nvioctlNvhostAsGpu_MapBufferEx(u32 fd, u32 flags, u32 kind, u32 nvmap_handle, u32 page_size, u64 buffer_offset, u64 mapping_size, u64 input_offset, u64 *offset);
 Result nvioctlNvhostAsGpu_UnmapBuffer(u32 fd, u64 offset);
 Result nvioctlNvhostAsGpu_GetVARegions(u32 fd, nvioctl_va_region regions[2]);
-Result nvioctlNvhostAsGpu_InitializeEx(u32 fd, u32 big_page_size, u32 flags);
+Result nvioctlNvhostAsGpu_InitializeEx(u32 fd, u32 flags, u32 big_page_size);
 
 Result nvioctlNvmap_Create(u32 fd, u32 size, u32 *nvmap_handle);
 Result nvioctlNvmap_FromId(u32 fd, u32 id, u32 *nvmap_handle);
 Result nvioctlNvmap_Alloc(u32 fd, u32 nvmap_handle, u32 heapmask, u32 flags, u32 align, u8 kind, void* addr);
 Result nvioctlNvmap_Free(u32 fd, u32 nvmap_handle);
+Result nvioctlNvmap_Param(u32 fd, u32 nvmap_handle, NvMapParam param, u32 *result);
 Result nvioctlNvmap_GetId(u32 fd, u32 nvmap_handle, u32 *id);
 
 Result nvioctlChannel_SetNvmapFd(u32 fd, u32 nvmap_fd);
@@ -189,8 +282,17 @@ Result nvioctlChannel_KickoffPb(u32 fd, nvioctl_gpfifo_entry *entries, u32 num_e
 Result nvioctlChannel_AllocObjCtx(u32 fd, u32 class_num, u32 flags, u64* id_out);
 Result nvioctlChannel_ZCullBind(u32 fd, u64 gpu_va, u32 mode);
 Result nvioctlChannel_SetErrorNotifier(u32 fd, u32 enable);
-Result nvioctlChannel_GetErrorNotification(u32 fd, NvError* out);
+Result nvioctlChannel_GetErrorInfo(u32 fd, NvError* out);
+Result nvioctlChannel_GetErrorNotification(u32 fd, NvNotification* out);
 Result nvioctlChannel_SetPriority(u32 fd, u32 priority);
 Result nvioctlChannel_SetTimeout(u32 fd, u32 timeout);
 Result nvioctlChannel_AllocGpfifoEx2(u32 fd, u32 num_entries, u32 flags, u32 unk0, u32 unk1, u32 unk2, u32 unk3, nvioctl_fence *fence_out);
 Result nvioctlChannel_SetUserData(u32 fd, void* addr);
+Result nvioctlChannel_Submit(u32 fd, const nvioctl_cmdbuf *cmdbufs, u32 num_cmdbufs, const nvioctl_reloc *relocs, const nvioctl_reloc_shift *reloc_shifts, u32 num_relocs,
+    const nvioctl_syncpt_incr *syncpt_incrs, u32 num_syncpt_incrs, nvioctl_fence *fences, u32 num_fences);
+Result nvioctlChannel_GetSyncpt(u32 fd, u32 module_id, u32 *syncpt);
+Result nvioctlChannel_GetModuleClockRate(u32 fd, u32 module_id, u32 *freq);
+Result nvioctlChannel_SetModuleClockRate(u32 fd, u32 module_id, u32 freq);
+Result nvioctlChannel_MapCommandBuffer(u32 fd, nvioctl_command_buffer_map *maps, u32 num_maps, bool compressed);
+Result nvioctlChannel_UnmapCommandBuffer(u32 fd, const nvioctl_command_buffer_map *maps, u32 num_maps, bool compressed);
+Result nvioctlChannel_SetSubmitTimeout(u32 fd, u32 timeout);

nx/include/switch/nvidia/map.h

@@ -0,0 +1,50 @@
+#pragma once
+#include "types.h"
+
+typedef struct NvMap {
+    u32    handle;
+    u32    id;
+    u32    size;
+    void*  cpu_addr;
+    NvKind kind;
+    bool   has_init;
+    bool   is_cpu_cacheable;
+} NvMap;
+
+Result nvMapInit(void);
+u32    nvMapGetFd(void);
+void   nvMapExit(void);
+
+Result nvMapCreate(NvMap* m, void* cpu_addr, u32 size, u32 align, NvKind kind, bool is_cpu_cacheable);
+Result nvMapLoadRemote(NvMap* m, u32 id);
+void   nvMapClose(NvMap* m);
+
+static inline u32 nvMapGetHandle(NvMap* m)
+{
+    return m->handle;
+}
+
+static inline u32 nvMapGetId(NvMap* m)
+{
+    return m->id;
+}
+
+static inline u32 nvMapGetSize(NvMap* m)
+{
+    return m->size;
+}
+
+static inline void* nvMapGetCpuAddr(NvMap* m)
+{
+    return m->cpu_addr;
+}
+
+static inline bool nvMapIsRemote(NvMap* m)
+{
+    return !m->cpu_addr;
+}
+
+static inline NvKind nvMapGetKind(NvMap* m)
+{
+    return m->kind;
+}

nx/include/switch/nvidia/types.h

@@ -249,3 +249,236 @@ typedef enum {
     NvKind_Generic_16BX2 = 0xfe,
     NvKind_Invalid = 0xff,
 } NvKind;
+
+typedef enum {
+    NvColorFormat_Unspecified = 0x0000000000UL,
+    NvColorFormat_NonColor8 = 0x0009200408UL,
+    NvColorFormat_NonColor16 = 0x0009200A10UL,
+    NvColorFormat_NonColor24 = 0x0009201A18UL,
+    NvColorFormat_NonColor32 = 0x0009201C20UL,
+    NvColorFormat_X4C4 = 0x0009210508UL,
+    NvColorFormat_A4L4 = 0x0100490508UL,
+    NvColorFormat_A8L8 = 0x0100490E10UL,
+    NvColorFormat_Float_A16L16 = 0x0100495D20UL,
+    NvColorFormat_A1B5G5R5 = 0x0100531410UL,
+    NvColorFormat_A4B4G4R4 = 0x0100531510UL,
+    NvColorFormat_A5B5G5R1 = 0x0100531810UL,
+    NvColorFormat_A2B10G10R10 = 0x0100532020UL,
+    NvColorFormat_A8B8G8R8 = 0x0100532120UL,
+    NvColorFormat_A16B16G16R16 = 0x0100532740UL,
+    NvColorFormat_Float_A16B16G16R16 = 0x0100536740UL,
+    NvColorFormat_A1R5G5B5 = 0x0100D11410UL,
+    NvColorFormat_A4R4G4B4 = 0x0100D11510UL,
+    NvColorFormat_A5R1G5B5 = 0x0100D11610UL,
+    NvColorFormat_A2R10G10B10 = 0x0100D12020UL,
+    NvColorFormat_A8R8G8B8 = 0x0100D12120UL,
+    NvColorFormat_A1 = 0x0101240101UL,
+    NvColorFormat_A2 = 0x0101240202UL,
+    NvColorFormat_A4 = 0x0101240304UL,
+    NvColorFormat_A8 = 0x0101240408UL,
+    NvColorFormat_A16 = 0x0101240A10UL,
+    NvColorFormat_A32 = 0x0101241C20UL,
+    NvColorFormat_Float_A16 = 0x0101244A10UL,
+    NvColorFormat_L4A4 = 0x0102000508UL,
+    NvColorFormat_L8A8 = 0x0102000E10UL,
+    NvColorFormat_B4G4R4A4 = 0x01060A1510UL,
+    NvColorFormat_B5G5R1A5 = 0x01060A1710UL,
+    NvColorFormat_B5G5R5A1 = 0x01060A1810UL,
+    NvColorFormat_B8G8R8A8 = 0x01060A2120UL,
+    NvColorFormat_B10G10R10A2 = 0x01060A2320UL,
+    NvColorFormat_R1G5B5A5 = 0x0106881410UL,
+    NvColorFormat_R4G4B4A4 = 0x0106881510UL,
+    NvColorFormat_R5G5B5A1 = 0x0106881810UL,
+    NvColorFormat_R8G8B8A8 = 0x0106882120UL,
+    NvColorFormat_R10G10B10A2 = 0x0106882320UL,
+    NvColorFormat_L1 = 0x010A000101UL,
+    NvColorFormat_L2 = 0x010A000202UL,
+    NvColorFormat_L4 = 0x010A000304UL,
+    NvColorFormat_L8 = 0x010A000408UL,
+    NvColorFormat_L16 = 0x010A000A10UL,
+    NvColorFormat_L32 = 0x010A001C20UL,
+    NvColorFormat_Float_L16 = 0x010A004A10UL,
+    NvColorFormat_B5G6R5 = 0x010A0A1210UL,
+    NvColorFormat_B6G5R5 = 0x010A0A1310UL,
+    NvColorFormat_B5G5R5X1 = 0x010A0A1810UL,
+    NvColorFormat_B8_G8_R8 = 0x010A0A1918UL,
+    NvColorFormat_B8G8R8X8 = 0x010A0A2120UL,
+    NvColorFormat_Float_B10G11R11 = 0x010A0A5E20UL,
+    NvColorFormat_X1B5G5R5 = 0x010A531410UL,
+    NvColorFormat_X8B8G8R8 = 0x010A532120UL,
+    NvColorFormat_X16B16G16R16 = 0x010A532740UL,
+    NvColorFormat_Float_X16B16G16R16 = 0x010A536740UL,
+    NvColorFormat_R3G3B2 = 0x010A880608UL,
+    NvColorFormat_R5G5B6 = 0x010A881110UL,
+    NvColorFormat_R5G6B5 = 0x010A881210UL,
+    NvColorFormat_R5G5B5X1 = 0x010A881810UL,
+    NvColorFormat_R8_G8_B8 = 0x010A881918UL,
+    NvColorFormat_R8G8B8X8 = 0x010A882120UL,
+    NvColorFormat_X1R5G5B5 = 0x010AD11410UL,
+    NvColorFormat_X8R8G8B8 = 0x010AD12120UL,
+    NvColorFormat_RG8 = 0x010B080E10UL,
+    NvColorFormat_R16G16 = 0x010B081D20UL,
+    NvColorFormat_Float_R16G16 = 0x010B085D20UL,
+    NvColorFormat_R8 = 0x010B200408UL,
+    NvColorFormat_R16 = 0x010B200A10UL,
+    NvColorFormat_Float_R16 = 0x010B204A10UL,
+    NvColorFormat_A2B10G10R10_sRGB = 0x0200532020UL,
+    NvColorFormat_A8B8G8R8_sRGB = 0x0200532120UL,
+    NvColorFormat_A16B16G16R16_sRGB = 0x0200532740UL,
+    NvColorFormat_A2R10G10B10_sRGB = 0x0200D12020UL,
+    NvColorFormat_B10G10R10A2_sRGB = 0x02060A2320UL,
+    NvColorFormat_R10G10B10A2_sRGB = 0x0206882320UL,
+    NvColorFormat_X8B8G8R8_sRGB = 0x020A532120UL,
+    NvColorFormat_X16B16G16R16_sRGB = 0x020A532740UL,
+    NvColorFormat_A2B10G10R10_709 = 0x0300532020UL,
+    NvColorFormat_A8B8G8R8_709 = 0x0300532120UL,
+    NvColorFormat_A16B16G16R16_709 = 0x0300532740UL,
+    NvColorFormat_A2R10G10B10_709 = 0x0300D12020UL,
+    NvColorFormat_B10G10R10A2_709 = 0x03060A2320UL,
+    NvColorFormat_R10G10B10A2_709 = 0x0306882320UL,
+    NvColorFormat_X8B8G8R8_709 = 0x030A532120UL,
+    NvColorFormat_X16B16G16R16_709 = 0x030A532740UL,
+    NvColorFormat_A2B10G10R10_709_Linear = 0x0400532020UL,
+    NvColorFormat_A8B8G8R8_709_Linear = 0x0400532120UL,
+    NvColorFormat_A16B16G16R16_709_Linear = 0x0400532740UL,
+    NvColorFormat_A2R10G10B10_709_Linear = 0x0400D12020UL,
+    NvColorFormat_B10G10R10A2_709_Linear = 0x04060A2320UL,
+    NvColorFormat_R10G10B10A2_709_Linear = 0x0406882320UL,
+    NvColorFormat_X8B8G8R8_709_Linear = 0x040A532120UL,
+    NvColorFormat_X16B16G16R16_709_Linear = 0x040A532740UL,
+    NvColorFormat_Float_A16B16G16R16_scRGB_Linear = 0x0500536740UL,
+    NvColorFormat_A2B10G10R10_2020 = 0x0600532020UL,
+    NvColorFormat_A8B8G8R8_2020 = 0x0600532120UL,
+    NvColorFormat_A16B16G16R16_2020 = 0x0600532740UL,
+    NvColorFormat_A2R10G10B10_2020 = 0x0600D12020UL,
+    NvColorFormat_B10G10R10A2_2020 = 0x06060A2320UL,
+    NvColorFormat_R10G10B10A2_2020 = 0x0606882320UL,
+    NvColorFormat_X8B8G8R8_2020 = 0x060A532120UL,
+    NvColorFormat_X16B16G16R16_2020 = 0x060A532740UL,
+    NvColorFormat_A2B10G10R10_2020_Linear = 0x0700532020UL,
+    NvColorFormat_A8B8G8R8_2020_Linear = 0x0700532120UL,
+    NvColorFormat_A16B16G16R16_2020_Linear = 0x0700532740UL,
+    NvColorFormat_Float_A16B16G16R16_2020_Linear = 0x0700536740UL,
+    NvColorFormat_A2R10G10B10_2020_Linear = 0x0700D12020UL,
+    NvColorFormat_B10G10R10A2_2020_Linear = 0x07060A2320UL,
+    NvColorFormat_R10G10B10A2_2020_Linear = 0x0706882320UL,
+    NvColorFormat_X8B8G8R8_2020_Linear = 0x070A532120UL,
+    NvColorFormat_X16B16G16R16_2020_Linear = 0x070A532740UL,
+    NvColorFormat_Float_A16B16G16R16_2020_PQ = 0x0800536740UL,
+    NvColorFormat_A4I4 = 0x0901210508UL,
+    NvColorFormat_A8I8 = 0x0901210E10UL,
+    NvColorFormat_I4A4 = 0x0903200508UL,
+    NvColorFormat_I8A8 = 0x0903200E10UL,
+    NvColorFormat_I1 = 0x0909200101UL,
+    NvColorFormat_I2 = 0x0909200202UL,
+    NvColorFormat_I4 = 0x0909200304UL,
+    NvColorFormat_I8 = 0x0909200408UL,
+    NvColorFormat_A8Y8U8V8 = 0x0A00D12120UL,
+    NvColorFormat_A16Y16U16V16 = 0x0A00D12740UL,
+    NvColorFormat_Y8U8V8A8 = 0x0A06882120UL,
+    NvColorFormat_V8_U8 = 0x0A080C0710UL,
+    NvColorFormat_V8U8 = 0x0A080C0E10UL,
+    NvColorFormat_V10U10 = 0x0A08142220UL,
+    NvColorFormat_V12U12 = 0x0A08142420UL,
+    NvColorFormat_V8 = 0x0A08240408UL,
+    NvColorFormat_V10 = 0x0A08240F10UL,
+    NvColorFormat_V12 = 0x0A08241010UL,
+    NvColorFormat_U8_V8 = 0x0A08440710UL,
+    NvColorFormat_U8V8 = 0x0A08440E10UL,
+    NvColorFormat_U10V10 = 0x0A08842220UL,
+    NvColorFormat_U12V12 = 0x0A08842420UL,
+    NvColorFormat_U8 = 0x0A09040408UL,
+    NvColorFormat_U10 = 0x0A09040F10UL,
+    NvColorFormat_U12 = 0x0A09041010UL,
+    NvColorFormat_Y8 = 0x0A09200408UL,
+    NvColorFormat_Y10 = 0x0A09200F10UL,
+    NvColorFormat_Y12 = 0x0A09201010UL,
+    NvColorFormat_YVYU = 0x0A0A500810UL,
+    NvColorFormat_VYUY = 0x0A0A500910UL,
+    NvColorFormat_YUYV = 0x0A0A880810UL,
+    NvColorFormat_UYVY = 0x0A0A880910UL,
+    NvColorFormat_Y8_U8_V8 = 0x0A0A881918UL,
+    NvColorFormat_V8_U8_RR = 0x0B080C0710UL,
+    NvColorFormat_V8U8_RR = 0x0B080C0E10UL,
+    NvColorFormat_V8_RR = 0x0B08240408UL,
+    NvColorFormat_U8_V8_RR = 0x0B08440710UL,
+    NvColorFormat_U8V8_RR = 0x0B08440E10UL,
+    NvColorFormat_U8_RR = 0x0B09040408UL,
+    NvColorFormat_Y8_RR = 0x0B09200408UL,
+    NvColorFormat_V8_U8_ER = 0x0C080C0710UL,
+    NvColorFormat_V8U8_ER = 0x0C080C0E10UL,
+    NvColorFormat_V8_ER = 0x0C08240408UL,
+    NvColorFormat_U8_V8_ER = 0x0C08440710UL,
+    NvColorFormat_U8V8_ER = 0x0C08440E10UL,
+    NvColorFormat_U8_ER = 0x0C09040408UL,
+    NvColorFormat_Y8_ER = 0x0C09200408UL,
+    NvColorFormat_V8_U8_709 = 0x0D080C0710UL,
+    NvColorFormat_V8U8_709 = 0x0D080C0E10UL,
+    NvColorFormat_V10U10_709 = 0x0D08142220UL,
+    NvColorFormat_V12U12_709 = 0x0D08142420UL,
+    NvColorFormat_V8_709 = 0x0D08240408UL,
+    NvColorFormat_V10_709 = 0x0D08240F10UL,
+    NvColorFormat_V12_709 = 0x0D08241010UL,
+    NvColorFormat_U8_V8_709 = 0x0D08440710UL,
+    NvColorFormat_U8V8_709 = 0x0D08440E10UL,
+    NvColorFormat_U10V10_709 = 0x0D08842220UL,
+    NvColorFormat_U12V12_709 = 0x0D08842420UL,
+    NvColorFormat_U8_709 = 0x0D09040408UL,
+    NvColorFormat_U10_709 = 0x0D09040F10UL,
+    NvColorFormat_U12_709 = 0x0D09041010UL,
+    NvColorFormat_Y8_709 = 0x0D09200408UL,
+    NvColorFormat_Y10_709 = 0x0D09200F10UL,
+    NvColorFormat_Y12_709 = 0x0D09201010UL,
+    NvColorFormat_V8_U8_709_ER = 0x0E080C0710UL,
+    NvColorFormat_V8U8_709_ER = 0x0E080C0E10UL,
+    NvColorFormat_V10U10_709_ER = 0x0E08142220UL,
+    NvColorFormat_V12U12_709_ER = 0x0E08142420UL,
+    NvColorFormat_V8_709_ER = 0x0E08240408UL,
+    NvColorFormat_V10_709_ER = 0x0E08240F10UL,
+    NvColorFormat_V12_709_ER = 0x0E08241010UL,
+    NvColorFormat_U8_V8_709_ER = 0x0E08440710UL,
+    NvColorFormat_U8V8_709_ER = 0x0E08440E10UL,
+    NvColorFormat_U10V10_709_ER = 0x0E08842220UL,
+    NvColorFormat_U12V12_709_ER = 0x0E08842420UL,
+    NvColorFormat_U8_709_ER = 0x0E09040408UL,
+    NvColorFormat_U10_709_ER = 0x0E09040F10UL,
+    NvColorFormat_U12_709_ER = 0x0E09041010UL,
+    NvColorFormat_Y8_709_ER = 0x0E09200408UL,
+    NvColorFormat_Y10_709_ER = 0x0E09200F10UL,
+    NvColorFormat_Y12_709_ER = 0x0E09201010UL,
+    NvColorFormat_V10U10_2020 = 0x0F08142220UL,
+    NvColorFormat_V12U12_2020 = 0x0F08142420UL,
+    NvColorFormat_V10_2020 = 0x0F08240F10UL,
+    NvColorFormat_V12_2020 = 0x0F08241010UL,
+    NvColorFormat_U10V10_2020 = 0x0F08842220UL,
+    NvColorFormat_U12V12_2020 = 0x0F08842420UL,
+    NvColorFormat_U10_2020 = 0x0F09040F10UL,
+    NvColorFormat_U12_2020 = 0x0F09041010UL,
+    NvColorFormat_Y10_2020 = 0x0F09200F10UL,
+    NvColorFormat_Y12_2020 = 0x0F09201010UL,
+    NvColorFormat_Bayer8RGGB = 0x1009200408UL,
+    NvColorFormat_Bayer16RGGB = 0x1009200A10UL,
+    NvColorFormat_BayerS16RGGB = 0x1009208A10UL,
+    NvColorFormat_X2Bayer14RGGB = 0x1009210B10UL,
+    NvColorFormat_X4Bayer12RGGB = 0x1009210C10UL,
+    NvColorFormat_X6Bayer10RGGB = 0x1009210D10UL,
+    NvColorFormat_Bayer8BGGR = 0x1109200408UL,
+    NvColorFormat_Bayer16BGGR = 0x1109200A10UL,
+    NvColorFormat_BayerS16BGGR = 0x1109208A10UL,
+    NvColorFormat_X2Bayer14BGGR = 0x1109210B10UL,
+    NvColorFormat_X4Bayer12BGGR = 0x1109210C10UL,
+    NvColorFormat_X6Bayer10BGGR = 0x1109210D10UL,
+    NvColorFormat_Bayer8GRBG = 0x1209200408UL,
+    NvColorFormat_Bayer16GRBG = 0x1209200A10UL,
+    NvColorFormat_BayerS16GRBG = 0x1209208A10UL,
+    NvColorFormat_X2Bayer14GRBG = 0x1209210B10UL,
+    NvColorFormat_X4Bayer12GRBG = 0x1209210C10UL,
+    NvColorFormat_X6Bayer10GRBG = 0x1209210D10UL,
+    NvColorFormat_Bayer8GBRG = 0x1309200408UL,
+    NvColorFormat_Bayer16GBRG = 0x1309200A10UL,
+    NvColorFormat_BayerS16GBRG = 0x1309208A10UL,
+    NvColorFormat_X2Bayer14GBRG = 0x1309210B10UL,
+    NvColorFormat_X4Bayer12GBRG = 0x1309210C10UL,
+    NvColorFormat_X6Bayer10GBRG = 0x1309210D10UL,
+    NvColorFormat_XYZ = 0x140A886640UL,
+} NvColorFormat;

nx/include/switch/result.h

@@ -14,22 +14,65 @@
 #define R_MODULE(res)      ((res)&0x1FF)
 /// Returns the description of a result code.
 #define R_DESCRIPTION(res) (((res)>>9)&0x1FFF)
+/// Masks out unused bits in a result code, retrieving the actual value for use in comparisons.
+#define R_VALUE(res)       ((res)&0x3FFFFF)
 
 /// Builds a result code from its constituent components.
 #define MAKERESULT(module,description) \
     ((((module)&0x1FF)) | ((description)&0x1FFF)<<9)
 
+/// Builds a kernel error result code.
+#define KERNELRESULT(description) \
+    MAKERESULT(Module_Kernel, KernelError_##description)
+
 /// Module values
 enum {
     Module_Kernel=1,
     Module_Libnx=345,
-    Module_LibnxBinder=347,
+    Module_HomebrewAbi=346,
+    Module_HomebrewLoader=347,
     Module_LibnxNvidia=348,
+    Module_LibnxBinder=349,
 };
 
 /// Kernel error codes
 enum {
-    KernelError_Timeout=117,
+    KernelError_OutOfSessions=7,
+    KernelError_InvalidCapabilityDescriptor=14,
+    KernelError_NotImplemented=33,
+    KernelError_ThreadTerminating=59,
+    KernelError_OutOfDebugEvents=70,
+    KernelError_InvalidSize=101,
+    KernelError_InvalidAddress=102,
+    KernelError_ResourceExhausted=103,
+    KernelError_OutOfMemory=104,
+    KernelError_OutOfHandles=105,
+    KernelError_InvalidMemoryState=106,
+    KernelError_InvalidMemoryPermissions=108,
+    KernelError_InvalidMemoryRange=110,
+    KernelError_InvalidPriority=112,
+    KernelError_InvalidCoreId=113,
+    KernelError_InvalidHandle=114,
+    KernelError_InvalidUserBuffer=115,
+    KernelError_InvalidCombination=116,
+    KernelError_TimedOut=117,
+    KernelError_Cancelled=118,
+    KernelError_OutOfRange=119,
+    KernelError_InvalidEnumValue=120,
+    KernelError_NotFound=121,
+    KernelError_AlreadyExists=122,
+    KernelError_ConnectionClosed=123,
+    KernelError_UnhandledUserInterrupt=124,
+    KernelError_InvalidState=125,
+    KernelError_ReservedValue=126,
+    KernelError_InvalidHwBreakpoint=127,
+    KernelError_FatalUserException=128,
+    KernelError_OwnedByAnotherProcess=129,
+    KernelError_ConnectionRefused=131,
+    KernelError_OutOfResource=132,
+    KernelError_IpcMapFailed=259,
+    KernelError_IpcCmdbufTooSmall=260,
+    KernelError_NotDebugged=520,
 };
 
 /// libnx error codes
@@ -79,6 +122,10 @@ enum {
     LibnxError_ApmFailedToInitialize,
     LibnxError_NvinfoFailedToInitialize,
     LibnxError_NvbufFailedToInitialize,
+    LibnxError_LibAppletBadExit,
+    LibnxError_InvalidCmifOutHeader,
+    LibnxError_ShouldNotHappen,
+    LibnxError_Timeout,
 };
 
 /// libnx binder error codes

nx/include/switch/runtime/btdev.h

@@ -0,0 +1,445 @@
+/**
+ * @file btdev.h
+ * @brief Wrapper around the bt/btmu services for using bluetooth BLE.
+ * @note Only available on [5.0.0+].
+ * @note See also: https://switchbrew.org/wiki/BTM_services
+ * @author yellows8
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+#include "../kernel/event.h"
+#include "../services/btdrv_types.h"
+
+/// GattAttribute
+typedef struct {
+    u8 type;                                        ///< Type
+    BtdrvGattAttributeUuid uuid;                    ///< \ref BtdrvGattAttributeUuid
+    u16 handle;                                     ///< Handle
+    u32 connection_handle;                          ///< ConnectionHandle
+} BtdevGattAttribute;
+
+/// GattService
+typedef struct {
+    BtdevGattAttribute attr;                        ///< \ref BtdevGattAttribute
+    u16 instance_id;                                ///< InstanceId
+    u16 end_group_handle;                           ///< EndGroupHandle
+    bool primary_service;                           ///< PrimaryService
+} BtdevGattService;
+
+/// GattCharacteristic
+typedef struct {
+    BtdevGattAttribute attr;                        ///< \ref BtdevGattAttribute
+    u16 instance_id;                                ///< InstanceId
+    u8 properties;                                  ///< Properties
+    u64 value_size;                                 ///< Size of value.
+    u8 value[0x200];                                ///< Value
+} BtdevGattCharacteristic;
+
+/// GattDescriptor
+typedef struct {
+    BtdevGattAttribute attr;                        ///< \ref BtdevGattAttribute
+    u64 value_size;                                 ///< Size of value.
+    u8 value[0x200];                                ///< Value
+} BtdevGattDescriptor;
+
+/// Initialize bt/btmu.
+Result btdevInitialize(void);
+
+/// Exit bt/btmu.
+void btdevExit(void);
+
+/// Compares two \ref BtdrvGattAttributeUuid, returning whether these match.
+bool btdevGattAttributeUuidIsSame(const BtdrvGattAttributeUuid *a, const BtdrvGattAttributeUuid *b);
+
+/// Wrapper for \ref btmuAcquireBleScanEvent.
+Result btdevAcquireBleScanEvent(Event* out_event);
+
+/// Wrapper for \ref btmuGetBleScanFilterParameter.
+Result btdevGetBleScanParameter(u16 parameter_id, BtdrvBleAdvertisePacketParameter *out);
+
+/// Wrapper for \ref btmuGetBleScanFilterParameter2.
+Result btdevGetBleScanParameter2(u16 parameter_id, BtdrvGattAttributeUuid *out);
+
+/// Wrapper for \ref btdevStartBleScanGeneral.
+Result btdevStartBleScanGeneral(BtdrvBleAdvertisePacketParameter param);
+
+/// Wrapper for \ref btmuStopBleScanForGeneral.
+Result btdevStopBleScanGeneral(void);
+
+/**
+ * @brief Wrapper for \ref btmuGetBleScanResultsForGeneral and \ref btmuGetBleScanResultsForSmartDevice.
+ * @param[out] results Output array of \ref BtdrvBleScanResult.
+ * @param[in] count Size of the results array in entries.
+ * @param[out] total_out Total output entries.
+ */
+Result btdevGetBleScanResult(BtdrvBleScanResult *results, u8 count, u8 *total_out);
+
+/// Wrapper for \ref btmuStartBleScanForPaired.
+Result btdevEnableBleAutoConnection(BtdrvBleAdvertisePacketParameter param);
+
+/// Wrapper for \ref btmuStopBleScanForPaired.
+Result btdevDisableBleAutoConnection(void);
+
+/// Wrapper for \ref btmuStartBleScanForSmartDevice.
+Result btdevStartBleScanSmartDevice(const BtdrvGattAttributeUuid *uuid);
+
+/// Wrapper for \ref btmuStopBleScanForSmartDevice.
+Result btdevStopBleScanSmartDevice(void);
+
+/// Wrapper for \ref btmuAcquireBleConnectionEvent.
+Result btdevAcquireBleConnectionStateChangedEvent(Event* out_event);
+
+/// Wrapper for \ref btmuBleConnect.
+Result btdevConnectToGattServer(BtdrvAddress addr);
+
+/// Wrapper for \ref btmuBleDisconnect.
+Result btdevDisconnectFromGattServer(u32 connection_handle);
+
+/// Wrapper for \ref btmuBleGetConnectionState.
+Result btdevGetBleConnectionInfoList(BtdrvBleConnectionInfo *info, u8 count, u8 *total_out);
+
+/// Wrapper for \ref btmuAcquireBleServiceDiscoveryEvent.
+Result btdevAcquireBleServiceDiscoveryEvent(Event* out_event);
+
+/**
+ * @brief Wrapper for \ref btmuGetGattServices.
+ * @param[in] connection_handle ConnectionHandle
+ * @param[out] services Output array of \ref BtdevGattService.
+ * @param[in] count Size of the services array in entries. The max is 100.
+ * @param[out] total_out Total output entries.
+ */
+Result btdevGetGattServices(u32 connection_handle, BtdevGattService *services, u8 count, u8 *total_out);
+
+/**
+ * @brief Wrapper for \ref btmuGetGattService.
+ * @param[in] connection_handle ConnectionHandle
+ * @param[in] uuid \ref BtdrvGattAttributeUuid
+ * @param[out] service \ref BtdevGattService
+ * @param[out] flag Whether a \ref BtdevGattService was returned.
+ */
+Result btdevGetGattService(u32 connection_handle, const BtdrvGattAttributeUuid *uuid, BtdevGattService *service, bool *flag);
+
+/// Wrapper for \ref btmuAcquireBlePairingEvent.
+Result btdevAcquireBlePairingEvent(Event* out_event);
+
+/// Wrapper for \ref btmuBlePairDevice.
+Result btdevPairGattServer(u32 connection_handle, BtdrvBleAdvertisePacketParameter param);
+
+/// Wrapper for \ref btmuBleUnPairDevice.
+Result btdevUnpairGattServer(u32 connection_handle, BtdrvBleAdvertisePacketParameter param);
+
+/// Wrapper for \ref btmuBleUnPairDevice2.
+Result btdevUnpairGattServer2(BtdrvAddress addr, BtdrvBleAdvertisePacketParameter param);
+
+/// Wrapper for \ref btmuBleGetPairedDevices.
+Result btdevGetPairedGattServerAddress(BtdrvBleAdvertisePacketParameter param, BtdrvAddress *addrs, u8 count, u8 *total_out);
+
+/// Wrapper for \ref btmuAcquireBleMtuConfigEvent.
+Result btdevAcquireBleMtuConfigEvent(Event* out_event);
+
+/**
+ * @brief Wrapper for \ref btmuConfigureBleMtu.
+ * @param[in] connection_handle Same as \ref btmuBleDisconnect.
+ * @param[in] mtu MTU, must be 0x18-0x200.
+ */
+Result btdevConfigureBleMtu(u32 connection_handle, u16 mtu);
+
+/// Wrapper for \ref btmuGetBleMtu.
+Result btdevGetBleMtu(u32 connection_handle, u16 *out);
+
+/// Wrapper for \ref btRegisterBleEvent.
+Result btdevAcquireBleGattOperationEvent(Event* out_event);
+
+/**
+ * @brief Wrapper for \ref btmuRegisterBleGattDataPath.
+ * @param[in] uuid \ref BtdrvGattAttributeUuid
+ */
+Result btdevRegisterGattOperationNotification(const BtdrvGattAttributeUuid *uuid);
+
+/**
+ * @brief Wrapper for \ref btmuUnregisterBleGattDataPath.
+ * @param[in] uuid \ref BtdrvGattAttributeUuid
+ */
+Result btdevUnregisterGattOperationNotification(const BtdrvGattAttributeUuid *uuid);
+
+/**
+ * @brief Wrapper for \ref btGetLeEventInfo.
+ * @param[out] out \ref BtdrvBleClientGattOperationInfo
+ */
+Result btdevGetGattOperationResult(BtdrvBleClientGattOperationInfo *out);
+
+/**
+ * @brief Wrapper for \ref btLeClientReadCharacteristic.
+ * @note An error is thrown if the properties from \ref btdevGattCharacteristicGetProperties don't allow using this.
+ * @param c \ref BtdevGattCharacteristic
+ */
+Result btdevReadGattCharacteristic(BtdevGattCharacteristic *c);
+
+/**
+ * @brief Wrapper for \ref btLeClientWriteCharacteristic.
+ * @note An error is thrown if the properties from \ref btdevGattCharacteristicGetProperties don't allow using this.
+ * @note This uses the Value from \ref btdevGattCharacteristicSetValue.
+ * @param c \ref BtdevGattCharacteristic
+ */
+Result btdevWriteGattCharacteristic(BtdevGattCharacteristic *c);
+
+/**
+ * @brief Wrapper for \ref btLeClientRegisterNotification / \ref btLeClientDeregisterNotification.
+ * @note An error is thrown if the properties from \ref btdevGattCharacteristicGetProperties don't allow using this.
+ * @param c \ref BtdevGattCharacteristic
+ * @param[in] flag Whether to enable/disable, controls which func to call.
+ */
+Result btdevEnableGattCharacteristicNotification(BtdevGattCharacteristic *c, bool flag);
+
+/**
+ * @brief Wrapper for \ref btLeClientReadDescriptor.
+ * @param d \ref BtdevGattDescriptor
+ */
+Result btdevReadGattDescriptor(BtdevGattDescriptor *d);
+
+/**
+ * @brief Wrapper for \ref btLeClientWriteDescriptor.
+ * @note This uses the Value from \ref btdevGattDescriptorSetValue.
+ * @param d \ref BtdevGattDescriptor
+ */
+Result btdevWriteGattDescriptor(BtdevGattDescriptor *d);
+
+///@name GattAttribute
+///@{
+
+/**
+ * @brief Creates a \ref BtdevGattAttribute object. This is intended for internal use.
+ * @param a \ref BtdevGattAttribute
+ * @param[in] uuid \ref BtdrvGattAttributeUuid
+ * @param[in] handle Handle
+ * @param[in] connection_handle ConnectionHandle
+ */
+void btdevGattAttributeCreate(BtdevGattAttribute *a, const BtdrvGattAttributeUuid *uuid, u16 handle, u32 connection_handle);
+
+/**
+ * @brief Gets the Type.
+ * @param a \ref BtdevGattAttribute
+ */
+NX_CONSTEXPR u8 btdevGattAttributeGetType(BtdevGattAttribute *a) {
+    return a->type;
+}
+
+/**
+ * @brief Gets the Uuid.
+ * @param a \ref BtdevGattAttribute
+ * @param[out] out \ref BtdrvGattAttributeUuid
+ */
+NX_CONSTEXPR void btdevGattAttributeGetUuid(BtdevGattAttribute *a, BtdrvGattAttributeUuid *out) {
+    *out = a->uuid;
+}
+
+/**
+ * @brief Gets the Handle.
+ * @param a \ref BtdevGattAttribute
+ */
+NX_CONSTEXPR u16 btdevGattAttributeGetHandle(BtdevGattAttribute *a) {
+    return a->handle;
+}
+
+/**
+ * @brief Gets the ConnectionHandle.
+ * @param a \ref BtdevGattAttribute
+ */
+NX_CONSTEXPR u32 btdevGattAttributeGetConnectionHandle(BtdevGattAttribute *a) {
+    return a->connection_handle;
+}
+
+///@}
+
+///@name GattService
+///@{
+
+/**
+ * @brief Creates a \ref BtdevGattService object. This is intended for internal use.
+ * @param s \ref BtdevGattService
+ * @param[in] uuid \ref BtdrvGattAttributeUuid
+ * @param[in] handle Handle
+ * @param[in] connection_handle ConnectionHandle
+ * @param[in] instance_id InstanceId
+ * @param[in] end_group_handle EndGroupHandle
+ * @param[in] primary_service PrimaryService
+ */
+void btdevGattServiceCreate(BtdevGattService *s, const BtdrvGattAttributeUuid *uuid, u16 handle, u32 connection_handle, u16 instance_id, u16 end_group_handle, bool primary_service);
+
+/**
+ * @brief Gets the InstanceId.
+ * @param s \ref BtdevGattService
+ */
+NX_CONSTEXPR u16 btdevGattServiceGetInstanceId(BtdevGattService *s) {
+    return s->instance_id;
+}
+
+/**
+ * @brief Gets the EndGroupHandle.
+ * @param s \ref BtdevGattService
+ */
+NX_CONSTEXPR u16 btdevGattServiceGetEndGroupHandle(BtdevGattService *s) {
+    return s->end_group_handle;
+}
+
+/**
+ * @brief Gets whether this is the PrimaryService.
+ * @param s \ref BtdevGattService
+ */
+NX_CONSTEXPR u16 btdevGattServiceIsPrimaryService(BtdevGattService *s) {
+    return s->primary_service;
+}
+
+/**
+ * @brief Wrapper for \ref btmuGetGattIncludedServices.
+ * @param s \ref BtdevGattService
+ * @param[out] services Output array of \ref BtdevGattService.
+ * @param[in] count Size of the services array in entries. The max is 100.
+ * @param[out] total_out Total output entries.
+ */
+Result btdevGattServiceGetIncludedServices(BtdevGattService *s, BtdevGattService *services, u8 count, u8 *total_out);
+
+/**
+ * @brief Wrapper for \ref btmuGetGattCharacteristics.
+ * @param s \ref BtdevGattService
+ * @param[out] characteristics Output array of \ref BtdevGattCharacteristic.
+ * @param[in] count Size of the characteristics array in entries. The max is 100.
+ * @param[out] total_out Total output entries.
+ */
+Result btdevGattServiceGetCharacteristics(BtdevGattService *s, BtdevGattCharacteristic *characteristics, u8 count, u8 *total_out);
+
+/**
+ * @brief Same as \ref btdevGattServiceGetCharacteristics except this only returns the \ref BtdevGattCharacteristic which contains a matching \ref BtdrvGattAttributeUuid.
+ * @param s \ref BtdevGattService
+ * @param[in] uuid \ref BtdrvGattAttributeUuid
+ * @param[out] characteristic \ref BtdevGattCharacteristic
+ * @param[out] flag Whether a \ref BtdevGattService was returned.
+ */
+Result btdevGattServiceGetCharacteristic(BtdevGattService *s, const BtdrvGattAttributeUuid *uuid, BtdevGattCharacteristic *characteristic, bool *flag);
+
+///@}
+
+///@name GattCharacteristic
+///@{
+
+/**
+ * @brief Creates a \ref BtdevGattCharacteristic object. This is intended for internal use.
+ * @param c \ref BtdevGattCharacteristic
+ * @param[in] uuid \ref BtdrvGattAttributeUuid
+ * @param[in] handle Handle
+ * @param[in] connection_handle ConnectionHandle
+ * @param[in] instance_id InstanceId
+ * @param[in] properties Properties
+ */
+void btdevGattCharacteristicCreate(BtdevGattCharacteristic *c, const BtdrvGattAttributeUuid *uuid, u16 handle, u32 connection_handle, u16 instance_id, u8 properties);
+
+/**
+ * @brief Gets the InstanceId.
+ * @param c \ref BtdevGattCharacteristic
+ */
+NX_CONSTEXPR u16 btdevGattCharacteristicGetInstanceId(BtdevGattCharacteristic *c) {
+    return c->instance_id;
+}
+
+/**
+ * @brief Gets the Properties.
+ * @param c \ref BtdevGattCharacteristic
+ */
+NX_CONSTEXPR u8 btdevGattCharacteristicGetProperties(BtdevGattCharacteristic *c) {
+    return c->properties;
+}
+
+/**
+ * @brief Wrapper for \ref btmuGetBelongingGattService.
+ * @note Gets the \ref BtdevGattService which belongs to this object.
+ * @param c \ref BtdevGattCharacteristic.
+ * @param[out] service \ref BtdevGattService
+ */
+Result btdevGattCharacteristicGetService(BtdevGattCharacteristic *c, BtdevGattService *service);
+
+/**
+ * @brief Wrapper for \ref btmuGetGattDescriptors.
+ * @note Gets the descriptors which belongs to this object.
+ * @param c \ref BtdevGattCharacteristic
+ * @param[out] descriptors Output array of \ref BtdevGattDescriptor.
+ * @param[in] count Size of the descriptors array in entries. The max is 100.
+ * @param[out] total_out Total output entries.
+ */
+Result btdevGattCharacteristicGetDescriptors(BtdevGattCharacteristic *c, BtdevGattDescriptor *descriptors, u8 count, u8 *total_out);
+
+/**
+ * @brief Same as \ref btdevGattCharacteristicGetDescriptors except this only returns a \ref BtdevGattDescriptor which contains a matching \ref BtdrvGattAttributeUuid.
+ * @param c \ref BtdevGattCharacteristic
+ * @param[in] uuid \ref BtdrvGattAttributeUuid
+ * @param[out] descriptor \ref BtdevGattDescriptor
+ * @param[out] flag Whether a \ref BtdevGattDescriptor was returned.
+ */
+Result btdevGattCharacteristicGetDescriptor(BtdevGattCharacteristic *c, const BtdrvGattAttributeUuid *uuid, BtdevGattDescriptor *descriptor, bool *flag);
+
+/**
+ * @brief Sets the Value in the object.
+ * @note See also \ref btdevWriteGattCharacteristic.
+ * @param c \ref BtdevGattCharacteristic
+ * @param[in] buffer Input buffer.
+ * @param[in] size Input buffer size, max is 0x200.
+ */
+void btdevGattCharacteristicSetValue(BtdevGattCharacteristic *c, const void* buffer, size_t size);
+
+/**
+ * @brief Gets the Value in the object, returns the copied value size.
+ * @param c \ref BtdevGattCharacteristic
+ * @param[out] buffer Output buffer.
+ * @param[in] size Output buffer size, max is 0x200.
+ */
+u64 btdevGattCharacteristicGetValue(BtdevGattCharacteristic *c, void* buffer, size_t size);
+
+///@}
+
+///@name GattDescriptor
+///@{
+
+/**
+ * @brief Creates a \ref BtdevGattDescriptor object. This is intended for internal use.
+ * @param d \ref BtdevGattDescriptor
+ * @param[in] uuid \ref BtdrvGattAttributeUuid
+ * @param[in] handle Handle
+ * @param[in] connection_handle ConnectionHandle
+ */
+void btdevGattDescriptorCreate(BtdevGattDescriptor *d, const BtdrvGattAttributeUuid *uuid, u16 handle, u32 connection_handle);
+
+/**
+ * @brief Wrapper for \ref btmuGetBelongingGattService.
+ * @note Gets the \ref BtdevGattService which belongs to this object.
+ * @param d \ref BtdevGattDescriptor
+ * @param[out] service \ref BtdevGattService
+ */
+Result btdevGattDescriptorGetService(BtdevGattDescriptor *d, BtdevGattService *service);
+
+/**
+ * @brief Wrapper for \ref btmuGetGattCharacteristics.
+ * @note Gets the \ref BtdevGattCharacteristic which belongs to this object.
+ * @param d \ref BtdevGattDescriptor
+ * @param[out] characteristic \ref BtdevGattCharacteristic
+ */
+Result btdevGattDescriptorGetCharacteristic(BtdevGattDescriptor *d, BtdevGattCharacteristic *characteristic);
+
+/**
+ * @brief Sets the Value in the object.
+ * @note See also \ref btdevWriteGattDescriptor.
+ * @param d \ref BtdevGattDescriptor
+ * @param[in] buffer Input buffer.
+ * @param[in] size Input buffer size, max is 0x200.
+ */
+void btdevGattDescriptorSetValue(BtdevGattDescriptor *d, const void* buffer, size_t size);
+
+/**
+ * @brief Gets the Value in the object, returns the copied value size.
+ * @param d \ref BtdevGattDescriptor
+ * @param[out] buffer Output buffer.
+ * @param[in] size Output buffer size, max is 0x200.
+ */
+u64 btdevGattDescriptorGetValue(BtdevGattDescriptor *d, void* buffer, size_t size);
+
+///@}
+

nx/include/switch/runtime/devices/console.h

@@ -10,12 +10,9 @@
  *
  * General usage is to initialize the console by:
  * @code
- * consoleDemoInit()
- * @endcode
- * or to customize the console usage by:
- * @code
- * consoleInit()
+ * consoleInit(NULL)
  * @endcode
+ * optionally customizing the console usage by passing a pointer to a custom PrintConsole struct.
  */
 #pragma once
 #include "../../types.h"
@@ -31,15 +28,27 @@
 #define CONSOLE_CYAN    CONSOLE_ESC(36;1m)
 #define CONSOLE_WHITE   CONSOLE_ESC(37;1m)
 
-/// A callback for printing a character.
-typedef bool(*ConsolePrint)(void* con, int c);
+// Forward declaration
+typedef struct PrintConsole PrintConsole;
+
+/// Renderer interface for the console.
+typedef struct ConsoleRenderer
+{
+	bool (*init)(PrintConsole* con);
+	void (*deinit)(PrintConsole* con);
+	void (*drawChar)(PrintConsole* con, int x, int y, int c);
+	void (*scrollWindow)(PrintConsole* con);
+	void (*flushAndSwap)(PrintConsole* con);
+} ConsoleRenderer;
 
 /// A font struct for the console.
 typedef struct ConsoleFont
 {
-	u16* gfx;         ///< A pointer to the font graphics
+	const void* gfx;         ///< A pointer to the font graphics
 	u16 asciiOffset; ///< Offset to the first valid character in the font table
 	u16 numChars;    ///< Number of characters in the font graphics
+	u16 tileWidth;
+	u16 tileHeight;
 }ConsoleFont;
 
 /**
@@ -51,10 +60,13 @@ typedef struct ConsoleFont
  * {
  * 	//Font:
  * 	{
- * 		(u16*)default_font_bin, //font gfx
+ * 		default_font_bin, //font gfx
  * 		0, //first ascii character in the set
- * 		128, //number of characters in the font set
+ * 		256, //number of characters in the font set
+ * 		16, //tile width
+ * 		16, //tile height
  *	},
+ *	NULL, //renderer
  *	0,0, //cursorX cursorY
  *	0,0, //prevcursorX prevcursorY
  *	80, //console width
@@ -64,18 +76,17 @@ typedef struct ConsoleFont
  *	80, //window width
  *	45, //window height
  *	3, //tab size
- *	0, //font character offset
- *	0,  //print callback
+ *	7, // foreground color
+ *	0, // background color
+ *	0, // flags
  *	false //console initialized
  * };
  * @endcode
  */
-typedef struct PrintConsole
+struct PrintConsole
 {
 	ConsoleFont font;        ///< Font of the console
-
-	u32 *frameBuffer;        ///< Framebuffer address
-	u32 *frameBuffer2;       ///< Framebuffer address
+	ConsoleRenderer* renderer; ///< Renderer of the console
 
 	int cursorX;             ///< Current X location of the cursor (as a tile offset by default)
 	int cursorY;             ///< Current Y location of the cursor (as a tile offset by default)
@@ -86,20 +97,18 @@ typedef struct PrintConsole
 	int consoleWidth;        ///< Width of the console hardware layer in characters
 	int consoleHeight;       ///< Height of the console hardware layer in characters
 
-	int windowX;             ///< Window X location in characters (not implemented)
-	int windowY;             ///< Window Y location in characters (not implemented)
-	int windowWidth;         ///< Window width in characters (not implemented)
-	int windowHeight;        ///< Window height in characters (not implemented)
+	int windowX;             ///< Window X location in characters
+	int windowY;             ///< Window Y location in characters
+	int windowWidth;         ///< Window width in characters
+	int windowHeight;        ///< Window height in characters
 
 	int tabSize;             ///< Size of a tab
-	int fg;                  ///< Foreground color
-	int bg;                  ///< Background color
+	u16 fg;                  ///< Foreground color
+	u16 bg;                  ///< Background color
 	int flags;               ///< Reverse/bright flags
 
-	ConsolePrint PrintChar;  ///< Callback for printing a character. Should return true if it has handled rendering the graphics (else the print engine will attempt to render via tiles).
-
 	bool consoleInitialised; ///< True if the console is initialized
-}PrintConsole;
+};
 
 #define CONSOLE_COLOR_BOLD	(1<<0) ///< Bold text
 #define CONSOLE_COLOR_FAINT	(1<<1) ///< Faint text
@@ -110,13 +119,14 @@ typedef struct PrintConsole
 #define CONSOLE_COLOR_REVERSE	(1<<6) ///< Reversed color text
 #define CONSOLE_CONCEAL		(1<<7) ///< Concealed text
 #define CONSOLE_CROSSED_OUT	(1<<8) ///< Crossed out text
+#define CONSOLE_FG_CUSTOM	(1<<9) ///< Foreground custom color
+#define CONSOLE_BG_CUSTOM	(1<<10) ///< Background custom color
 
 /// Console debug devices supported by libnx.
 typedef enum {
 	debugDevice_NULL,    ///< Swallows prints to stderr
 	debugDevice_SVC,     ///< Outputs stderr debug statements using svcOutputDebugString, which can then be captured by interactive debuggers
 	debugDevice_CONSOLE, ///< Directs stderr debug statements to Switch console window
-	debugDevice_3DMOO = debugDevice_SVC,
 } debugDevice;
 
 /**
@@ -157,11 +167,24 @@ PrintConsole *consoleSelect(PrintConsole* console);
  */
 PrintConsole* consoleInit(PrintConsole* console);
 
+/**
+ * @brief Deinitialise the console.
+ * @param console A pointer to the console data to initialize (if it's NULL, the default console will be used).
+ */
+void consoleExit(PrintConsole* console);
+
+/**
+ * @brief Updates the console, submitting a new frame to the display.
+ * @param console A pointer to the console data to initialize (if it's NULL, the default console will be used).
+ * @remark This function should be called periodically. Failure to call this function will result in lack of screen updating.
+ */
+void consoleUpdate(PrintConsole* console);
+
 /**
  * @brief Initializes debug console output on stderr to the specified device.
  * @param device The debug device (or devices) to output debug print statements to.
  */
 void consoleDebugInit(debugDevice device);
 
-/// Clears the screan by using iprintf("\x1b[2J");
+/// Clears the screan by using printf("\x1b[2J");
 void consoleClear(void);

nx/include/switch/runtime/devices/fs_dev.h

@@ -19,14 +19,48 @@ typedef struct
   FsDir             fd;            ///< File descriptor
   ssize_t           index;         ///< Current entry index
   size_t            size;          ///< Current batch size
-  FsDirectoryEntry entry_data[32]; ///< Temporary storage for reading entries
 } fsdev_dir_t;
 
-/// Initializes and mounts the sdmc device if accessible. Also initializes current working directory to point to the folder containing the path to the executable (argv[0]), if it is provided by the environment.
+/// Retrieves a pointer to temporary stage for reading entries
+NX_CONSTEXPR FsDirectoryEntry* fsdevDirGetEntries(fsdev_dir_t *dir)
+{
+  return (FsDirectoryEntry*)(void*)(dir+1);
+}
+
+/// Initializes and mounts the sdmc device if accessible.
 Result fsdevMountSdmc(void);
 
+/// Mounts the specified SaveData.
+Result fsdevMountSaveData(const char *name, u64 application_id, AccountUid uid);
+
+/// Mounts the specified SaveData as ReadOnly.
+/// Only available on [2.0.0+].
+Result fsdevMountSaveDataReadOnly(const char *name, u64 application_id, AccountUid uid);
+
+/// Mounts the specified BcatSaveData.
+Result fsdevMountBcatSaveData(const char *name, u64 application_id);
+
+/// Mounts the specified DeviceSaveData.
+Result fsdevMountDeviceSaveData(const char *name, u64 application_id);
+
+/// Mounts the TemporaryStorage for the current process.
+/// Only available on [3.0.0+].
+Result fsdevMountTemporaryStorage(const char *name);
+
+/// Mounts the specified CacheStorage.
+/// Only available on [3.0.0+].
+Result fsdevMountCacheStorage(const char *name, u64 application_id, u16 save_data_index);
+
+/// Mounts the specified SystemSaveData.
+Result fsdevMountSystemSaveData(const char *name, FsSaveDataSpaceId save_data_space_id, u64 system_save_data_id, AccountUid uid);
+
+/// Mounts the specified SystemBcatSaveData.
+/// Only available on [4.0.0+].
+Result fsdevMountSystemBcatSaveData(const char *name, u64 system_save_data_id);
+
 /// Mounts the input fs with the specified device name. fsdev will handle closing the fs when required, including when fsdevMountDevice() fails.
 /// Returns -1 when any errors occur.
+/// Input device name string shouldn't exceed 31 characters, and shouldn't have a trailing colon.
 int fsdevMountDevice(const char *name, FsFileSystem fs);
 
 /// Unmounts the specified device.
@@ -36,8 +70,26 @@ int fsdevUnmountDevice(const char *name);
 /// This is not used automatically at device unmount.
 Result fsdevCommitDevice(const char *name);
 
-/// Returns the FsFileSystem for the default device (SD card), if mounted. Used internally by romfs_dev.
-FsFileSystem* fsdevGetDefaultFileSystem(void);
+/// Returns the FsFileSystem for the specified device. Returns NULL when the specified device isn't found.
+FsFileSystem* fsdevGetDeviceFileSystem(const char *name);
+
+/// Writes the FS-path to outpath (which has buffer size FS_MAX_PATH), for the input path (as used in stdio). The FsFileSystem is also written to device when not NULL.
+int fsdevTranslatePath(const char *path, FsFileSystem** device, char *outpath);
+
+/// This calls fsFsSetConcatenationFileAttribute on the filesystem specified by the input path (as used in stdio).
+Result fsdevSetConcatenationFileAttribute(const char *path);
+
+// Uses \ref fsFsIsValidSignedSystemPartitionOnSdCard with the specified device.
+Result fsdevIsValidSignedSystemPartitionOnSdCard(const char *name, bool *out);
+
+/// This calls fsFsCreateFile on the filesystem specified by the input path (as used in stdio).
+Result fsdevCreateFile(const char* path, size_t size, u32 flags);
+
+/// Recursively deletes the directory specified by the input path (as used in stdio).
+Result fsdevDeleteDirectoryRecursively(const char *path);
 
 /// Unmounts all devices and cleans up any resources used by the FS driver.
 Result fsdevUnmountAll(void);
+
+/// Retrieves the last native result code generated during a failed fsdev operation.
+Result fsdevGetLastResult(void);

nx/include/switch/runtime/devices/romfs_dev.h

@@ -10,6 +10,7 @@
 
 #include "../../types.h"
 #include "../../services/fs.h"
+#include "../../services/ncm_types.h"
 
 /// RomFS header.
 typedef struct
@@ -50,49 +51,72 @@ typedef struct
     uint8_t name[];   ///< Name. (UTF-8)
 } romfs_file;
 
-struct romfs_mount;
-
 /**
  * @brief Mounts the Application's RomFS.
- * @param mount Output mount handle
+ * @param name Device mount name.
+ * @remark This function is intended to be used to access one's own RomFS.
+ *         If the application is running as NRO, it mounts the embedded RomFS section inside the NRO.
+ *         If on the other hand it's an NSO, it behaves identically to \ref romfsMountFromCurrentProcess.
  */
-Result romfsMount(struct romfs_mount **mount);
-static inline Result romfsInit(void)
-{
-    return romfsMount(NULL);
-}
+Result romfsMountSelf(const char *name);
 
 /**
  * @brief Mounts RomFS from an open file.
  * @param file FsFile of the RomFS image.
  * @param offset Offset of the RomFS within the file.
- * @param mount Output mount handle
+ * @param name Device mount name.
  */
-Result romfsMountFromFile(FsFile file, u64 offset, struct romfs_mount **mount);
-static inline Result romfsInitFromFile(FsFile file, u64 offset)
-{
-    return romfsMountFromFile(file, offset, NULL);
-}
+Result romfsMountFromFile(FsFile file, u64 offset, const char *name);
 
 /**
  * @brief Mounts RomFS from an open storage.
  * @param storage FsStorage of the RomFS image.
  * @param offset Offset of the RomFS within the storage.
- * @param mount Output mount handle
+ * @param name Device mount name.
  */
-Result romfsMountFromStorage(FsStorage storage, u64 offset, struct romfs_mount **mount);
-static inline Result romfsInitFromStorage(FsStorage storage, u64 offset)
-{
-    return romfsMountFromStorage(storage, offset, NULL);
-}
+Result romfsMountFromStorage(FsStorage storage, u64 offset, const char *name);
 
-/// Bind the RomFS mount
-Result romfsBind(struct romfs_mount *mount);
+/**
+ * @brief Mounts RomFS using the current process host program RomFS.
+ * @param name Device mount name.
+ */
+Result romfsMountFromCurrentProcess(const char *name);
+
+/**
+ * @brief Mounts RomFS of a running program.
+ * @note Permission needs to be set in the NPDM.
+ * @param program_id ProgramId to mount.
+ * @param name Device mount name.
+ */
+Result romfsMountDataStorageFromProgram(u64 program_id, const char *name);
+
+/**
+ * @brief Mounts RomFS from a file path in a mounted fsdev device.
+ * @param path File path.
+ * @param offset Offset of the RomFS within the file.
+ * @param name Device mount name.
+ */
+Result romfsMountFromFsdev(const char *path, u64 offset, const char *name);
+
+/**
+ * @brief Mounts RomFS from SystemData.
+ * @param dataId SystemDataId to mount.
+ * @param storageId Storage ID to mount from.
+ * @param name Device mount name.
+ */
+Result romfsMountFromDataArchive(u64 dataId, NcmStorageId storageId, const char *name);
 
 /// Unmounts the RomFS device.
-Result romfsUnmount(struct romfs_mount *mount);
-static inline Result romfsExit(void)
+Result romfsUnmount(const char *name);
+
+/// Wrapper for \ref romfsMountSelf with the default "romfs" device name.
+static inline Result romfsInit(void)
 {
-    return romfsUnmount(NULL);
+    return romfsMountSelf("romfs");
 }
 
+/// Wrapper for \ref romfsUnmount with the default "romfs" device name.
+static inline Result romfsExit(void)
+{
+    return romfsUnmount("romfs");
+}

nx/include/switch/runtime/devices/socket.h

@@ -1,12 +1,17 @@
 #pragma once
 #include "../../types.h"
 
+/// BSD service type used by the socket driver.
+typedef enum {
+    BsdServiceType_User   = BIT(0), ///< Uses bsd:u (default).
+    BsdServiceType_System = BIT(1), ///< Uses bsd:s.
+    BsdServiceType_Auto   = BsdServiceType_User | BsdServiceType_System, ///< Tries to use bsd:s first, and if that fails uses bsd:u (official software behavior).
+} BsdServiceType;
+
 /// Configuration structure for socketInitalize
 typedef struct  {
-    u32 bsdsockets_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_rx_buf_size;                        ///< Size of the TCP receive 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.
 
@@ -15,10 +20,8 @@ typedef struct  {
 
     u32 sb_efficiency;                          ///< Number of buffers for each socket (standard values range from 1 to 8).
 
-    size_t serialized_out_addrinfos_max_size;   ///< For getaddrinfo.
-    size_t serialized_out_hostent_max_size;     ///< For gethostbyname/gethostbyaddr.
-    bool bypass_nsd;                            ///< For name gethostbyname/getaddrinfo: bypass the Name Server Daemon.
-    int dns_timeout;                            ///< For DNS requests: timeout or 0.
+    u32 num_bsd_sessions;                       ///< Number of BSD service sessions (typically 3).
+    BsdServiceType bsd_service_type;            ///< BSD service type (typically \ref BsdServiceType_User).
 } SocketInitConfig;
 
 /// Fetch the default configuration for the socket driver.
@@ -26,14 +29,30 @@ const SocketInitConfig *socketGetDefaultInitConfig(void);
 /// Initalize the socket driver.
 Result socketInitialize(const SocketInitConfig *config);
 /// Fetch the last bsd:u/s Switch result code (thread-local).
-Result socketGetLastBsdResult(void);
-/// Fetch the last sfdnsres Switch result code (thread-local).
-Result socketGetLastSfdnsresResult(void);
+Result socketGetLastResult(void);
 /// Deinitialize the socket driver.
 void socketExit(void);
 
 /// Initalize the socket driver using the default configuration.
-static inline Result socketInitializeDefault(void) {
-    return socketInitialize(socketGetDefaultInitConfig());
+NX_INLINE Result socketInitializeDefault(void) {
+    return socketInitialize(NULL);
 }
 
+/// Wrapper for \ref sslConnectionSetSocketDescriptor. Returns the output sockfd on success and -1 on error. errno==ENOENT indicates that no sockfd was returned, this error must be ignored.
+int socketSslConnectionSetSocketDescriptor(SslConnection *c, int sockfd);
+
+/// Wrapper for \ref sslConnectionGetSocketDescriptor. Returns the output sockfd on success and -1 on error.
+int socketSslConnectionGetSocketDescriptor(SslConnection *c);
+
+#ifdef _SOCKLEN_T_DECLARED
+struct sockaddr;
+/// Wrapper for \ref sslConnectionSetDtlsSocketDescriptor. Returns the output sockfd on success and -1 on error. errno==ENOENT indicates that no sockfd was returned, this error must be ignored.
+int socketSslConnectionSetDtlsSocketDescriptor(SslConnection *c, int sockfd, const struct sockaddr *addr, socklen_t addrlen);
+#endif
+
+/// Wrapper for \ref nifmRequestRegisterSocketDescriptor. Returns 0 on success and -1 on error.
+int socketNifmRequestRegisterSocketDescriptor(NifmRequest* r, int sockfd);
+
+/// Wrapper for \ref nifmRequestUnregisterSocketDescriptor. Returns 0 on success and -1 on error.
+int socketNifmRequestUnregisterSocketDescriptor(NifmRequest* r, int sockfd);
+

nx/include/switch/runtime/devices/usb_comms.h

@@ -8,15 +8,26 @@
 #pragma once
 #include "../../types.h"
 
+typedef struct {
+    u8 bInterfaceClass;
+    u8 bInterfaceSubClass;
+    u8 bInterfaceProtocol;
+} UsbCommsInterfaceInfo;
+
+/// Initializes usbComms with the default number of interfaces (1)
 Result usbCommsInitialize(void);
+
+/// Initializes usbComms with a specific number of interfaces.
+Result usbCommsInitializeEx(u32 num_interfaces, const UsbCommsInterfaceInfo *infos, u16 idVendor, u16 idProduct);
+
+/// Exits usbComms.
 void usbCommsExit(void);
 
-/// Same as usbCommsInitialize, except this can be used after usbCommsInitialize (or instead of usbCommsInitialize), for creating new interface(s).
-/// bInterface* are the values for the same fields in usb.h \ref usb_interface_descriptor. \ref usbCommsInitialize uses USB_CLASS_VENDOR_SPEC for all of these internally.
-Result usbCommsInitializeEx(u32 *interface, u8 bInterfaceClass, u8 bInterfaceSubClass, u8 bInterfaceProtocol);
+/// Sets whether to throw a fatal error in usbComms{Read/Write}* on failure, or just return the transferred size. By default (false) the latter is used.
+void usbCommsSetErrorHandling(bool flag);
 
-/// Shutdown the specified interface. If no interfaces are remaining, this then uses \ref usbCommsExit internally.
-void usbCommsExitEx(u32 interface);
+///@name Synchronous API
+///@{
 
 /// Read data with the default interface.
 size_t usbCommsRead(void* buffer, size_t size);
@@ -29,3 +40,31 @@ size_t usbCommsReadEx(void* buffer, size_t size, u32 interface);
 
 /// Same as usbCommsWrite except with the specified interface.
 size_t usbCommsWriteEx(const void* buffer, size_t size, u32 interface);
+
+///@}
+
+///@name Asynchronous API
+///@{
+
+/// Retrieve event used for read completion with the given interface.
+Event *usbCommsGetReadCompletionEvent(u32 interface);
+
+/// Start an asynchronous read. The completion event will be signaled when the read completes.
+/// The buffer must be page-aligned and no larger than one page.
+Result usbCommsReadAsync(void *buffer, size_t size, u32 *urbId, u32 interface);
+
+/// Complete an asynchronous read, clearing the completion event, and return the amount of data which was read.
+Result usbCommsGetReadResult(u32 urbId, u32 *transferredSize, u32 interface);
+
+
+/// Retrieve event used for write completion with the given interface.
+Event *usbCommsGetWriteCompletionEvent(u32 interface);
+
+/// Start an asynchronous write. The completion event will be signaled when the write completes.
+/// The buffer must be page-aligned and no larger than one page.
+Result usbCommsWriteAsync(void *buffer, size_t size, u32 *urbId, u32 interface);
+
+/// Complete an asynchronous write, clearing the completion event, and return the amount of data which was written.
+Result usbCommsGetWriteResult(u32 urbId, u32 *transferredSize, u32 interface);
+
+///@}

nx/include/switch/runtime/diag.h

@@ -0,0 +1,15 @@
+/**
+ * @file diag.h
+ * @brief Debugging and diagnostics utilities
+ * @author fincs
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+#include "../result.h"
+
+/**
+ * @brief Aborts program execution with a result code.
+ * @param[in] res Result code.
+ */
+void NX_NORETURN diagAbortWithResult(Result res);

nx/include/switch/runtime/env.h

@@ -6,6 +6,7 @@
  */
 #pragma once
 #include "../types.h"
+#include "../services/acc.h"
 
 /// Structure representing an entry in the homebrew environment configuration.
 typedef struct {
@@ -27,16 +28,24 @@ enum {
     EntryType_OverrideHeap=3,         ///< Provides heap override information.
     EntryType_OverrideService=4,      ///< Provides service override information.
     EntryType_Argv=5,                 ///< Provides argv.
-    EntryType_SyscallAvailableHint=6, ///< Provides syscall availability hints.
+    EntryType_SyscallAvailableHint=6, ///< Provides syscall availability hints (SVCs 0x00..0x7F).
     EntryType_AppletType=7,           ///< Provides APT applet type.
     EntryType_AppletWorkaround=8,     ///< Indicates that APT is broken and should not be used.
-    EntryType_StdioSockets=9,         ///< Provides socket-based standard stream redirection information.
+    EntryType_Reserved9=9,            ///< Unused/reserved entry type, formerly used by StdioSockets.
     EntryType_ProcessHandle=10,       ///< Provides the process handle.
-    EntryType_LastLoadResult=11       ///< Provides the last load result.
+    EntryType_LastLoadResult=11,      ///< Provides the last load result.
+    EntryType_RandomSeed=14,          ///< Provides random data used to seed the pseudo-random number generator.
+    EntryType_UserIdStorage=15,       ///< Provides persistent storage for the preselected user id.
+    EntryType_HosVersion=16,          ///< Provides the currently running Horizon OS version.
+    EntryType_SyscallAvailableHint2=17, ///< Provides syscall availability hints (SVCs 0x80..0xBF).
+};
+
+enum {
+    EnvAppletFlags_ApplicationOverride = BIT(0) ///< Use AppletType_Application instead of AppletType_SystemApplication.
 };
 
 /// Loader return function.
-typedef void NORETURN (*LoaderReturnFn)(int result_code);
+typedef void NX_NORETURN (*LoaderReturnFn)(int result_code);
 
 /**
  * @brief Parses the homebrew loader environment block (internally called).
@@ -46,6 +55,11 @@ typedef void NORETURN (*LoaderReturnFn)(int result_code);
  */
 void envSetup(void* ctx, Handle main_thread, LoaderReturnFn saved_lr);
 
+/// Returns information text about the loader, if present.
+const char* envGetLoaderInfo(void);
+/// Returns the size of the loader information text.
+u64 envGetLoaderInfoSize(void);
+
 /// Retrieves the handle to the main thread.
 Handle envGetMainThreadHandle(void);
 /// Returns true if the application is running as NSO, otherwise NRO.
@@ -68,7 +82,7 @@ void* envGetArgv(void);
  * @param svc Syscall number to test.
  * @returns true if the syscall is available.
  */
-bool envIsSyscallHinted(u8 svc);
+bool envIsSyscallHinted(unsigned svc);
 
 /// Returns the handle to the running homebrew process.
 Handle envGetOwnProcessHandle(void);
@@ -76,6 +90,9 @@ Handle envGetOwnProcessHandle(void);
 /// Returns the loader's return function, to be called on program exit.
 LoaderReturnFn envGetExitFuncPtr(void);
 
+/// Sets the return function to be called on program exit.
+void envSetExitFuncPtr(LoaderReturnFn addr);
+
 /**
  * @brief Configures the next homebrew application to load.
  * @param path Path to the next homebrew application to load (.nro).
@@ -88,3 +105,15 @@ bool envHasNextLoad(void);
 
 /// Returns the Result from the last NRO.
 Result envGetLastLoadResult(void);
+
+/// Returns true if the environment provides a random seed.
+bool envHasRandomSeed(void);
+
+/**
+ * @brief Retrieves the random seed provided by the environment.
+ * @param out Pointer to a u64[2] buffer which will contain the random seed on return.
+ */
+void envGetRandomSeed(u64 out[2]);
+
+/// Returns a pointer to the user id storage area (if present).
+AccountUid* envGetUserIdStorage(void);

nx/include/switch/runtime/hosversion.h

@@ -0,0 +1,45 @@
+/**
+ * @file hosversion.h
+ * @brief Horizon OS (HOS) version detection utilities.
+ * @author fincs
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+
+/// Builds a HOS version value from its constituent components.
+#define MAKEHOSVERSION(_major,_minor,_micro) (((u32)(_major) << 16) | ((u32)(_minor) << 8) | (u32)(_micro))
+
+/// Extracts the major number from a HOS version value.
+#define HOSVER_MAJOR(_version) (((_version) >> 16) & 0xFF)
+
+/// Extracts the minor number from a HOS version value.
+#define HOSVER_MINOR(_version) (((_version) >>  8) & 0xFF)
+
+/// Extracts the micro number from a HOS version value.
+#define HOSVER_MICRO(_version) ( (_version)        & 0xFF)
+
+/// Returns the current HOS version that was previously set with \ref hosversionSet. If version initialization fails during startup (such as in the case set:sys is not available), this function returns zero.
+u32 hosversionGet(void);
+
+/// Sets or overrides the current HOS version. This function is normally called automatically by libnx on startup with the version info obtained with \ref setsysGetFirmwareVersion.
+void hosversionSet(u32 version);
+
+/// Returns whether the current HOS version is augmented by running the Atmosphère custom firmware.
+bool hosversionIsAtmosphere(void);
+
+/// Returns true if the current HOS version is equal to or above the specified major/minor/micro version.
+static inline bool hosversionAtLeast(u8 major, u8 minor, u8 micro) {
+    return hosversionGet() >= MAKEHOSVERSION(major,minor,micro);
+}
+
+/// Returns true if the current HOS version is earlier than the specified major/minor/micro version.
+static inline bool hosversionBefore(u8 major, u8 minor, u8 micro) {
+    return !hosversionAtLeast(major, minor, micro);
+}
+
+/// Returns true if the current HOS version is between the two specified major versions, i.e. [major1, major2).
+static inline bool hosversionBetween(u8 major1, u8 major2) {
+    u32 ver = hosversionGet();
+    return ver >= MAKEHOSVERSION(major1,0,0) && ver < MAKEHOSVERSION(major2,0,0);
+}

nx/include/switch/runtime/nxlink.h

@@ -1,10 +1,35 @@
+/**
+ * @file nxlink.h
+ * @brief Netloader (nxlink) utilities
+ * @author WinterMute
+ * @copyright libnx Authors
+ */
 #pragma once
+#include "../types.h"
 
 struct in_addr;
 
+/// Address of the host connected through nxlink
 extern struct in_addr __nxlink_host;
 
-#define NXLINK_SERVER_PORT 28280
-#define NXLINK_CLIENT_PORT 28771
+#define NXLINK_SERVER_PORT 28280 ///< nxlink TCP server port
+#define NXLINK_CLIENT_PORT 28771 ///< nxlink TCP client port
 
-int nxlinkStdio(void);
+/**
+ * @brief Connects to the nxlink host, setting up an output stream.
+ * @param[in] redirStdout Whether to redirect stdout to nxlink output.
+ * @param[in] redirStderr Whether to redirect stderr to nxlink output.
+ * @return Socket fd on success, negative number on failure.
+ * @note The socket should be closed with close() during application cleanup.
+ */
+int nxlinkConnectToHost(bool redirStdout, bool redirStderr);
+
+/// Same as \ref nxlinkConnectToHost but redirecting both stdout/stderr.
+NX_INLINE int nxlinkStdio(void) {
+    return nxlinkConnectToHost(true, true);
+}
+
+/// Same as \ref nxlinkConnectToHost but redirecting only stderr.
+NX_INLINE int nxlinkStdioForDebug(void) {
+    return nxlinkConnectToHost(false, true);
+}

nx/include/switch/runtime/pad.h

@@ -0,0 +1,224 @@
+/**
+ * @file pad.h
+ * @brief Simple wrapper for the HID Npad API.
+ * @author fincs
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+#include "../services/hid.h"
+
+/// Mask including all existing controller IDs.
+#define PAD_ANY_ID_MASK 0x1000100FFUL
+
+/// Pad state object.
+typedef struct {
+    u8 id_mask;
+    u8 active_id_mask;
+    bool read_handheld;
+    bool active_handheld;
+    u32 style_set;
+    u32 attributes;
+    u64 buttons_cur;
+    u64 buttons_old;
+    HidAnalogStickState sticks[2];
+    u32 gc_triggers[2];
+} PadState;
+
+/// Pad button repeater state object.
+typedef struct {
+    u64 button_mask;
+    s32 counter;
+    u16 delay;
+    u16 repeat;
+} PadRepeater;
+
+/**
+ * @brief Configures the input layout supported by the application.
+ * @param[in] max_players The maximum supported number of players (1 to 8).
+ * @param[in] style_set Bitfield of supported controller styles (see \ref HidNpadStyleTag).
+ */
+void padConfigureInput(u32 max_players, u32 style_set);
+
+/**
+ * @brief Initializes a \ref PadState object to read input from one or more controller input sources.
+ * @param[in] _pad Pointer to \ref PadState.
+ * @remarks This is a variadic macro, pass the \ref HidNpadIdType value of each controller to add to the set.
+ */
+#define padInitialize(_pad, ...) ({ \
+    const HidNpadIdType _pad_ids[] = { __VA_ARGS__ }; \
+    u64 _pad_mask = 0; \
+    for (unsigned _pad_i = 0; _pad_i < (sizeof(_pad_ids)/sizeof(_pad_ids[0])); ++_pad_i) \
+        _pad_mask |= 1UL << (_pad_ids[_pad_i]); \
+    padInitializeWithMask((_pad), _pad_mask); \
+})
+
+/**
+ * @brief Same as \ref padInitialize, but taking a bitfield of controller IDs directly.
+ * @param[in] pad Pointer to \ref PadState.
+ * @param[in] mask Bitfield of controller IDs (each bit's position indicates a different \ref HidNpadIdType value).
+ */
+void padInitializeWithMask(PadState* pad, u64 mask);
+
+/**
+ * @brief Same as \ref padInitialize, but including every single controller input source.
+ * @param[in] pad Pointer to \ref PadState.
+ * @remark Use this function if you want to accept input from any controller.
+ */
+NX_INLINE void padInitializeAny(PadState* pad) {
+    padInitializeWithMask(pad, PAD_ANY_ID_MASK);
+}
+
+/**
+ * @brief Same as \ref padInitialize, but including \ref HidNpadIdType_No1 and \ref HidNpadIdType_Handheld.
+ * @param[in] pad Pointer to \ref PadState.
+ * @remark Use this function if you just want to accept input for a single-player application.
+ */
+NX_INLINE void padInitializeDefault(PadState* pad) {
+    padInitialize(pad, HidNpadIdType_No1, HidNpadIdType_Handheld);
+}
+
+/**
+ * @brief Updates pad state by reading from the controller input sources specified during initialization.
+ * @param[in] pad Pointer to \ref PadState.
+ */
+void padUpdate(PadState* pad);
+
+/**
+ * @brief Retrieves whether \ref HidNpadIdType_Handheld is an active input source (i.e. it was possible to read from it).
+ * @param[in] pad Pointer to \ref PadState.
+ * @return Boolean value.
+ * @remark \ref padUpdate must have been previously called.
+ */
+NX_CONSTEXPR bool padIsHandheld(const PadState* pad) {
+    return pad->active_handheld;
+}
+
+/**
+ * @brief Retrieves whether the specified controller is an active input source (i.e. it was possible to read from it).
+ * @param[in] pad Pointer to \ref PadState.
+ * @param[in] id ID of the controller input source (see \ref HidNpadIdType)
+ * @return Boolean value.
+ * @remark \ref padUpdate must have been previously called.
+ */
+NX_CONSTEXPR bool padIsNpadActive(const PadState* pad, HidNpadIdType id) {
+    if (id <= HidNpadIdType_No8)
+        return pad->active_id_mask & BIT(id);
+    else if (id == HidNpadIdType_Handheld)
+        return pad->active_handheld;
+    else
+        return false;
+}
+
+/**
+ * @brief Retrieves the set of input styles supported by the selected controller input sources.
+ * @param[in] pad Pointer to \ref PadState.
+ * @return Bitfield of \ref HidNpadStyleTag.
+ * @remark \ref padUpdate must have been previously called.
+ */
+NX_CONSTEXPR u32 padGetStyleSet(const PadState* pad) {
+    return pad->style_set;
+}
+
+/**
+ * @brief Retrieves the set of attributes reported by the system for the selected controller input sources.
+ * @param[in] pad Pointer to \ref PadState.
+ * @return Bitfield of \ref HidNpadAttribute.
+ * @remark \ref padUpdate must have been previously called.
+ */
+NX_CONSTEXPR u32 padGetAttributes(const PadState* pad) {
+    return pad->attributes;
+}
+
+/**
+ * @brief Retrieves whether any of the selected controller input sources is connected.
+ * @param[in] pad Pointer to \ref PadState.
+ * @return Boolean value.
+ * @remark \ref padUpdate must have been previously called.
+ */
+NX_CONSTEXPR bool padIsConnected(const PadState* pad) {
+    return pad->attributes & HidNpadAttribute_IsConnected;
+}
+
+/**
+ * @brief Retrieves the current set of pressed buttons across all selected controller input sources.
+ * @param[in] pad Pointer to \ref PadState.
+ * @return Bitfield of \ref HidNpadButton.
+ * @remark \ref padUpdate must have been previously called.
+ */
+NX_CONSTEXPR u64 padGetButtons(const PadState* pad) {
+    return pad->buttons_cur;
+}
+
+/**
+ * @brief Retrieves the set of buttons that are newly pressed.
+ * @param[in] pad Pointer to \ref PadState.
+ * @return Bitfield of \ref HidNpadButton.
+ * @remark \ref padUpdate must have been previously called.
+ */
+NX_CONSTEXPR u64 padGetButtonsDown(const PadState* pad) {
+    return ~pad->buttons_old & pad->buttons_cur;
+}
+
+/**
+ * @brief Retrieves the set of buttons that are newly released.
+ * @param[in] pad Pointer to \ref PadState.
+ * @return Bitfield of \ref HidNpadButton.
+ * @remark \ref padUpdate must have been previously called.
+ */
+NX_CONSTEXPR u64 padGetButtonsUp(const PadState* pad) {
+    return pad->buttons_old & ~pad->buttons_cur;
+}
+
+/**
+ * @brief Retrieves the position of an analog stick in a controller.
+ * @param[in] pad Pointer to \ref PadState.
+ * @param[in] i ID of the analog stick to read (0=left, 1=right).
+ * @return \ref HidAnalogStickState.
+ * @remark \ref padUpdate must have been previously called.
+ */
+NX_CONSTEXPR HidAnalogStickState padGetStickPos(const PadState* pad, unsigned i) {
+    return pad->sticks[i];
+}
+
+/**
+ * @brief Retrieves the position of an analog trigger in a GameCube controller.
+ * @param[in] pad Pointer to \ref PadState.
+ * @param[in] i ID of the analog trigger to read (0=left, 1=right).
+ * @return Analog trigger position (range is 0 to 0x7fff).
+ * @remark \ref padUpdate must have been previously called.
+ * @remark \ref HidNpadStyleTag_NpadGc must have been previously configured as a supported style in \ref padConfigureInput for GC trigger data to be readable.
+ */
+NX_CONSTEXPR u32 padGetGcTriggerPos(const PadState* pad, unsigned i) {
+    return pad->gc_triggers[i];
+}
+
+/**
+ * @brief Initializes a \ref PadRepeater object with the specified settings.
+ * @param[in] r Pointer to \ref PadRepeater.
+ * @param[in] delay Number of input updates between button presses being first detected and them being considered for repeat.
+ * @param[in] repeat Number of input updates between autogenerated repeat button presses.
+ */
+NX_CONSTEXPR void padRepeaterInitialize(PadRepeater* r, u16 delay, u16 repeat) {
+    r->button_mask = 0;
+    r->counter = 0;
+    r->delay = delay;
+    r->repeat = repeat;
+}
+
+/**
+ * @brief Updates pad repeat state.
+ * @param[in] r Pointer to \ref PadRepeater.
+ * @param[in] button_mask Bitfield of currently pressed \ref HidNpadButton that will be considered for repeat.
+ */
+void padRepeaterUpdate(PadRepeater* r, u64 button_mask);
+
+/**
+ * @brief Retrieves the set of buttons that are being repeated according to the parameters specified in \ref padRepeaterInitialize.
+ * @param[in] r Pointer to \ref PadRepeater.
+ * @return Bitfield of \ref HidNpadButton.
+ * @remark It is suggested to bitwise-OR the return value of this function with that of \ref padGetButtonsDown.
+ */
+NX_CONSTEXPR u64 padRepeaterGetButtons(const PadRepeater* r) {
+    return r->counter == 0 ? r->button_mask : 0;
+}

nx/include/switch/runtime/resolver.h

@@ -0,0 +1,29 @@
+#pragma once
+#include "../types.h"
+
+/// Fetches the last resolver Switch result code of the current thread.
+Result resolverGetLastResult(void);
+
+/// Retrieves a handle used to cancel the next resolver command on the current thread.
+u32 resolverGetCancelHandle(void);
+
+/// Retrieves whether service discovery is enabled for resolver commands on the current thread.
+bool resolverGetEnableServiceDiscovery(void);
+
+/// [5.0.0+] Retrieves whether the DNS cache is used to resolve queries on the current thread (not implemented).
+bool resolverGetEnableDnsCache(void);
+
+/// Enables or disables service discovery for the current thread.
+void resolverSetEnableServiceDiscovery(bool enable);
+
+/// [5.0.0+] Enables or disables the usage of the DNS cache on the current thread (not implemented).
+void resolverSetEnableDnsCache(bool enable);
+
+/// Cancels a previous resolver command (handle obtained with \ref resolverGetCancelHandle prior to calling the command).
+Result resolverCancel(u32 handle);
+
+/// [5.0.0+] Removes a hostname from the DNS cache (not implemented).
+Result resolverRemoveHostnameFromCache(const char* hostname);
+
+/// [5.0.0+] Removes an IP address from the DNS cache (not implemented).
+Result resolverRemoveIpAddressFromCache(u32 ip);

nx/include/switch/runtime/ringcon.h

@@ -0,0 +1,257 @@
+/**
+ * @file ringcon.h
+ * @brief Wrapper for using the Ring-Con attached to a Joy-Con, with hidbus. See also: https://switchbrew.org/wiki/Ring-Con
+ * @author yellows8
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+#include "../services/hidbus.h"
+
+#define RINGCON_CAL_MAGIC -0x3502 // 0xCAFE
+
+/// Whether the output data is valid.
+typedef enum {
+    RingConDataValid_Ok  = 0,                     ///< Valid.
+    RingConDataValid_CRC = 1,                     ///< Bad CRC.
+    RingConDataValid_Cal = 2,                     ///< Only used with \ref ringconReadUserCal. Calibration is needed via \ref ringconUpdateUserCal.
+} RingConDataValid;
+
+typedef enum {
+    RingConErrorFlag_BadUserCalUpdate   = 0,      ///< The output from \ref ringconReadUserCal doesn't match the input used with \ref ringconWriteUserCal, or the \ref RingConDataValid is not ::RingConDataValid_Ok.
+    RingConErrorFlag_BadFlag            = 4,      ///< The output flag from \ref ringconCmdx00020105 when successful is invalid.
+    RingConErrorFlag_BadUserCal         = 5,      ///< BadUserCal
+    RingConErrorFlag_BadManuCal         = 6,      ///< BadManuCal
+} RingConErrorFlag;
+
+/// Ring-Con firmware version.
+typedef struct {
+    u8 fw_main_ver;                               ///< Main firmware version.
+    u8 fw_sub_ver;                                ///< Sub firmware version.
+} RingConFwVersion;
+
+/// Ring-Con manufacturer calibration.
+typedef struct {
+    s16 os_max;                                   ///< (manu_)os_max
+    s16 hk_max;                                   ///< (manu_)hk_max
+    s16 zero_min;                                 ///< (manu_)zero_min
+    s16 zero_max;                                 ///< (manu_)zero_max
+} RingConManuCal;
+
+/// Ring-Con user calibration.
+typedef struct {
+    s16 os_max;                                   ///< (user_)os_max
+    s16 hk_max;                                   ///< (user_)hk_max
+    s16 zero;                                     ///< (user_)zero
+    RingConDataValid data_valid;                  ///< \ref RingConDataValid
+} RingConUserCal;
+
+/// Polling data extracted from \ref HidbusJoyPollingReceivedData.
+typedef struct {
+    s16 data;                                     ///< Sensor state data.
+    u64 sampling_number;                          ///< SamplingNumber
+} RingConPollingData;
+
+/// Ring-Con state object.
+typedef struct {
+    bool bus_initialized;
+    HidbusBusHandle handle;
+    void* workbuf;
+    size_t workbuf_size;
+    u64 polling_last_sampling_number;
+    u32 error_flags;
+
+    u64 id_l, id_h;
+    RingConFwVersion fw_ver;
+    u32 flag;
+    s16 unk_cal;
+    s32 total_push_count;
+
+    RingConManuCal manu_cal;
+    RingConUserCal user_cal;
+} RingCon;
+
+/**
+ * @brief Creates a \ref RingCon object, and handles the various initialization for it.
+ * @param c \ref RingCon
+ * @param[in] id \ref HidNpadIdType. A Ring-Con must be attached to this controller.
+ */
+Result ringconCreate(RingCon *c, HidNpadIdType id);
+
+/**
+ * @brief Close a \ref RingCon.
+ * @param c \ref RingCon
+ */
+void ringconClose(RingCon *c);
+
+/**
+ * @brief Gets the error flags field.
+ * @param c \ref RingCon
+ */
+NX_CONSTEXPR u32 ringconGetErrorFlags(RingCon *c) {
+    return c->error_flags;
+}
+
+/**
+ * @brief Gets the value of an error flag, set by \ref ringconSetErrorFlag.
+ * @param c \ref RingCon
+ * @param[in] flag \ref RingConErrorFlag
+ */
+NX_CONSTEXPR bool ringconGetErrorFlag(RingCon *c, RingConErrorFlag flag) {
+    return (c->error_flags & BIT(flag)) != 0;
+}
+
+/**
+ * @brief Gets the \ref RingConFwVersion previously loaded by \ref ringconCreate.
+ * @param c \ref RingCon
+ * @param[out] out \ref RingConFwVersion
+ */
+NX_CONSTEXPR RingConFwVersion ringconGetFwVersion(RingCon *c) {
+    return c->fw_ver;
+}
+
+/**
+ * @brief Gets the Id previously loaded by \ref ringconCreate.
+ * @param c \ref RingCon
+ * @param[out] id_l Id low.
+ * @param[out] id_h Id high.
+ */
+NX_CONSTEXPR void ringconGetId(RingCon *c, u64 *id_l, u64 *id_h) {
+    *id_l = c->id_l;
+    *id_h = c->id_h;
+}
+
+/**
+ * @brief Gets the unk_cal previously loaded by \ref ringconCreate with \ref ringconReadUnkCal. Only valid when the output flag from \ref ringconCmdx00020105 is valid.
+ * @param c \ref RingCon
+ */
+NX_CONSTEXPR s16 ringconGetUnkCal(RingCon *c) {
+    return c->unk_cal;
+}
+
+/**
+ * @brief Gets the total-push-count previously loaded by \ref ringconCreate.
+ * @param c \ref RingCon
+ * @param[out] out total_push_count
+ */
+NX_CONSTEXPR s32 ringconGetTotalPushCount(RingCon *c) {
+    return c->total_push_count;
+}
+
+/**
+ * @brief Gets the \ref RingConManuCal previously loaded by \ref ringconCreate.
+ * @param c \ref RingCon
+ * @param[out] out \ref RingConManuCal
+ */
+NX_CONSTEXPR void ringconGetManuCal(RingCon *c, RingConManuCal *out) {
+    *out = c->manu_cal;
+}
+
+/**
+ * @brief Gets the \ref RingConUserCal previously loaded by \ref ringconCreate.
+ * @note The Ring-Con UserCal doesn't seem to be calibrated normally?
+ * @param c \ref RingCon
+ * @param[out] out \ref RingConUserCal
+ */
+NX_CONSTEXPR void ringconGetUserCal(RingCon *c, RingConUserCal *out) {
+    *out = c->user_cal;
+}
+
+/**
+ * @brief Updates the \ref RingConUserCal.
+ * @note The input \ref RingConUserCal is used with \ref ringconWriteUserCal, and the output from \ref ringconReadUserCal is verified with the input \ref RingConUserCal. This does not update the \ref RingConUserCal returned by \ref ringconGetUserCal.
+ * @note The Ring-Con UserCal doesn't seem to be calibrated normally?
+ * @param c \ref RingCon
+ * @param[in] cal \ref RingConUserCal
+ */
+Result ringconUpdateUserCal(RingCon *c, RingConUserCal cal);
+
+/**
+ * @brief Reads the \ref RingConFwVersion.
+ * @note This is used internally by \ref ringconCreate. Normally you should use \ref ringconGetFwVersion instead.
+ * @param c \ref RingCon
+ * @param[out] out \ref RingConFwVersion
+ */
+Result ringconReadFwVersion(RingCon *c, RingConFwVersion *out);
+
+/**
+ * @brief Reads the Id.
+ * @note This is used internally by \ref ringconCreate. Normally you should use \ref ringconGetId instead.
+ * @param c \ref RingCon
+ * @param[out] id_l Id low.
+ * @param[out] id_h Id high.
+ */
+Result ringconReadId(RingCon *c, u64 *id_l, u64 *id_h);
+
+/**
+ * @brief Gets the \ref RingConPollingData. Only returns entries which are new since the last time this was called (or if not previously called, all available entries up to count).
+ * @param c \ref RingCon
+ * @param[out] out Output array of \ref RingConPollingData. Entry order is newest -> oldest.
+ * @param[in] count Total size of the out array in entries, max value is 0x9.
+ * @param[out] total_out Total output entries.
+ */
+Result ringconGetPollingData(RingCon *c, RingConPollingData *out, s32 count, s32 *total_out);
+
+/**
+ * @brief Uses cmd 0x00020105.
+ * @note Used internally by \ref ringconCreate.
+ * @param c \ref RingCon
+ * @param[out] out Output value.
+ */
+Result ringconCmdx00020105(RingCon *c, u32 *out);
+
+/**
+ * @brief Reads the \ref RingConManuCal.
+ * @note Used internally by \ref ringconCreate and \ref ringconReadUnkCal.
+ * @param c \ref RingCon
+ * @param[out] out \ref RingConManuCal
+ */
+Result ringconReadManuCal(RingCon *c, RingConManuCal *out);
+
+/**
+ * @brief Gets the unknown value derived from the output of cmd 0x00020504 and \ref ringconReadManuCal.
+ * @note Used internally by \ref ringconCreate.
+ * @param c \ref RingCon
+ * @param[out] out Output value.
+ */
+Result ringconReadUnkCal(RingCon *c, s16 *out);
+
+/**
+ * @brief Reads the \ref RingConUserCal.
+ * @note Used internally by \ref ringconCreate and \ref ringconUpdateUserCal.
+ * @param c \ref RingCon
+ * @param[out] out \ref RingConUserCal
+ */
+Result ringconReadUserCal(RingCon *c, RingConUserCal *out);
+
+/**
+ * @brief Reads the rep-count for Multitask Mode.
+ * @param c \ref RingCon
+ * @param[out] out Output value. Official sw using this clamps the output to range 0-500.
+ * @param[out] data_valid \ref RingConDataValid
+ */
+Result ringconReadRepCount(RingCon *c, s32 *out, RingConDataValid *data_valid);
+
+/**
+ * @brief Reads the total-push-count, for Multitask Mode.
+ * @note Used internally by \ref ringconCreate. Normally \ref ringconGetTotalPushCount should be used instead.
+ * @param c \ref RingCon
+ * @param[out] out Output value.
+ * @param[out] data_valid \ref RingConDataValid
+ */
+Result ringconReadTotalPushCount(RingCon *c, s32 *out, RingConDataValid *data_valid);
+
+/**
+ * @brief This resets the value returned by \ref ringconReadRepCount to 0.
+ * @param c \ref RingCon
+ */
+Result ringconResetRepCount(RingCon *c);
+
+/**
+ * @brief Writes the \ref RingConUserCal.
+ * @note Used internally by \ref ringconUpdateUserCal.
+ * @param c \ref RingCon
+ * @param[in] cal \ref RingConUserCal
+ */
+Result ringconWriteUserCal(RingCon *c, RingConUserCal cal);
+

nx/include/switch/services/acc.h

@@ -6,60 +6,101 @@
  */
 #pragma once
 #include "../types.h"
-#include "sm.h"
+#include "../sf/service.h"
 
 #define ACC_USER_LIST_SIZE 8
 
+typedef enum {
+    AccountServiceType_Application    = 0,  ///< Initializes acc:u0.
+    AccountServiceType_System         = 1,  ///< Initializes acc:u1.
+    AccountServiceType_Administrator  = 2,  ///< Initializes acc:su.
+} AccountServiceType;
+
+/// Profile
 typedef struct {
-    Service  s;
+    Service  s;       ///< IProfile
 } AccountProfile;
 
-typedef struct
-{
-    u32 unk_x0;
-    u32 iconID;                ///< Icon ID. 0 = Mii, the rest are character icon IDs. 
-    u8  iconBackgroundColorID; ///< Profile icon background color ID
-    u8  unk_x9[0x7];
-    u8  miiID[0x10];           ///< Some ID related to the Mii? All zeros when a character icon is used.
+/// Account UserId.
+typedef struct {
+    u64 uid[2];       ///< UserId. All-zero is invalid / Uid not set. See also \ref accountUidIsValid.
+} AccountUid;
+
+/// UserData
+typedef struct {
+    u32 unk_x0;                ///< Unknown.
+    u32 iconID;                ///< Icon ID. 0 = Mii, the rest are character icon IDs.
+    u8 iconBackgroundColorID;  ///< Profile icon background color ID
+    u8 unk_x9[0x7];            ///< Unknown.
+    u8 miiID[0x10];            ///< Some ID related to the Mii? All zeros when a character icon is used.
     u8 unk_x20[0x60];          ///< Usually zeros?
-} PACKED AccountUserData;
+} AccountUserData;
 
-typedef struct
-{
-    u128 userID;
+/// ProfileBase
+typedef struct {
+    AccountUid uid;        ///< \ref AccountUid
     u64 lastEditTimestamp; ///< POSIX UTC timestamp, for the last account edit.
-    char username[0x20];   ///< UTF-8 Username.
-} PACKED AccountProfileBase;
+    char nickname[0x20];   ///< UTF-8 Nickname.
+} AccountProfileBase;
 
-Result accountInitialize(void);
+/// NetworkServiceAccountId
+typedef struct {
+    u64 id;                ///< Id.
+} AccountNetworkServiceAccountId;
+
+/// Initialize account.
+Result accountInitialize(AccountServiceType service_type);
+
+/// Exit account.
 void accountExit(void);
-Service* accountGetService(void);
 
-/// Get the total number of user profiles
+/// Gets the Service object for the actual account service session.
+Service* accountGetServiceSession(void);
+
+/// Get the total number of user profiles.
 Result accountGetUserCount(s32* user_count);
 
 /**
- * @brief Get a list of all user IDs. The returned list will never be larger than ACC_USER_LIST_SIZE.
- * @param userIDs Pointer to array of user IDs.
- * @param max_userIDs Maximum number of user IDs to return.
- * @param actual_total The actual total number of user IDs found.
+ * @brief Get a list of all userIds. The returned list will never be larger than ACC_USER_LIST_SIZE.
+ * @param uids Pointer to array of userIds.
+ * @param max_uids Maximum number of userIds to return.
+ * @param actual_total The actual total number of userIds found.
  */
-Result accountListAllUsers(u128* userIDs, size_t max_userIDs, size_t *actual_total);
+Result accountListAllUsers(AccountUid* uids, s32 max_uids, s32 *actual_total);
 
-/// Get the userID for the currently active user. The output userID is only valid when the output account_selected==1, otherwise no user is currently selected.
-/// An user is only selected when the user-account selection applet was used to select an user at least once before.
-Result accountGetActiveUser(u128 *userID, bool *account_selected);
+/// Get the userId for the last opened user.
+Result accountGetLastOpenedUser(AccountUid *uid);
 
-/// Get an AccountProfile for the specified userID.
-Result accountGetProfile(AccountProfile* out, u128 userID);
+/// Get an AccountProfile for the specified userId.
+Result accountGetProfile(AccountProfile* out, AccountUid uid);
+
+/// IsUserRegistrationRequestPermitted
+Result accountIsUserRegistrationRequestPermitted(bool *out);
+
+/// TrySelectUserWithoutInteraction
+Result accountTrySelectUserWithoutInteraction(AccountUid *uid, bool is_network_service_account_required);
+
+/// Close the AccountProfile.
+void accountProfileClose(AccountProfile* profile);
 
 /// Get \ref AccountUserData and \ref AccountProfileBase for the specified profile, userdata is optional (can be NULL).
 Result accountProfileGet(AccountProfile* profile, AccountUserData* userdata, AccountProfileBase* profilebase);
 
 /// Get the icon image size.
-Result accountProfileGetImageSize(AccountProfile* profile, size_t* image_size);
+Result accountProfileGetImageSize(AccountProfile* profile, u32* image_size);
 
 /// Load the JPEG profile icon, valid for both Miis and character icons. The output image_size is the same as the one from \ref accountProfileGetImageSize.
-Result accountProfileLoadImage(AccountProfile* profile, void* buf, size_t len, size_t* image_size);
+Result accountProfileLoadImage(AccountProfile* profile, void* buf, size_t len, u32* image_size);
+
+/// Gets the userId which was selected by the profile-selector applet (if any), prior to launching the currently running Application.
+/// This gets the cached PreselectedUser loaded during accountInitialize, when PreselectedUser is available.
+Result accountGetPreselectedUser(AccountUid *uid);
+
+/**
+ * @brief Checks whether the specified \ref AccountUid is valid/set (non-zero).
+ * @param[in] Uid \ref AccountUid
+ */
+NX_CONSTEXPR bool accountUidIsValid(const AccountUid *Uid) {
+    return Uid->uid[0]!=0 || Uid->uid[1]!=0;
+}
 
-void accountProfileClose(AccountProfile* profile);

nx/include/switch/services/apm.h

@@ -1,16 +1,55 @@
 /**
  * @file apm.h
- * @brief Performance management (apm) service IPC wrapper.
+ * @brief Performance management (apm) service IPC wrapper. This is used internally by applet with __nx_applet_PerformanceConfiguration, however if you prefer non-init/exit can be used manually. See also: https://switchbrew.org/wiki/PTM_services#apm:am
  * @author yellows8
  * @copyright libnx Authors
  */
 #pragma once
 #include "../types.h"
+#include "../sf/service.h"
 
-/// These are used internally by applet.
+/// PerformanceMode
+typedef enum {
+    ApmPerformanceMode_Invalid = -1,  ///< Invalid
+    ApmPerformanceMode_Normal  = 0,   ///< Normal
+    ApmPerformanceMode_Boost   = 1,   ///< Boost
+} ApmPerformanceMode;
 
+/// CpuBoostMode. With \ref appletSetCpuBoostMode, only values 0/1 are available. This allows using higher clock rates.
+typedef enum {
+    ApmCpuBoostMode_Normal   = 0,  ///< Default, boost-mode disabled.
+    ApmCpuBoostMode_FastLoad = 1,  ///< Boost CPU. Additionally, throttle GPU to minimum. Use performance configurations 0x92220009 (Docked) and 0x9222000A (Handheld), or 0x9222000B and 0x9222000C.
+    ApmCpuBoostMode_Type2    = 2,  ///< Conserve power. Only throttle GPU to minimum. Use performance configurations 0x9222000B and 0x9222000C.
+} ApmCpuBoostMode;
+
+/// Initialize apm. Used automatically by \ref appletInitialize with AppletType_Application.
 Result apmInitialize(void);
+
+/// Exit apm. Used automatically by \ref appletExit with AppletType_Application.
 void apmExit(void);
 
-Result apmSetPerformanceConfiguration(u32 PerformanceMode, u32 PerformanceConfiguration);
-Result apmGetPerformanceConfiguration(u32 PerformanceMode, u32 *PerformanceConfiguration);
+/// Gets the Service object for the actual apm service session.
+Service* apmGetServiceSession(void);
+
+/// Gets the Service object for ISession.
+Service* apmGetServiceSession_Session(void);
+
+/**
+ * @brief Gets the current ApmPerformanceMode.
+ * @param[out] out_performanceMode ApmPerformanceMode
+ */
+Result apmGetPerformanceMode(ApmPerformanceMode* out_performanceMode);
+
+/**
+ * @brief Sets the PerformanceConfiguration for the specified PerformanceMode.
+ * @param[in] PerformanceMode \ref ApmPerformanceMode
+ * @param[in] PerformanceConfiguration PerformanceConfiguration
+ */
+Result apmSetPerformanceConfiguration(ApmPerformanceMode PerformanceMode, u32 PerformanceConfiguration);
+
+/**
+ * @brief Gets the PerformanceConfiguration for the specified PerformanceMode.
+ * @param[in] PerformanceMode \ref ApmPerformanceMode
+ * @param[out] PerformanceConfiguration PerformanceConfiguration
+ */
+Result apmGetPerformanceConfiguration(ApmPerformanceMode PerformanceMode, u32 *PerformanceConfiguration);

nx/include/switch/services/async.h

@@ -0,0 +1,115 @@
+/**
+ * @file async.h
+ * @brief NS/NIM IAsync* IPC wrapper.
+ * @author yellows8
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+#include "../sf/service.h"
+#include "../applets/error.h"
+#include "../kernel/event.h"
+
+/// AsyncValue
+typedef struct {
+    Service s;      ///< IAsyncValue
+    Event event;    ///< Event with autoclear=false.
+} AsyncValue;
+
+/// AsyncResult
+typedef struct {
+    Service s;      ///< IAsyncResult
+    Event event;    ///< Event with autoclear=false.
+} AsyncResult;
+
+///@name IAsyncValue
+///@{
+
+/**
+ * @brief Close a \ref AsyncValue.
+ * @note When the object is initialized, this uses \ref asyncValueCancel then \ref asyncValueWait with timeout=UINT64_MAX.
+ * @param a \ref AsyncValue
+ */
+void asyncValueClose(AsyncValue *a);
+
+/**
+ * @brief Waits for the async operation to finish using the specified timeout.
+ * @param a \ref AsyncValue
+ * @param[in] timeout Timeout in nanoseconds. UINT64_MAX for no timeout.
+ */
+Result asyncValueWait(AsyncValue *a, u64 timeout);
+
+/**
+ * @brief Gets the value size.
+ * @param a \ref AsyncValue
+ * @param[out] size Output size.
+ */
+Result asyncValueGetSize(AsyncValue *a, u64 *size);
+
+/**
+ * @brief Gets the value.
+ * @note Prior to using the cmd, this uses \ref asyncResultWait with timeout=UINT64_MAX.
+ * @param a \ref AsyncValue
+ * @param[out] buffer Output buffer.
+ * @param[in] size Output buffer size.
+ */
+Result asyncValueGet(AsyncValue *a, void* buffer, size_t size);
+
+/**
+ * @brief Cancels the async operation.
+ * @note Used automatically by \ref asyncValueClose.
+ * @param a \ref AsyncValue
+ */
+Result asyncValueCancel(AsyncValue *a);
+
+/**
+ * @brief Gets the \ref ErrorContext.
+ * @note Only available on [4.0.0+].
+ * @param a \ref AsyncValue
+ * @param[out] context \ref ErrorContext
+ */
+Result asyncValueGetErrorContext(AsyncValue *a, ErrorContext *context);
+
+///@}
+
+///@name IAsyncResult
+///@{
+
+/**
+ * @brief Close a \ref AsyncResult.
+ * @note When the object is initialized, this uses \ref asyncResultCancel then \ref asyncResultWait with timeout=UINT64_MAX.
+ * @param a \ref AsyncResult
+ */
+void asyncResultClose(AsyncResult *a);
+
+/**
+ * @brief Waits for the async operation to finish using the specified timeout.
+ * @param a \ref AsyncResult
+ * @param[in] timeout Timeout in nanoseconds. UINT64_MAX for no timeout.
+ */
+Result asyncResultWait(AsyncResult *a, u64 timeout);
+
+/**
+ * @brief Gets the Result.
+ * @note Prior to using the cmd, this uses \ref asyncResultWait with timeout=UINT64_MAX.
+ * @param a \ref AsyncResult
+ */
+Result asyncResultGet(AsyncResult *a);
+
+/**
+ * @brief Cancels the async operation.
+ * @note Used automatically by \ref asyncResultClose.
+ * @param a \ref AsyncResult
+ */
+Result asyncResultCancel(AsyncResult *a);
+
+/**
+ * @brief Gets the \ref ErrorContext.
+ * @note Only available on [4.0.0+].
+ * @param a \ref AsyncResult
+ * @param[out] context \ref ErrorContext
+ */
+Result asyncResultGetErrorContext(AsyncResult *a, ErrorContext *context);
+
+///@}
+