coreinit/memblockheap: Add padding bytes to MEMBlockHeap struct

* add OSGetConsoleType, and MCP_GetSystemMode

this adds in two functions that were an exported symbol in the system
libraries, but not included in any headers. these are useful for doing
two things:

- determine what kind of console you're running on (for users who want
  to know if they're running a CAT-DEV, CAT-R, Kiosk Unit, Retail
  Wii-U's, etc.)
- determine if the wii-u is currently running in production/development
  mode. this shouldn't be too useful for many users, as not too much
  changes besides certain extra libraries/etc. are loaded in memory.
  however, users may want to lock things behind development mode as dev
  mode can only be normally enabled when there's extra memory.

* add new comment to mask

.clang-format

@@ -0,0 +1,90 @@
+---
+BasedOnStyle: LLVM
+AccessModifierOffset: -3
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: AcrossEmptyLinesAndComments
+AlignConsecutiveMacros: AcrossEmptyLinesAndComments
+AlignOperands: Align
+AllowAllArgumentsOnNextLine: false
+AllowAllConstructorInitializersOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: Always
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Always
+AllowShortLambdasOnASingleLine: All
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterReturnType: All
+AlwaysBreakTemplateDeclarations: Yes
+AttributeMacros:
+  - asm
+  - WUT_FORMAT_PRINTF
+BinPackParameters: false
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterCaseLabel: false
+  AfterClass: true
+  AfterControlStatement: Never
+  AfterEnum: true
+  AfterExternBlock: false
+  AfterStruct: true
+  AfterFunction: true
+  AfterNamespace: true
+  AfterUnion: true
+  BeforeCatch: false
+  BeforeElse: false
+  IndentBraces: false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: true
+BreakBeforeBinaryOperators: None
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: AfterColon
+BreakInheritanceList: BeforeColon
+ColumnLimit: 0
+CompactNamespaces: false
+ConstructorInitializerIndentWidth: 3
+ContinuationIndentWidth: 3
+FixNamespaceComments: true
+IncludeBlocks:   Preserve
+IncludeCategories:
+  # Include wut headers first
+  - Regex:           '^[<|"]wut'
+    Priority:        1
+  - Regex:           '^<'
+    Priority:        2
+  - Regex:           '^"'
+    Priority:        3
+IndentAccessModifiers: false
+IndentCaseLabels: true
+IndentPPDirectives: None
+IndentWidth: 3
+KeepEmptyLinesAtTheStartOfBlocks: true
+MaxEmptyLinesToKeep: 2
+NamespaceIndentation: None
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PackConstructorInitializers: BinPack
+PointerAlignment: Right
+ReflowComments: false
+SeparateDefinitionBlocks: Leave
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles: false
+SpacesInCStyleCastParentheses: false
+SpacesInContainerLiterals: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+TabWidth: 4
+TypenameMacros:
+  - BOOL
+  - RPLWRAP
+UseTab: Never

.github/workflows/clang-format-diff.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+#
+# ===- clang-format-diff.py - ClangFormat Diff Reformatter ----*- python -*--===#
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+#
+# ===------------------------------------------------------------------------===#
+
+"""
+This script reads input from a unified diff and reformats all the changed
+lines. This is useful to reformat all the lines touched by a specific patch.
+Example usage for git/svn users:
+
+  git diff -U0 --no-color --relative HEAD^ | {clang_format_diff} -p1 -i
+  svn diff --diff-cmd=diff -x-U0 | {clang_format_diff} -i
+
+It should be noted that the filename contained in the diff is used unmodified
+to determine the source file to update. Users calling this script directly
+should be careful to ensure that the path in the diff is correct relative to the
+current working directory.
+"""
+from __future__ import absolute_import, division, print_function
+
+import argparse
+import difflib
+import re
+import subprocess
+import sys
+
+if sys.version_info.major >= 3:
+    from io import StringIO
+else:
+    from io import BytesIO as StringIO
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description=__doc__.format(clang_format_diff="%(prog)s"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "-i",
+        action="store_true",
+        default=False,
+        help="apply edits to files instead of displaying a diff",
+    )
+    parser.add_argument(
+        "-p",
+        metavar="NUM",
+        default=0,
+        help="strip the smallest prefix containing P slashes",
+    )
+    parser.add_argument(
+        "-regex",
+        metavar="PATTERN",
+        default=None,
+        help="custom pattern selecting file paths to reformat "
+        "(case sensitive, overrides -iregex)",
+    )
+    parser.add_argument(
+        "-iregex",
+        metavar="PATTERN",
+        default=r".*\.(?:cpp|cc|c\+\+|cxx|cppm|ccm|cxxm|c\+\+m|c|cl|h|hh|hpp"
+        r"|hxx|m|mm|inc|js|ts|proto|protodevel|java|cs|json|s?vh?)",
+        help="custom pattern selecting file paths to reformat "
+        "(case insensitive, overridden by -regex)",
+    )
+    parser.add_argument(
+        "-sort-includes",
+        action="store_true",
+        default=False,
+        help="let clang-format sort include blocks",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="be more verbose, ineffective without -i",
+    )
+    parser.add_argument(
+        "-style",
+        help="formatting style to apply (LLVM, GNU, Google, Chromium, "
+        "Microsoft, Mozilla, WebKit)",
+    )
+    parser.add_argument(
+        "-fallback-style",
+        help="The name of the predefined style used as a"
+        "fallback in case clang-format is invoked with"
+        "-style=file, but can not find the .clang-format"
+        "file to use.",
+    )
+    parser.add_argument(
+        "-binary",
+        default="clang-format",
+        help="location of binary to use for clang-format",
+    )
+    args = parser.parse_args()
+
+    # Extract changed lines for each file.
+    filename = None
+    lines_by_file = {}
+    for line in sys.stdin:
+        match = re.search(r"^\+\+\+\ (.*?/){%s}(\S*)" % args.p, line)
+        if match:
+            filename = match.group(2)
+        if filename is None:
+            continue
+
+        if args.regex is not None:
+            if not re.match("^%s$" % args.regex, filename):
+                continue
+        else:
+            if not re.match("^%s$" % args.iregex, filename, re.IGNORECASE):
+                continue
+
+        match = re.search(r"^@@.*\+(\d+)(?:,(\d+))?", line)
+        if match:
+            start_line = int(match.group(1))
+            line_count = 1
+            if match.group(2):
+                line_count = int(match.group(2))
+                # The input is something like
+                #
+                # @@ -1, +0,0 @@
+                #
+                # which means no lines were added.
+                if line_count == 0:
+                    continue
+            # Also format lines range if line_count is 0 in case of deleting
+            # surrounding statements.
+            end_line = start_line
+            if line_count != 0:
+                end_line += line_count - 1
+            lines_by_file.setdefault(filename, []).extend(
+                ["--lines", str(start_line) + ":" + str(end_line)]
+            )
+
+    # Reformat files containing changes in place.
+    has_diff = False
+    for filename, lines in lines_by_file.items():
+        if args.i and args.verbose:
+            print("Formatting {}".format(filename))
+        command = [args.binary, filename]
+        if args.i:
+            command.append("-i")
+        if args.sort_includes:
+            command.append("--sort-includes")
+        command.extend(lines)
+        if args.style:
+            command.extend(["--style", args.style])
+        if args.fallback_style:
+            command.extend(["--fallback-style", args.fallback_style])
+
+        try:
+            p = subprocess.Popen(
+                command,
+                stdout=subprocess.PIPE,
+                stderr=None,
+                stdin=subprocess.PIPE,
+                universal_newlines=True,
+            )
+        except OSError as e:
+            # Give the user more context when clang-format isn't
+            # found/isn't executable, etc.
+            raise RuntimeError(
+                'Failed to run "%s" - %s"' % (" ".join(command), e.strerror)
+            )
+
+        stdout, _stderr = p.communicate()
+        if p.returncode != 0:
+            return p.returncode
+
+        if not args.i:
+            with open(filename) as f:
+                code = f.readlines()
+            formatted_code = StringIO(stdout).readlines()
+            diff = difflib.unified_diff(
+                code,
+                formatted_code,
+                filename,
+                filename,
+                "(before formatting)",
+                "(after formatting)",
+            )
+            diff_string = "".join(diff)
+            if len(diff_string) > 0:
+                has_diff = True
+                sys.stdout.write(diff_string)
+
+    if has_diff:
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

.github/workflows/doc.yml

@@ -4,23 +4,32 @@ on:
   push:
     tags:
       - '*'
+  workflow_dispatch:
 
 jobs:
   doc:
     name: Deploy documentation
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
 
     steps:
 
     - name: Checkout the Git repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
+
+    - name: Fetch tags
+      run: |
+        git fetch --tags
+
+    - name: Get current tag
+      id: vars
+      run: echo "tag=`git tag --sort=-version:refname | head -n 1`" >> "$GITHUB_OUTPUT"
 
     - name: Generate Documentation
       run: |
         sudo apt-get update
         sudo apt-get install -y cmake doxygen doxygen-latex graphviz
         cd docs
-        sudo cmake .
+        sudo env WUT_VERSION=${{ steps.vars.outputs.tag }} cmake .
         doxygen Doxyfile.docs >/dev/null
 
     - name: Deploy to GitHub Pages

.github/workflows/format-check.yml

@@ -0,0 +1,47 @@
+name: Formatting check
+
+on: [pull_request]
+
+jobs:
+  formatting-check:
+    name: Formatting check
+    runs-on: ubuntu-24.04
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        # To get a diff from the PR we need to fetch 2 commits.
+        # The checkout action will create a merge commit as {{ github.sha }}.
+        fetch-depth: 2
+
+    - name: Install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -yqq clang-format-18
+
+    - name: Format check
+      id: format-check
+      run: |
+        git diff -U0 --no-color ${{ github.sha }}^ -- '*.cpp' '*.c' '*.h' '*.hpp' |
+          ./.github/workflows/clang-format-diff.py -p1 -binary clang-format-18 > clang-format.patch || true
+
+        # Check if patch is not empty
+        if [ -s clang-format.patch ]; then
+          echo "###############################################################"
+          echo "# Format checks failed!"
+          echo "# A patch has been uploaded as an artifact and is shown below."
+          echo "###############################################################"
+
+          # Show patch
+          cat clang-format.patch
+
+          exit 1
+        fi
+
+    - name: Upload format fixes patch 
+      uses: actions/upload-artifact@v4
+      if: ${{ failure() && steps.format-check.outcome == 'failure' }}
+      with:
+        name: clang-format.patch
+        path: clang-format.patch
+        if-no-files-found: ignore

CHANGELOG.md

@@ -1,3 +1,112 @@
+#### wut 1.7.0
+
+###### New features / improvements
+* nn/dlp: Add initial headers by @DaniElectra in https://github.com/devkitPro/wut/pull/389
+* nn/dlp: Fix Initialize functions on ServerPrivate by @DaniElectra in https://github.com/devkitPro/wut/pull/390
+* nn_ccr: Add `CCRSysSetCurrentLCDMode` and `CCRSysGetCurrentLCDMode` by @Maschell in https://github.com/devkitPro/wut/pull/393
+* nsysccr/cdc: Add CCRCDCSysGetInfo by @GaryOderNichts in https://github.com/devkitPro/wut/pull/398* nn_acp: Add ACPRemoveSaveDir* by @Andrew1Hawes in https://github.com/devkitPro/wut/pull/394
+* nn_acp: Add various save related functions by @Maschell in https://github.com/devkitPro/wut/pull/396
+* Add HDMI CEC functions by @GaryOderNichts in https://github.com/devkitPro/wut/pull/397
+* Added `OSSetPerformanceMonitor()`. by @dkosmari in https://github.com/devkitPro/wut/pull/400
+
+###### Fixes and corrections
+* coreinit/screen: Swap row and column parameters in OSScreenPutFontEx by @capitalistspz in https://github.com/devkitPro/wut/pull/391
+* camera: corrections and comments by @capitalistspz in https://github.com/devkitPro/wut/pull/392
+* nn_idb: Fix copy headers, fix nn::idb::IDBReader::Initialize by @Maschell in https://github.com/devkitPro/wut/pull/395
+* camera: event argument correction by @capitalistspz in https://github.com/devkitPro/wut/pull/399
+
+## New Contributors
+* @dkosmari made their first contribution in https://github.com/devkitPro/wut/pull/400
+
+#### wut 1.6.0
+
+###### New features / improvements
+* nn_idb: Implement icon database reading by @Maschell in https://github.com/devkitPro/wut/pull/357
+* nn_idb: move include into libraries directory by @Maschell in https://github.com/devkitPro/wut/pull/365
+* wut_types: Implement more operators for `WUT_ENUM_BITMASK_TYPE` by @GaryOderNichts in https://github.com/devkitPro/wut/pull/369
+* whb/gfx: Use 4:3 TV buffers on 4:3 TVs by @jranderia3 in https://github.com/devkitPro/wut/pull/383
+
+###### Breaking changes
+* padscore: rename `nunchuck` -> `nunchuk` in https://github.com/devkitPro/wut/pull/348
+
+###### CafeOS related changes
+* More nn_ccr and nsysccr struct/enum fixes by @Maschell in https://github.com/devkitPro/wut/pull/361
+* Add functions to control the Eco mode by @Maschell in https://github.com/devkitPro/wut/pull/363
+* nn_sl: Fix wrong parameters for nn::sl::LaunchInfoDatabase::Unregister by @Maschell in https://github.com/devkitPro/wut/pull/362
+* sysapp: Add all possible "jumpTo" targets for SysAppSettingsArgs by @Maschell in https://github.com/devkitPro/wut/pull/366
+* nn_ccr: Add CCRSysSetInitBootFlag and CCRSysInitializeSettings, add CCRCDCUicConfigIdEnum values by @Maschell in https://github.com/devkitPro/wut/pull/364
+* padscore: Add more functions and types in https://github.com/devkitPro/wut/pull/348
+* nsysccr/cdc: Add language and ext update functions by @GaryOderNichts in https://github.com/devkitPro/wut/pull/368
+* coreinit: Add __OSPhysicalToEffectiveCached and __OSPhysicalToEffectiveUncached by @Maschell in https://github.com/devkitPro/wut/pull/367
+* coreinit: Add "SavedFrame" related functions by @Maschell in https://github.com/devkitPro/wut/pull/374
+* nn_acp: Add ACPGetTitleMetaDir and ACPGetTitleMetaDirByTitleListType by @Maschell in https://github.com/devkitPro/wut/pull/375
+* coreinit: Add __FSAShimDecodeIosErrorToFsaStatus by @Maschell in https://github.com/devkitPro/wut/pull/378
+* coreinit: add stopwatch.h and stopwatchatomic.h by @capitalistspz in https://github.com/devkitPro/wut/pull/370
+* nn_ccr: Add CCRSysCaffeineBootCheckAbort; nsysccr: fix quick start menu value in CCRCDCDrcStateEnum by @Maschell in https://github.com/devkitPro/wut/pull/372
+* gx2: add GX2GetMainCoreId by @Maschell in https://github.com/devkitPro/wut/pull/380
+* vpad: Add VPADGetButtonProcMode by @Maschell in https://github.com/devkitPro/wut/pull/376
+* sndcore2: Update AXTransitionAudioBuffer struct by @Maschell in https://github.com/devkitPro/wut/pull/373
+* coreinit: Fix wrong/duplicate OSGetCodegenVirtAddrRange declaration, formatting by @Maschell in https://github.com/devkitPro/wut/pull/371
+* avm: Add some missing DRC functions by @Maschell in https://github.com/devkitPro/wut/pull/379
+* nsysccr: Add CCRCDCRegister*AttachCallback functions by @Maschell in https://github.com/devkitPro/wut/pull/377
+* gx2: Add GX2AllocateTilingApertureEx and GX2FreeTilingAperture by @GaryOderNichts in https://github.com/devkitPro/wut/pull/381
+* nsysnet/netconfig: Add SOGetProxyConfig by @GaryOderNichts in https://github.com/devkitPro/wut/pull/382
+* gx2: Add GX2GetSystemTVAspectRatio by @GaryOderNichts in https://github.com/devkitPro/wut/pull/384
+* nsysccr/cdc: Update CCRCDCDrcStateEnum with test menu names by @GaryOderNichts in https://github.com/devkitPro/wut/pull/386
+* More DRX definitions by @team-orangeBlue in https://github.com/devkitPro/wut/pull/385
+* nn/uds: Add initial headers by @DaniElectra in https://github.com/devkitPro/wut/pull/387
+
+#### wut 1.5.0
+
+###### New features / improvements
+* wutnewlib: implement abort, assert and assert_func by @Maschell in https://github.com/devkitPro/wut/pull/337 and updated for devkitPPC r45.1 in https://github.com/devkitPro/wut/pull/359
+
+###### Bug fixes
+* wutmalloc: make sure to set errno properly on error by @Maschell in https://github.com/devkitPro/wut/pull/347
+
+###### CafeOS related changes
+* Add missing language/region values to nn::erreula and nn::swkbd by @Maschell in https://github.com/devkitPro/wut/pull/336
+* nn_nets2: Add somemopt by @GaryOderNichts in https://github.com/devkitPro/wut/pull/338
+* coreinit/im: Add IM_SetDeviceState and missing `IMEvent`s by @GaryOderNichts in https://github.com/devkitPro/wut/pull/343
+* Add AVM and TVE headers, functions and enums by @Andrew1Hawes in https://github.com/devkitPro/wut/pull/345
+* nn/hpad: Add initial headers by @GaryOderNichts in https://github.com/devkitPro/wut/pull/344
+* vpad: Fix documentation for VPADRead return value by @GaryOderNichts in https://github.com/devkitPro/wut/pull/346
+* nn/temp: Fix TEMPTargetPreference by @GaryOderNichts in https://github.com/devkitPro/wut/pull/349
+* coreinit/mcp: Fix MCPAppType for DRC and DRH by @GaryOderNichts in https://github.com/devkitPro/wut/pull/350
+* nsysccr/cdc: Add CCRCDCPerSetUicConfig by @GaryOderNichts in https://github.com/devkitPro/wut/pull/351
+* nsysccr/cdc: Add software functions by @GaryOderNichts in https://github.com/devkitPro/wut/pull/353
+* nn_ccr/sys: Add fw update functions by @GaryOderNichts in https://github.com/devkitPro/wut/pull/355
+* padscore: Add missing functions for 7-controller mode by @GaryOderNichts in https://github.com/devkitPro/wut/pull/352
+* nsysccr/cdc: Implement CCRCDCSysSetDrhState by @Maschell in https://github.com/devkitPro/wut/pull/356
+* nn/sl: Implement more functions/classes by @Maschell in https://github.com/devkitPro/wut/pull/354
+* coreinit: Add MEMCheckExpHeap and MEMCheckHeap by @Maschell in https://github.com/devkitPro/wut/pull/358
+
+
+#### wut 1.4.0
+
+## What's Changed
+* nfc: Add initial header by @GaryOderNichts in https://github.com/devkitPro/wut/pull/321
+* nsysccr/cdc: Add CCRCDCWowlWakeDrc and CCRCDCWakeStateEnum by @Andrew1Hawes in https://github.com/devkitPro/wut/pull/320
+* Add NTAG by @GaryOderNichts in https://github.com/devkitPro/wut/pull/326
+* Add system time update functions by @GaryOderNichts in https://github.com/devkitPro/wut/pull/328
+* Update camera.h by @Fangal-Airbag in https://github.com/devkitPro/wut/pull/329
+* Add missing GX2 enum values by @GaryOderNichts in https://github.com/devkitPro/wut/pull/327
+* Add missing optnames and multicast support by @GaryOderNichts in https://github.com/devkitPro/wut/pull/331
+* procui: Fix ProcUIInForeground and ProcUIIsRunning comments by @Andrew1Hawes in https://github.com/devkitPro/wut/pull/330
+* Finalize compile commands by @thearst3rd in https://github.com/devkitPro/wut/pull/332
+
+#### wut 1.3.2
+
+* Implement wut_set_thread_specific/wut_get_thread_specific as weak functions by @Maschell in https://github.com/devkitPro/wut/pull/324
+* wutdevoptab: Add support for opening files with more flag combinations by @Maschell in https://github.com/devkitPro/wut/pull/322
+
+#### wut 1.3.1
+
+* wutmalloc: Always align allocated memory to 0x40 to match newlib behaviour by @Maschell in https://github.com/devkitPro/wut/pull/316
+* devoptab_fsa: use c++ headers by @WinterMute in https://github.com/devkitPro/wut/pull/317
+* Implement __syscall_getreent by @GaryOderNichts in https://github.com/devkitPro/wut/pull/318
+* coreinit: Add some missing field to the OSThread struct by @Maschell in https://github.com/devkitPro/wut/pull/319
+
 #### wut 1.3.0
 
 ###### Important changes

Makefile

@@ -2,10 +2,6 @@
 TOPDIR ?= $(CURDIR)
 include $(TOPDIR)/share/wut_rules
 
-export WUT_MAJOR	:=	1
-export WUT_MINOR	:=	3
-export WUT_PATCH	:=	0
-
 VERSION	:=	$(WUT_MAJOR).$(WUT_MINOR).$(WUT_PATCH)
 
 #---------------------------------------------------------------------------------
@@ -20,7 +16,6 @@ TARGET		:=	wut
 SOURCES		:=	cafe \
 				libraries/wutcrt \
 				libraries/wutnewlib \
-				libraries/wutstdc++ \
 				libraries/wutmalloc \
 				libraries/wutdevoptab \
 				libraries/wutsocket \
@@ -29,12 +24,15 @@ SOURCES		:=	cafe \
 				libraries/libgfd/src \
 				libraries/libirc/src \
 				libraries/nn_erreula \
+				libraries/nn_sl \
+				libraries/nn_idb/src \
 				libraries/nn_swkbd
 DATA		:=	data
 INCLUDES	:=	include \
 				libraries/libwhb/include \
 				libraries/libgfd/include \
-				libraries/libirc/include
+				libraries/libirc/include \
+				libraries/nn_idb/include 
 
 #---------------------------------------------------------------------------------
 # options for code generation
@@ -102,21 +100,13 @@ export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
 #---------------------------------------------------------------------------------
 all: lib/libwut.a lib/libwutd.a
 
-dist-bin: all
+install: all
-	@tar --exclude=*~ -cjf wut-$(VERSION).tar.bz2 \
+	@mkdir -p $(DESTDIR)$(DEVKITPRO)/wut
-		include lib share \
+	@cp -frv include lib share $(DESTDIR)$(DEVKITPRO)/wut
-		-C libraries/libwhb include \
+	@cp -frv libraries/libwhb/include $(DESTDIR)$(DEVKITPRO)/wut
-		-C ../libgfd include \
+	@cp -frv libraries/nn_idb/include $(DESTDIR)$(DEVKITPRO)/wut
-		-C ../libirc include
+	@cp -frv libraries/libgfd/include $(DESTDIR)$(DEVKITPRO)/wut
-
+	@cp -frv libraries/libirc/include $(DESTDIR)$(DEVKITPRO)/wut
-dist-src:
-	@tar --exclude=*~ -cjf wut-src-$(VERSION).tar.bz2 cafe include libraries share Makefile
-
-dist: dist-src dist-bin
-
-install: dist-bin
-	mkdir -p $(DESTDIR)$(DEVKITPRO)/wut
-	bzip2 -cd wut-$(VERSION).tar.bz2 | tar -xf - -C $(DESTDIR)$(DEVKITPRO)/wut
 
 lib:
 	@[ -d $@ ] || mkdir -p $@

cafe/nn_acp.def

@@ -77,7 +77,6 @@ ACPGetTitleMetaXmlByTitleListType
 ACPGetTitleSaveDir
 ACPGetTitleSaveDirEx
 ACPGetTitleSaveDirExWithoutMetaCheck
-ACPGetTitleSaveMetaXml
 ACPGetWoodTin
 ACPImportSaveDataFromBuffer
 ACPImportSaveDirOfAccountWithEncryption
@@ -161,3 +160,4 @@ WaitExternalStorage__Q2_2nn3acpFv
 
 :TEXT_WRAP
 ACPGetTitleMetaXml
+ACPGetTitleSaveMetaXml

cafe/nn_hpad.def

@@ -9,7 +9,6 @@ BETA_DEBUG_SET_DUMP_MODE
 HPADControlMotor
 HPADGetGGGGStatus
 HPADInit
-HPADRead
 HPADRecalibrate
 HPADResetDevice
 HPADSetConnectCallback
@@ -17,3 +16,6 @@ HPADSetGgggConnectCallback
 HPADSetPowerSupplyCallback
 HPADSetSamplingCallback
 HPADShutdown
+
+:TEXT_WRAP
+HPADRead

cafe/nn_nets2.def

@@ -11,4 +11,6 @@ icmp_close_handle
 icmp_create_handle
 icmp_last_code_type
 icmp_ping
+
+:TEXT_WRAP
 somemopt

cafe/nsysnet.def

@@ -123,6 +123,7 @@ inet_ntoa
 inet_ntoa_r
 ntohl
 ntohs
+set_multicast_state
 socket_lib_finish
 socket_lib_init
 
@@ -162,7 +163,6 @@ send
 sendto
 sendto_multi
 sendto_multi_ex
-set_multicast_state
 set_resolver_allocator
 setsocklibopt
 setsockopt

cafe/ntag.def

@@ -7,7 +7,6 @@ NTAGConvertMasterDataToWriteDataForT2T
 NTAGConvertT2T
 NTAGCreateAllWriteData
 NTAGCreateAllWriteDataForT2T
-NTAGDetect
 NTAGFormat
 NTAGInit
 NTAGInitEx
@@ -28,3 +27,6 @@ NTAGWriteT2TLockArea
 NTAGWriteT2TRawData
 NTAGWriteT2TRawDataEx
 NTAGWriteT2TWithConvert
+
+:TEXT_WRAP
+NTAGDetect

docs/CMakeLists.txt

@@ -6,7 +6,7 @@ if(DOXYGEN_FOUND)
    set(DOXYGEN_OUT ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)
 
    set(DOXYGEN_PROJECT_NAME "wut")
-   set(DOXYGEN_PROJECT_NUMBER "1.3.0")
+   set(DOXYGEN_PROJECT_NUMBER $ENV{WUT_VERSION})
    set(DOXYGEN_PROJECT_BRIEF "Wii U Toolchain")
 
    set(DOXYGEN_GENERATE_HTML YES)
@@ -22,18 +22,23 @@ if(DOXYGEN_FOUND)
    set(DOXYGEN_RECURSIVE YES)
    set(DOXYGEN_EXCLUDE_PATTERNS
       "wut_structsize.h")
-   set(DOXYGEN_EXCLUDE_SYMBOLS
-      "WUT_CHECK_OFFSET"
-      "WUT_CHECK_SIZE"
-      "WUT_PADDING_BYTES"
-      "WUT_UNKNOWN_BYTES"
-      "WUT_UNKNOWN_SIZE")
    set(DOXYGEN_SOURCE_BROWSER YES)
    set(DOXYGEN_JAVADOC_AUTOBRIEF YES)
    set(DOXYGEN_ENUM_VALUES_PER_LINE 1)
    set(DOXYGEN_CLASS_DIAGRAMS NO)
    set(DOXYGEN_COLLABORATION_GRAPH NO)
-   set(DOXYGEN_PREDEFINED "__cplusplus")
+   set(DOXYGEN_ENABLE_PREPROCESSING YES)
+   set(DOXYGEN_MACRO_EXPANSION YES)
+   set(DOXYGEN_EXPAND_ONLY_PREDEF YES)
+   set(DOXYGEN_PREDEFINED
+      "__cplusplus;"
+      "WUT_PACKED=;"
+      "WUT_ALIGNAS(x)=;"
+      "WUT_CHECK_OFFSET(Type,Offset,Field)=;"
+      "WUT_CHECK_SIZE(Type,Size)=;"
+      "WUT_PADDING_BYTES(Size)=;"
+      "WUT_UNKNOWN_BYTES(Size)=;"
+      "WUT_UNKNOWN_SIZE(x)=;")
 
    doxygen_add_docs(docs
       "${CMAKE_CURRENT_SOURCE_DIR}/../include"

include/avm/avm.dox

@@ -1,5 +1,5 @@
 /**
  * \defgroup avm avm
  *
- * AVM
+ * Audio/Video Manager
  */

include/avm/cec.h

@@ -0,0 +1,92 @@
+#pragma once
+#include <wut.h>
+#include <tve/cec.h>
+
+/**
+ * \defgroup avm_cec AVM HDMI CEC
+ * \ingroup avm
+ * @{
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Initializes CEC.
+ * 
+ * \return
+ * \c TRUE on success.
+ */
+BOOL
+AVMCECInit(void);
+
+/**
+ * Enable CEC.
+ */
+void
+AVMEnableCEC(void);
+
+/**
+ * Disable CEC.
+ */
+void
+AVMDisableCEC(void);
+
+/**
+ * Sends a CEC command.
+ * 
+ * \param destination
+ * Logical address of the device where the command should be sent to.
+ * 
+ * \param opCode
+ * The op code of the command to send.
+ * 
+ * \param parameters
+ * Pointer to optional command parameters.
+ * 
+ * \param numParameters
+ * The amount of additional parameters.
+ * 
+ * \return
+ * \c TRUE on success.
+ */
+BOOL
+AVMCECSendCommand(TVECECLogicalAddress destination,
+                  TVECECOpCode opCode,
+                  uint8_t *parameters,
+                  uint8_t numParameters);
+
+/**
+ * Get the last receieved CEC command.
+ * 
+ * \param outInitiator
+ * Pointer to store the logical address of the initiator of the command to.
+ * 
+ * \param outOpCode
+ * Pointer to store the op code of the command to.
+ * 
+ * \param outParameters
+ * Pointer to store additional parameters to.
+ * 
+ * \param numParameters
+ * Pointer to store the amount of additional parameters to.
+ * 
+ * \return
+ * \c TRUE on success.
+ * 
+ * \warning
+ * This will return success even if no new command has been receieved.
+ * The caller should check that the parameters were actually written to.
+ */
+BOOL
+AVMCECReceiveCommand(TVECECLogicalAddress *outInitiator,
+                     TVECECOpCode *outOpCode,
+                     uint8_t *outParameters,
+                     uint8_t *outNumParameters);
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */

include/avm/config.h

@@ -0,0 +1,132 @@
+#pragma once
+#include <wut.h>
+#include <tve/tve.h>
+#include "tv.h"
+
+/**
+ * \defgroup avm_config AVM System Config
+ * \ingroup avm
+ * @{
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Reads the TV aspect ratio.
+ * 
+ * \param outAspectRatio
+ * Pointer to write the aspect ratio to.
+ * 
+ * \return
+ * \c 0 on success or a negative value on error.
+ */
+int32_t
+AVMReadSystemAspectRatioConfig(AVMTvAspectRatio *outAspectRatio);
+
+/**
+ * Reads the TV port.
+ * 
+ * \param outPort
+ * Pointer to write the port to.
+ * 
+ * \return
+ * \c 0 on success or a negative value on error.
+ */
+int32_t
+AVMReadSystemPortConfig(TVEPort *outPort);
+
+/**
+ * Reads the TV under scan.
+ * 
+ * \param outUnderScan
+ * Pointer to write the under scan to.
+ * 
+ * \return
+ * \c 0 on success or a negative value on error.
+ */
+int32_t
+AVMReadSystemTVUnderScanConfig(uint32_t *outUnderScan);
+
+/**
+ * Reads the TV resolution.
+ * 
+ * \param outResolution
+ * Pointer to write the resolution to.
+ * 
+ * \return
+ * \c 0 on success or a negative value on error.
+ */
+int32_t
+AVMReadSystemVideoResConfig(AVMTvResolution *outResolution);
+
+/**
+ * Writes the TV aspect ratio.
+ * 
+ * \param aspectRatio
+ * Must be one of #AVMTvAspectRatio.
+ * 
+ * \return
+ * \c 0 on success or a negative value on error.
+ */
+int32_t
+AVMWriteSystemAspectRatioConfig(AVMTvAspectRatio aspectRatio);
+
+/**
+ * Writes the TV under scan.
+ * 
+ * \param underScan
+ * Must be less than \c 0x15 .
+ * 
+ * \return
+ * \c 0 on success or a negative value on error.
+ */
+int32_t
+AVMWriteSystemTVUnderScanConfig(uint32_t underScan);
+
+/**
+ * Writes the TV port and resolution.
+ * 
+ * \param port
+ * Must be one of #TVEPort.
+ * 
+ * \param resolution
+ * Must be one of:
+ * - #AVM_TV_RESOLUTION_576I
+ * - #AVM_TV_RESOLUTION_480I
+ * - #AVM_TV_RESOLUTION_480P
+ * - #AVM_TV_RESOLUTION_720P
+ * - #AVM_TV_RESOLUTION_1080I
+ * - #AVM_TV_RESOLUTION_1080P
+ * 
+ * \return
+ * \c 0 on success or a negative value on error.
+ */
+int32_t
+AVMWriteSystemVideoOutConfig(TVEPort port,
+                             AVMTvResolution resolution);
+
+/**
+ * Writes the TV resolution.
+ *
+ * \param resolution
+ * Must be one of:
+ * - #AVM_TV_RESOLUTION_576I
+ * - #AVM_TV_RESOLUTION_480I
+ * - #AVM_TV_RESOLUTION_480P
+ * - #AVM_TV_RESOLUTION_720P
+ * - #AVM_TV_RESOLUTION_1080I
+ * - #AVM_TV_RESOLUTION_1080P
+ * 
+ * \return
+ * \c 0 on success or a negative value on error.
+ */
+int32_t
+AVMWriteSystemVideoResConfig(AVMTvResolution resolution);
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */

include/avm/drc.h

@@ -13,19 +13,43 @@ extern "C" {
 
 typedef enum AVMDrcScanMode
 {
-   AVM_DRC_SCAN_MODE_UNKNOWN_0 = 0,
+   AVM_DRC_SCAN_MODE_UNKNOWN_0   = 0,
-   AVM_DRC_SCAN_MODE_UNKNOWN_1 = 1,
+   AVM_DRC_SCAN_MODE_UNKNOWN_1   = 1,
-   AVM_DRC_SCAN_MODE_UNKNOWN_3 = 3,
+   AVM_DRC_SCAN_MODE_UNKNOWN_3   = 3,
    AVM_DRC_SCAN_MODE_UNKNOWN_255 = 255,
 } AVMDrcScanMode;
 
 typedef enum AVMDrcMode
 {
-   AVM_DRC_MODE_NONE = 0,
+   AVM_DRC_MODE_NONE   = 0,
    AVM_DRC_MODE_SINGLE = 1,
    AVM_DRC_MODE_DOUBLE = 2,
 } AVMDrcMode;
 
+typedef enum AVMDrcSystemAudioMode
+{
+   AVM_DRC_SYSTEM_AUDIO_MODE_UNKNOWN_0 = 0, // mono?
+   AVM_DRC_SYSTEM_AUDIO_MODE_UNKNOWN_1 = 1, // stereo?
+   AVM_DRC_SYSTEM_AUDIO_MODE_SURROUND  = 2,
+} AVMDrcSystemAudioMode;
+
+/**
+ * Uses AVMGetDRCSystemAudioMode internally
+ * @param outAudioMode
+ * @return 0 on success, -2 on error
+ */
+int
+AVMGetSystemDRCAudioMode(AVMDrcSystemAudioMode *outAudioMode);
+
+BOOL
+AVMGetDRCSystemAudioMode(AVMDrcSystemAudioMode *outAudioMode);
+
+uint32_t
+AVMGetDRCVertCount();
+
+BOOL
+AVMIsDRCFirstFlippDone();
+
 BOOL
 AVMGetDRCScanMode(AVMDrcScanMode *outScanMode);
 
@@ -35,6 +59,12 @@ AVMGetDRCMode(AVMDrcMode *outMode);
 uint32_t
 AVMProbeDRCNum(void);
 
+BOOL
+AVMSetDRCEnable(BOOL enable);
+
+BOOL
+AVMSetDRCGamma(float *gamma);
+
 #ifdef __cplusplus
 }
 #endif

include/avm/tv.h

@@ -0,0 +1,265 @@
+#pragma once
+#include <wut.h>
+#include <tve/tve.h>
+
+/**
+ * \defgroup avm_tv TV
+ * \ingroup avm
+ * @{
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum AVMTvAspectRatio
+{
+   //! 4:3
+   AVM_TV_ASPECT_RATIO_4_3,
+   //! 16:9
+   AVM_TV_ASPECT_RATIO_16_9,
+} AVMTvAspectRatio;
+
+typedef enum AVMTvResolution
+{
+   AVM_TV_RESOLUTION_576I       = 1,
+   AVM_TV_RESOLUTION_480I       = 2,
+   AVM_TV_RESOLUTION_480P       = 3,
+   AVM_TV_RESOLUTION_720P       = 4,
+   AVM_TV_RESOLUTION_720P_3D    = 5,
+   AVM_TV_RESOLUTION_1080I      = 6,
+   AVM_TV_RESOLUTION_1080P      = 7,
+   AVM_TV_RESOLUTION_480I_PAL60 = 10,
+   AVM_TV_RESOLUTION_576P       = 11,
+   AVM_TV_RESOLUTION_720P_50HZ  = 12,
+   AVM_TV_RESOLUTION_1080I_50HZ = 13,
+   AVM_TV_RESOLUTION_1080P_50HZ = 14,
+} AVMTvResolution;
+
+typedef enum AVMTvVideoRegion
+{
+   AVM_TV_VIDEO_REGION_NTSC = 1,
+   AVM_TV_VIDEO_REGION_PAL,
+} AVMTvVideoRegion;
+
+/**
+ * Gets the TV video region.
+ *
+ * \return
+ * \c TRUE if the region is set to \link AVM_TV_VIDEO_REGION_NTSC NTSC \endlink.
+ * \c FALSE if the region is set to \link AVM_TV_VIDEO_REGION_PAL PAL \endlink.
+ */
+BOOL
+AVMDebugIsNTSC(void);
+
+/**
+ * Gets the TV port.
+ * 
+ * \param outPort
+ * Pointer to write the port to.
+ * 
+ * \return
+ * Always returns \c TRUE .
+ * 
+ * \sa
+ * - TVEGetCurrentPort()
+ */
+BOOL
+AVMGetCurrentPort(TVEPort *outPort);
+
+/**
+ * Gets the HDMI state.
+ * 
+ * \param outState
+ * Pointer to write the state to.
+ * 
+ * \sa
+ * - TVEGetHDMIErrorStat()
+ */
+void
+AVMGetHDMIState(TVEHdmiState *outState);
+
+/**
+ * Gets the TV aspect ratio.
+ * 
+ * \param outAspectRatio
+ * Pointer to write the aspect ratio to.
+ * 
+ * \return
+ * Always returns \c TRUE .
+ */
+BOOL
+AVMGetTVAspectRatio(AVMTvAspectRatio *outAspectRatio);
+
+/**
+ * Gets the TV resolution.
+ * 
+ * \warning
+ * If the resolution is set to #AVM_TV_RESOLUTION_480I_PAL60, this function
+ * will instead output #AVM_TV_RESOLUTION_480I.
+ * If the resolution is set to either #AVM_TV_RESOLUTION_720P_50HZ,
+ * #AVM_TV_RESOLUTION_1080I_50HZ, or #AVM_TV_RESOLUTION_1080P_50HZ, then
+ * \e nothing will be stored to \a outResolution .
+ * 
+ * \param outResolution
+ * Pointer to write the resolution to.
+ * 
+ * \return
+ * Always returns \c TRUE .
+ */
+BOOL
+AVMGetTVScanMode(AVMTvResolution *outResolution);
+
+/**
+ * Gets the TV under scan.
+ * 
+ * \param outUnderScan
+ * Pointer to write the under scan to.
+ * 
+ * \return
+ * \c 0 on success or \c -1 on failure.
+ */
+int32_t
+AVMGetTVUnderScan(uint32_t *outUnderScan);
+
+/**
+ * Determines whether a TV is currently connected and displaying the Wii U source.
+ * 
+ * Internally checks that either the #TVEHdmiState is #TVE_HDMI_STATE_DONE or
+ * the analog state is \c 1 , depending on whether the \link TVEPort port \endlink is
+ * set to \link TVE_PORT_HDMI HDMI \endlink or not.
+ * 
+ * \return
+ * \c TRUE if a TV is connected, \c FALSE otherwise.
+ * 
+ * \sa
+ * - AVMGetHDMIState()
+ * - TVEGetHDMIErrorStat()
+ * - TVEGetAnalogStat()
+ */
+BOOL
+AVMIsAVOutReady(void);
+
+/**
+ * Sets the TV aspect ratio.
+ * 
+ * \param aspectRatio
+ * Must be one of #AVMTvAspectRatio.
+ * 
+ * \return
+ * \c TRUE on success or \c FALSE on failure.
+ */
+BOOL
+AVMSetTVAspectRatio(AVMTvAspectRatio aspectRatio);
+
+/**
+ * Sets whether to show or hide the TV video out.
+ * 
+ * \param enable
+ * If \c FALSE then a black image is output (i.e. blanks the screen).
+ * The TV still receives a signal as normal and still plays audio.
+ * 
+ * \return
+ * \c TRUE on success or \c FALSE on failure.
+ */
+BOOL
+AVMSetTVEnable(BOOL enable);
+
+/**
+ * Sets the TV port.
+ * 
+ * \param port
+ * Must be one of #TVEPort.
+ * 
+ * \param resolution
+ * Must be one of #AVMTvResolution.
+ * 
+ * \return
+ * \c 0 on success or a negative value on error.
+ */
+int32_t
+AVMSetTVOutPort(TVEPort port,
+                AVMTvResolution resolution);
+
+/**
+ * Sets the TV resolution and port.
+ * 
+ * \param resolution
+ * Must be one of #AVMTvResolution.
+ * 
+ * \param port
+ * Must be one of #TVEPort.
+ * 
+ * \return
+ * \c 1 on success.
+ */
+int32_t
+AVMSetTVScanMode(AVMTvResolution resolution,
+                 uint32_t unknown,
+                 TVEPort port);
+
+/**
+ * Sets the TV resolution.
+ *
+ * \param resolution
+ * Must be one of #AVMTvResolution.
+ * 
+ * \return
+ * \c 0 on success or a negative value on error.
+ */
+int32_t
+AVMSetTVScanResolution(AVMTvResolution resolution);
+
+/**
+ * Sets the TV under scan.
+ * 
+ * \param underScan
+ * Must be less than \c 0x15 .
+ * 
+ * \return
+ * \c 0 on success or a negative value on error.
+ * 
+ * \sa
+ * - AVMSetTVUnderScanParam()
+ */
+int32_t
+AVMSetTVUnderScan(uint32_t underScan);
+
+/**
+ * \param underScan
+ * Must be less than \c 0x15 .
+ * 
+ * \return
+ * \c 0 on success or \c -1 on failure.
+ * 
+ * \sa
+ * - AVMSetTVUnderScan()
+ */
+int32_t
+AVMSetTVUnderScanParam(uint32_t underScan);
+
+/**
+ * Sets the TV video region.
+ * 
+ * \param videoRegion
+ * Must be one of #AVMTvVideoRegion.
+ * 
+ * \param port
+ * Must be one of #TVEPort.
+ * 
+ * \param resolution
+ * Must be one of #AVMTvResolution.
+ * 
+ * \return
+ * \c 0 on success or a negative value on error.
+ */
+int32_t
+AVMSetTVVideoRegion(AVMTvVideoRegion videoRegion,
+                    TVEPort port,
+                    AVMTvResolution resolution);
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */

include/camera/camera.h

@@ -12,13 +12,13 @@
 extern "C" {
 #endif
 
-#define CAMERA_WIDTH 640
+#define CAMERA_WIDTH                640
-#define CAMERA_PITCH 768
+#define CAMERA_PITCH                768
-#define CAMERA_HEIGHT 480
+#define CAMERA_HEIGHT               480
 
-#define CAMERA_Y_BUFFER_SIZE  (CAMERA_PITCH * CAMERA_HEIGHT)
+#define CAMERA_Y_BUFFER_SIZE        (CAMERA_PITCH * CAMERA_HEIGHT)
-#define CAMERA_UV_BUFFER_SIZE (CAMERA_PITCH * CAMERA_HEIGHT / 2)
+#define CAMERA_UV_BUFFER_SIZE       (CAMERA_PITCH * CAMERA_HEIGHT / 2)
-#define CAMERA_YUV_BUFFER_SIZE (CAMERA_Y_BUFFER_SIZE + CAMERA_UV_BUFFER_SIZE)
+#define CAMERA_YUV_BUFFER_SIZE      (CAMERA_Y_BUFFER_SIZE + CAMERA_UV_BUFFER_SIZE)
 
 #define CAMERA_YUV_BUFFER_ALIGNMENT 256
 
@@ -34,51 +34,91 @@ typedef struct CAMSurface CAMSurface;
 
 typedef enum CamError
 {
-   CAMERA_ERROR_OK                     =  0,
+   CAMERA_ERROR_OK                  = 0,
-   CAMERA_ERROR_INVALID_ARG            = -1,
+   CAMERA_ERROR_INVALID_ARG         = -1,
-   CAMERA_ERROR_INVALID_HANDLE         = -2,
+   CAMERA_ERROR_INVALID_HANDLE      = -2,
-   CAMERA_ERROR_INSUFFICIENT_MEMORY    = -5,
+   CAMERA_ERROR_TOO_MANY_SURFACES   = -4,
-   CAMERA_ERROR_NOT_READY              = -6,
+   CAMERA_ERROR_INSUFFICIENT_MEMORY = -5,
-   CAMERA_ERROR_UNINITIALIZED          = -8,
+   CAMERA_ERROR_NOT_READY           = -6,
-   CAMERA_ERROR_UNKNOWN                = -10,
+   CAMERA_ERROR_UNINITIALIZED       = -8,
-   CAMERA_ERROR_DEVICE_IN_USE          = -12,
+   CAMERA_ERROR_UVC                 = -9,
-   CAMERA_ERROR_SEGMENT_VIOLATION      = -14
+   CAMERA_ERROR_UVD_CONTEXT         = -10,
+   CAMERA_ERROR_DEVICE_IN_USE       = -12,
+   CAMERA_ERROR_UVD_SESSION         = -13,
+   CAMERA_ERROR_SEGMENT_VIOLATION   = -15
 } CamError;
 
 typedef enum CamFps
 {
-   CAMERA_FPS_15,
+   CAMERA_FPS_15 = 0,
-   CAMERA_FPS_30
+   CAMERA_FPS_30 = 1
 } CamFps;
 
 typedef enum CamStreamType
 {
-   CAMERA_STREAM_TYPE_1
+   CAMERA_STREAM_TYPE_1 = 0
 } CamStreamType;
 
+typedef enum CamEventType
+{
+   CAMERA_DECODE_DONE = 0,
+   CAMERA_DRC_DETACH  = 1
+} CamEventType;
+
 struct CAMEventData
 {
-   CAMError err;
+   //! Event type
-   void *img;
+   CamEventType eventType;
-   void *arg; // user provided value ??
+   union
+   {
+      struct
+      {
+         //! Pointer to the buffer of the decoded image
+         void *surfaceBuffer;
+         //! Handle of instance
+         CAMHandle handle;
+         //! TRUE if decode failed
+         BOOL failed;
+      } decode;
+      struct
+      {
+         //! Will be FALSE
+         BOOL connected;
+         //! Handle of instance
+         CAMHandle handle;
+      } detach;
+      //! Event args
+      uint32_t args[3];
+   };
 };
-WUT_CHECK_SIZE(CAMEventData, 0x0C);
+WUT_CHECK_OFFSET(CAMEventData, 0x00, eventType);
+WUT_CHECK_OFFSET(CAMEventData, 0x04, decode.surfaceBuffer);
+WUT_CHECK_OFFSET(CAMEventData, 0x08, decode.handle);
+WUT_CHECK_OFFSET(CAMEventData, 0x0c, decode.failed);
+WUT_CHECK_OFFSET(CAMEventData, 0x04, detach.connected);
+WUT_CHECK_OFFSET(CAMEventData, 0x08, detach.handle);
+WUT_CHECK_OFFSET(CAMEventData, 0x04, args);
+WUT_CHECK_SIZE(CAMEventData, 0x10);
 
-typedef void(*CAMEventHandler)(CAMEventData*);
+typedef void (*CAMEventHandler)(CAMEventData *camEventData);
 
 struct CAMMode
 {
-   int unk_0x00;
+   //! If TRUE, the GamePad will display the camera output regardless of what is being rendered
+   BOOL forceDrc;
+   //! Framerate setting
    CamFps fps;
 };
-WUT_CHECK_OFFSET(CAMMode, 0x00, unk_0x00);
+WUT_CHECK_OFFSET(CAMMode, 0x00, forceDrc);
 WUT_CHECK_OFFSET(CAMMode, 0x04, fps);
 WUT_CHECK_SIZE(CAMMode, 0x08);
 
 struct CAMWorkMem
 {
-   int  size; // size of the work mem
+   //! Size of the work memory
-   void *pMem; // pointer to the work mem
+   uint32_t size;
+   //! Pointer to the work memory
+   void *pMem;
 };
 WUT_CHECK_OFFSET(CAMWorkMem, 0x00, size);
 WUT_CHECK_OFFSET(CAMWorkMem, 0x04, pMem);
@@ -86,9 +126,12 @@ WUT_CHECK_SIZE(CAMWorkMem, 0x08);
 
 struct CAMStreamInfo
 {
+   //! Stream type, only CAMERA_STREAM_TYPE_1 is valid
    CamStreamType type;
-   int height; // stream height              
+   //! Stream height
-   int width; // stream width
+   uint32_t height;
+   //! Stream width
+   uint32_t width;
 };
 WUT_CHECK_OFFSET(CAMStreamInfo, 0x00, type);
 WUT_CHECK_OFFSET(CAMStreamInfo, 0x04, height);
@@ -97,62 +140,101 @@ WUT_CHECK_SIZE(CAMStreamInfo, 0x0C);
 
 struct CAMSetupInfo
 {
+   //! Stream info
    CAMStreamInfo streamInfo;
+   //! Memory used by library to record and decode frames
    CAMWorkMem workMem;
+   //! Event handler
    CAMEventHandler eventHandler;
-   WUT_UNKNOWN_BYTES(4);
+   //! Camera mode
    CAMMode mode;
    //! See \link OS_THREAD_ATTRIB \endlink
    uint32_t threadAffinity;
-   WUT_UNKNOWN_BYTES(0x10);
+   WUT_PADDING_BYTES(0x10);
 };
 WUT_CHECK_OFFSET(CAMSetupInfo, 0x00, streamInfo);
 WUT_CHECK_OFFSET(CAMSetupInfo, 0x0C, workMem);
 WUT_CHECK_OFFSET(CAMSetupInfo, 0x14, eventHandler);
-WUT_CHECK_OFFSET(CAMSetupInfo, 0x1C, mode);
+WUT_CHECK_OFFSET(CAMSetupInfo, 0x18, mode);
-WUT_CHECK_OFFSET(CAMSetupInfo, 0x24, threadAffinity);
+WUT_CHECK_OFFSET(CAMSetupInfo, 0x20, threadAffinity);
-WUT_CHECK_SIZE(CAMSetupInfo, 0x38);
+WUT_CHECK_SIZE(CAMSetupInfo, 0x34);
 
 struct CAMSurface
 {
-   int surfaceSize;
+   //! Number of bytes allocated to surface buffer
+   int32_t surfaceSize;
+   //! Surface buffer data
    void *surfaceBuffer;
-   int height; // surface height
+   //! Surface height
-   int width; // surface width
+   int32_t height;
-   int unk_0x10; // pitch related?
+   //! Surface width
-   int alignment; // surface alignment
+   int32_t width;
-   int unk_0x18; // surface tile mode related?
+   //! Surface pitch
-   int unk_0x1C;
+   int32_t pitch;
+   //! Surface alignment
+   int32_t alignment;
+   //! Tile mode, should be zero
+   int32_t tileMode;
+   //! Pixel format, Should be zero
+   int32_t pixelFormat;
 };
 WUT_CHECK_OFFSET(CAMSurface, 0x00, surfaceSize);
 WUT_CHECK_OFFSET(CAMSurface, 0x04, surfaceBuffer);
 WUT_CHECK_OFFSET(CAMSurface, 0x08, height);
 WUT_CHECK_OFFSET(CAMSurface, 0x0C, width);
-WUT_CHECK_OFFSET(CAMSurface, 0x10, unk_0x10);
+WUT_CHECK_OFFSET(CAMSurface, 0x10, pitch);
 WUT_CHECK_OFFSET(CAMSurface, 0x14, alignment);
-WUT_CHECK_OFFSET(CAMSurface, 0x18, unk_0x18);
+WUT_CHECK_OFFSET(CAMSurface, 0x18, tileMode);
-WUT_CHECK_OFFSET(CAMSurface, 0x1C, unk_0x1C);
+WUT_CHECK_OFFSET(CAMSurface, 0x1C, pixelFormat);
 WUT_CHECK_SIZE(CAMSurface, 0x20);
 
-CAMHandle 
+/**
+* Initialize the camera
+* \returns camera handle on success, and -1 on failure
+*/
+CAMHandle
 CAMInit(int instance, CAMSetupInfo *setupInfo, CAMError *err);
 
-void 
+/**
+* Deinitialize and clean up
+*/
+void
 CAMExit(CAMHandle handle);
 
-CAMError 
+/**
+* Start recording and decoding frames
+*/
+CAMError
 CAMOpen(CAMHandle handle);
 
-CAMError 
+/**
+* Stops recording and decoding.
+* Automatically called when the process is moved to background
+*/
+CAMError
 CAMClose(CAMHandle handle);
 
-CAMError 
+/**
+* Get the number of bytes requied by the work memory
+* \returns number of bytes
+* \returns CAM_ERROR_INVALID_ARG if streamInfo is NULL
+*/
+int32_t
 CAMGetMemReq(CAMStreamInfo *streamInfo);
 
-CAMError 
+/**
+* Submit 1 surface to the working queue.
+* Once the frame is captured and decoded, the event handler set in CAMInit will fire, and the frame will be dequeued.
+* Up to 20 surfaces may be queued.
+* Surface data is returned in the NV12 format
+*/
+CAMError
 CAMSubmitTargetSurface(CAMHandle handle, CAMSurface *surface);
 
-CAMError 
+/**
+* Checks whether memory is segmented correctly to be used with the camera library
+*/
+CAMError
 CAMCheckMemSegmentation(void *pMem, uint32_t size);
 
 #ifdef __cplusplus

include/coreinit/alarm.h

@@ -1,8 +1,8 @@
 #pragma once
 #include <wut.h>
+#include "context.h"
 #include "threadqueue.h"
 #include "time.h"
-#include "context.h"
 
 /**
  * \defgroup coreinit_alarms Alarms

include/coreinit/bsp.h

@@ -12,51 +12,67 @@
 extern "C" {
 #endif
 
-typedef int32_t BSPError;
 typedef uint32_t BSPHardwareVersion;
 typedef uint32_t BSPConsoleTypeRaw;
 
-typedef enum BSPErrors
+typedef enum BSPError
 {
-    BSP_ERROR_OK                    =   0,
+   BSP_ERROR_OK                       = 0x0,
-    BSP_ERROR_IOS_ERROR             =   0x40,
+   BSP_ERROR_UNKNOWN_ENTITY           = 0x1,
-    BSP_ERROR_RESPONSE_TOO_LARGE    =   0x80,
+   BSP_ERROR_UNKNOWN_ATTRIBUTE        = 0x2,
-} BSPErrors;
+   BSP_ERROR_INVALID_INSTANCE         = 0x4,
+   BSP_ERROR_CFG_CORRUPTED            = 0x8,
+   BSP_ERROR_DEVICE_ERROR             = 0x10,
+   BSP_ERROR_DEVICE_BUSY              = 0x20,
+   BSP_ERROR_IOS_ERROR                = 0x40,
+   BSP_ERROR_SPECIFIED_SIZE_INVALID   = 0x80,
+   BSP_ERROR_HEAP_ERROR               = 0x100,
+   BSP_ERROR_ENTITY_LIST_FULL         = 0x200,
+   BSP_ERROR_UNSUPPORTED_METHOD       = 0x400,
+   BSP_ERROR_UNKNOWN_HARDWARE_VERSION = 0x800,
+   BSP_ERROR_QUERY_UNAVAILABLE        = 0x1000,
+   BSP_ERROR_UNKNOWN_DEVICE           = 0x2000,
+   BSP_ERROR_INVALID_PARAMETER        = 0x4000,
+   BSP_ERROR_DEVICE_NOT_FOUND         = 0x8000,
+   BSP_ERROR_REQUEST_DENIED           = 0x10000,
+   BSP_ERROR_UNSUPPORTED_PARAMETER    = 0x20000,
+   BSP_ERROR_BOARD_CONFIG_INVALID     = 0x40000,
+} BSPError;
 
 typedef enum BSPHardwareVersions
 {
-    BSP_HARDWARE_VERSION_UNKNOWN                        =   0x00000000,
+   BSP_HARDWARE_VERSION_UNKNOWN                    = 0x00000000,
 
-    // vWii Hardware Versions
+   // vWii Hardware Versions
-    BSP_HARDWARE_VERSION_HOLLYWOOD_ENG_SAMPLE_1         =   0x00000001,
+   BSP_HARDWARE_VERSION_HOLLYWOOD_ENG_SAMPLE_1     = 0x00000001,
-    BSP_HARDWARE_VERSION_HOLLYWOOD_ENG_SAMPLE_2         =   0x10000001,
+   BSP_HARDWARE_VERSION_HOLLYWOOD_ENG_SAMPLE_2     = 0x10000001,
-    BSP_HARDWARE_VERSION_HOLLYWOOD_PROD_FOR_WII         =   0x10100001,
+   BSP_HARDWARE_VERSION_HOLLYWOOD_PROD_FOR_WII     = 0x10100001,
-    BSP_HARDWARE_VERSION_HOLLYWOOD_CORTADO              =   0x10100008,
+   BSP_HARDWARE_VERSION_HOLLYWOOD_CORTADO          = 0x10100008,
-    BSP_HARDWARE_VERSION_HOLLYWOOD_CORTADO_ESPRESSO     =   0x1010000C,
+   BSP_HARDWARE_VERSION_HOLLYWOOD_CORTADO_ESPRESSO = 0x1010000C,
-    BSP_HARDWARE_VERSION_BOLLYWOOD                      =   0x20000001,
+   BSP_HARDWARE_VERSION_BOLLYWOOD                  = 0x20000001,
-    BSP_HARDWARE_VERSION_BOLLYWOOD_PROD_FOR_WII         =   0x20100001,
+   BSP_HARDWARE_VERSION_BOLLYWOOD_PROD_FOR_WII     = 0x20100001,
 
-    // WiiU Hardware Versions
+   // WiiU Hardware Versions
-    BSP_HARDWARE_VERSION_LATTE_A11_EV            =   0x21100010,
+   BSP_HARDWARE_VERSION_LATTE_A11_EV               = 0x21100010,
-    BSP_HARDWARE_VERSION_LATTE_A11_CAT           =   0x21100020,
+   BSP_HARDWARE_VERSION_LATTE_A11_CAT              = 0x21100020,
-    BSP_HARDWARE_VERSION_LATTE_A12_EV            =   0x21200010,
+   BSP_HARDWARE_VERSION_LATTE_A12_EV               = 0x21200010,
-    BSP_HARDWARE_VERSION_LATTE_A12_CAT           =   0x21200020,
+   BSP_HARDWARE_VERSION_LATTE_A12_CAT              = 0x21200020,
-    BSP_HARDWARE_VERSION_LATTE_A2X_EV            =   0x22100010,
+   BSP_HARDWARE_VERSION_LATTE_A2X_EV               = 0x22100010,
-    BSP_HARDWARE_VERSION_LATTE_A2X_CAT           =   0x22100020,
+   BSP_HARDWARE_VERSION_LATTE_A2X_CAT              = 0x22100020,
-    BSP_HARDWARE_VERSION_LATTE_A3X_EV            =   0x23100010,
+   BSP_HARDWARE_VERSION_LATTE_A3X_EV               = 0x23100010,
-    BSP_HARDWARE_VERSION_LATTE_A3X_CAT           =   0x23100020,
+   BSP_HARDWARE_VERSION_LATTE_A3X_CAT              = 0x23100020,
-    BSP_HARDWARE_VERSION_LATTE_A3X_CAFE          =   0x23100028,
+   BSP_HARDWARE_VERSION_LATTE_A3X_CAFE             = 0x23100028,
-    BSP_HARDWARE_VERSION_LATTE_A4X_EV            =   0x24100010,
+   BSP_HARDWARE_VERSION_LATTE_A4X_EV               = 0x24100010,
-    BSP_HARDWARE_VERSION_LATTE_A4X_CAT           =   0x24100020,
+   BSP_HARDWARE_VERSION_LATTE_A4X_CAT              = 0x24100020,
-    BSP_HARDWARE_VERSION_LATTE_A4X_CAFE          =   0x24100028,
+   BSP_HARDWARE_VERSION_LATTE_A4X_CAFE             = 0x24100028,
-    BSP_HARDWARE_VERSION_LATTE_A5X_EV            =   0x25100010,
+   BSP_HARDWARE_VERSION_LATTE_A5X_EV               = 0x25100010,
-    BSP_HARDWARE_VERSION_LATTE_A5X_EV_Y          =   0x25100011,
+   BSP_HARDWARE_VERSION_LATTE_A5X_EV_Y             = 0x25100011,
-    BSP_HARDWARE_VERSION_LATTE_A5X_CAT           =   0x25100020,
+   BSP_HARDWARE_VERSION_LATTE_A5X_CAT              = 0x25100020,
-    BSP_HARDWARE_VERSION_LATTE_A5X_CAFE          =   0x25100028,
+   BSP_HARDWARE_VERSION_LATTE_A5X_CAFE             = 0x25100028,
-    BSP_HARDWARE_VERSION_LATTE_B1X_EV            =   0x26100010,
+   BSP_HARDWARE_VERSION_LATTE_B1X_EV               = 0x26100010,
-    BSP_HARDWARE_VERSION_LATTE_B1X_EV_Y          =   0x26100011,
+   BSP_HARDWARE_VERSION_LATTE_B1X_EV_Y             = 0x26100011,
-    BSP_HARDWARE_VERSION_LATTE_B1X_CAT           =   0x26100020,
+   BSP_HARDWARE_VERSION_LATTE_B1X_CAT              = 0x26100020,
-    BSP_HARDWARE_VERSION_LATTE_B1X_CAFE          =   0x26100028
+   BSP_HARDWARE_VERSION_LATTE_B1X_CAFE             = 0x26100028
 } BSPHardwareVersions;
 
 BSPError

include/coreinit/cache.h

@@ -191,7 +191,7 @@ DCTouchRange(void *addr,
 void
 ICInvalidateRange(void *addr,
                   uint32_t size);
-				  
+
 void
 OSMemoryBarrier();
 

include/coreinit/codegen.h

@@ -1,4 +1,5 @@
 #pragma once
+
 #include <wut.h>
 
 /**
@@ -32,10 +33,10 @@ extern "C" {
 //! The memory permissions for the codegen area.
 typedef enum OSCodegenSecMode
 {
-    //! The area can be read or written to, but not executed.
+   //! The area can be read or written to, but not executed.
-    CODEGEN_RW_ = 0,
+   CODEGEN_RW_ = 0,
-    //! The area can be read or executed, but not written to.
+   //! The area can be read or executed, but not written to.
-    CODEGEN_R_X = 1,
+   CODEGEN_R_X = 1,
 } OSCodegenSecMode;
 
 /**
@@ -53,8 +54,8 @@ typedef enum OSCodegenSecMode
  * - \link OSGetSecCodeGenMode \endlink
  */
 void
-OSCodegenGetVirtAddrRange(uint32_t* outVirtualAddress,
+OSGetCodegenVirtAddrRange(void **outVirtualAddress,
-                          uint32_t* outSize);
+                          uint32_t *outSize);
 
 /**
  * Gets the CPU core that's allowed to use codegen.
@@ -119,10 +120,9 @@ OSGetSecCodeGenMode();
  * <!-- NOTE this function has a specific bit required in cox.xml: 1 << 30? -->
  */
 BOOL
-OSCodegenCopy(void* dst, void* src, size_t size);
+OSCodegenCopy(void *dst,
-
+              void *src,
-void
+              size_t size);
-OSGetCodegenVirtAddrRange(void** outAddr, uint32_t* size);
 
 #ifdef __cplusplus
 }

include/coreinit/context.h

@@ -15,9 +15,10 @@ extern "C" {
 //! A bitfield of enum OS_CONTEXT_STATE.
 typedef uint16_t OSContextState;
 
-enum OS_CONTEXT_STATE {
+enum OS_CONTEXT_STATE
-    OS_CONTEXT_STATE_OSCALLBACK     = 1 << 3,
+{
-    OS_CONTEXT_STATE_USERMODE_SAVED = 1 << 4
+   OS_CONTEXT_STATE_OSCALLBACK     = 1 << 3,
+   OS_CONTEXT_STATE_USERMODE_SAVED = 1 << 4
 };
 
 typedef struct OSContext OSContext;

include/coreinit/core.h

@@ -14,6 +14,15 @@ extern "C" {
 #endif
 
 
+/**
+ * Can be used to mask the return value of
+ * \ref OSGetConsoleType
+ * for determining the "group" of console. See the function for more
+ * information around the values the mask gives.
+ */
+#define OS_CONSOLE_TYPE_MASK 0xF0000000
+
+
 /**
  * Gets the number of cores in the system. On a retail Wii U, this is always 3.
  *
@@ -58,6 +67,22 @@ BOOL
 OSIsMainCore();
 
 
+/**
+ * Get the type of console this code is actively running on.
+ *
+ * Most of the field is relatively unknown but you can use
+ * \ref OS_CONSOLE_TYPE_MASK
+ * which returns whether the unit is a Retail/CAT-R unit with `0x00000000`,
+ * a CAT-DEV or other CAFE development board with `0x10000000`, and an
+ * orchestrax unit with `0x20000000`.
+ *
+ * \returns
+ * A number representing the specific console types.
+ */
+uint32_t
+OSGetConsoleType();
+
+
 #ifdef __cplusplus
 }
 #endif

include/coreinit/cosreport.h

@@ -12,45 +12,52 @@
 extern "C" {
 #endif
 
-typedef enum COSReportLevel{
+typedef enum COSReportLevel
-   COS_REPORT_LEVEL_ERROR       = 0,
+{
-   COS_REPORT_LEVEL_WARN        = 1,
+   COS_REPORT_LEVEL_ERROR   = 0,
-   COS_REPORT_LEVEL_INFO        = 2,
+   COS_REPORT_LEVEL_WARN    = 1,
-   COS_REPORT_LEVEL_VERBOSE     = 3,
+   COS_REPORT_LEVEL_INFO    = 2,
+   COS_REPORT_LEVEL_VERBOSE = 3,
 } COSReportLevel;
 
-typedef enum COSReportModule{
+typedef enum COSReportModule
-   COS_REPORT_MODULE_UNKNOWN_0  = 0,
+{
-   COS_REPORT_MODULE_UNKNOWN_1  = 1,
+   COS_REPORT_MODULE_UNKNOWN_0 = 0,
-   COS_REPORT_MODULE_UNKNOWN_2  = 2,
+   COS_REPORT_MODULE_UNKNOWN_1 = 1,
-   COS_REPORT_MODULE_UNKNOWN_5  = 5,
+   COS_REPORT_MODULE_UNKNOWN_2 = 2,
+   COS_REPORT_MODULE_UNKNOWN_5 = 5,
 } COSReportModule;
 
 void
 COSVReport(COSReportModule module,
            COSReportLevel level,
-           const char* fmt,
+           const char *fmt,
-           ...);
+           ...)
+   WUT_FORMAT_PRINTF(3, 4);
 
 void
 COSError(COSReportModule module,
-         const char* fmt,
+         const char *fmt,
-         ...);
+         ...)
+   WUT_FORMAT_PRINTF(2, 3);
 
 void
 COSInfo(COSReportModule module,
-        const char* fmt,
+        const char *fmt,
-        ...);
+        ...)
+   WUT_FORMAT_PRINTF(2, 3);
 
 void
 COSVerbose(COSReportModule module,
-           const char* fmt,
+           const char *fmt,
-           ...);
+           ...)
+   WUT_FORMAT_PRINTF(2, 3);
 
 void
 COSWarn(COSReportModule module,
-        const char* fmt,
+        const char *fmt,
-        ...);
+        ...)
+   WUT_FORMAT_PRINTF(2, 3);
 
 #ifdef __cplusplus
 }

include/coreinit/debug.h

@@ -11,6 +11,8 @@
 extern "C" {
 #endif
 
+typedef struct OSFatalError OSFatalError;
+
 typedef void (*DisassemblyPrintFn)(const char *fmt, ...);
 
 typedef uint32_t (*DisassemblyFindSymbolFn)(uint32_t addr, char *symbolNameBuf, uint32_t symbolNameBufSize);
@@ -20,6 +22,39 @@ typedef enum DisassemblePPCFlags
    DISASSEMBLE_PPC_FLAGS_NONE = 0,
 } DisassemblePPCFlags;
 
+typedef enum OSFatalErrorMessageType
+{
+   OS_FATAL_ERROR_UNKOWN              = 0,
+   OS_FATAL_ERROR_GENERAL             = 1,
+
+   //! These are only valid for errorCode 1600200 - 1609999
+   OS_FATAL_ERROR_CORRUPTION          = 2,
+   OS_FATAL_ERROR_FATAL_SYSTEM_OR_USB = 3,
+   OS_FATAL_ERROR_CORRUPTION_SLC      = 4,
+   OS_FATAL_ERROR_CORRUPTION_USB      = 5,
+   OS_FATAL_ERROR_STORAGE_REMOVED     = 6,
+   OS_FATAL_ERROR_DISC_REMOVED        = 7,
+   OS_FATAL_ERROR_CORRUPTION_DISC     = 8,
+   OS_FATAL_ERROR_WRITE_PROTECT       = 9,
+} OSFatalErrorMessageType;
+
+struct OSFatalError
+{
+   OSFatalErrorMessageType messageType;
+   uint32_t errorCode;
+   uint32_t processId;
+   uint32_t internalErrorCode;
+   uint32_t line;
+   char functionName[64];
+   WUT_UNKNOWN_BYTES(0x80);
+};
+WUT_CHECK_OFFSET(OSFatalError, 0x00, messageType);
+WUT_CHECK_OFFSET(OSFatalError, 0x04, errorCode);
+WUT_CHECK_OFFSET(OSFatalError, 0x08, processId);
+WUT_CHECK_OFFSET(OSFatalError, 0x0C, internalErrorCode);
+WUT_CHECK_OFFSET(OSFatalError, 0x10, line);
+WUT_CHECK_OFFSET(OSFatalError, 0x14, functionName);
+WUT_CHECK_SIZE(OSFatalError, 0xD4);
 
 void
 OSConsoleWrite(const char *msg,
@@ -30,30 +65,40 @@ __OSConsoleWrite(const char *msg,
                  uint32_t size);
 
 void
-OSReport(const char *fmt, ...);
+OSReport(const char *fmt, ...)
+   WUT_FORMAT_PRINTF(1, 2);
 
 
 void
-OSReportVerbose(const char *fmt, ...);
+OSReportVerbose(const char *fmt, ...)
+   WUT_FORMAT_PRINTF(1, 2);
 
 
 void
-OSReportInfo(const char *fmt, ...);
+OSReportInfo(const char *fmt, ...)
+   WUT_FORMAT_PRINTF(1, 2);
 
 
 void
-OSReportWarn(const char *fmt, ...);
+OSReportWarn(const char *fmt, ...)
+   WUT_FORMAT_PRINTF(1, 2);
 
 
 void
 OSPanic(const char *file,
         uint32_t line,
-        const char *fmt, ...);
+        const char *fmt,
+        ...)
+   WUT_FORMAT_PRINTF(3, 4);
 
 
 void
 OSFatal(const char *msg);
 
+void
+OSSendFatalError(OSFatalError *error,
+                 const char *functionName,
+                 uint32_t line);
 
 uint32_t
 OSGetSymbolName(uint32_t addr,

include/coreinit/dynload.h

@@ -23,31 +23,32 @@ typedef struct OSDynLoad_InternalData OSDynLoad_InternalData;
 
 typedef enum OSDynLoad_Error
 {
-   OS_DYNLOAD_OK                          = 0,
+   OS_DYNLOAD_OK                      = 0,
-   OS_DYNLOAD_OUT_OF_MEMORY               = 0xBAD10002,
+   OS_DYNLOAD_OUT_OF_MEMORY           = 0xBAD10002,
-   OS_DYNLOAD_INVALID_NOTIFY_PTR          = 0xBAD1000E,
+   OS_DYNLOAD_INVALID_NOTIFY_PTR      = 0xBAD1000E,
-   OS_DYNLOAD_INVALID_MODULE_NAME_PTR     = 0xBAD1000F,
+   OS_DYNLOAD_INVALID_MODULE_NAME_PTR = 0xBAD1000F,
-   OS_DYNLOAD_INVALID_MODULE_NAME         = 0xBAD10010,
+   OS_DYNLOAD_INVALID_MODULE_NAME     = 0xBAD10010,
-   OS_DYNLOAD_INVALID_ACQUIRE_PTR         = 0xBAD10011,
+   OS_DYNLOAD_INVALID_ACQUIRE_PTR     = 0xBAD10011,
-   OS_DYNLOAD_EMPTY_MODULE_NAME           = 0xBAD10012,
+   OS_DYNLOAD_EMPTY_MODULE_NAME       = 0xBAD10012,
-   OS_DYNLOAD_INVALID_ALLOCATOR_PTR       = 0xBAD10017,
+   OS_DYNLOAD_INVALID_ALLOCATOR_PTR   = 0xBAD10017,
-   OS_DYNLOAD_OUT_OF_SYSTEM_MEMORY        = 0xBAD1002F,
+   OS_DYNLOAD_OUT_OF_SYSTEM_MEMORY    = 0xBAD1002F,
-   OS_DYNLOAD_TLS_ALLOCATOR_LOCKED        = 0xBAD10031,
+   OS_DYNLOAD_TLS_ALLOCATOR_LOCKED    = 0xBAD10031,
-   OS_DYNLOAD_MODULE_NOT_FOUND            = 0xFFFFFFFA,
+   OS_DYNLOAD_MODULE_NOT_FOUND        = 0xFFFFFFFA,
 } OSDynLoad_Error;
 
 typedef OSDynLoad_Error (*OSDynLoadAllocFn)(int32_t size, int32_t align, void **outAddr);
 typedef void (*OSDynLoadFreeFn)(void *addr);
 
-typedef enum OSDynLoad_ExportType {
+typedef enum OSDynLoad_ExportType
-  OS_DYNLOAD_EXPORT_FUNC = 0,
+{
-  OS_DYNLOAD_EXPORT_DATA = 1,
+   OS_DYNLOAD_EXPORT_FUNC = 0,
+   OS_DYNLOAD_EXPORT_DATA = 1,
 } OSDynLoad_ExportType;
 
 typedef enum OSDynLoad_EntryReason
 {
-  OS_DYNLOAD_LOADED                       = 1,
+   OS_DYNLOAD_LOADED   = 1,
-  OS_DYNLOAD_UNLOADED                     = 2,
+   OS_DYNLOAD_UNLOADED = 2,
 } OSDynLoad_EntryReason;
 
 struct OSDynLoad_NotifyData
@@ -97,18 +98,18 @@ WUT_CHECK_SIZE(OSDynLoad_LoaderHeapStatistics, 0x18);
 
 struct OSDynLoad_LoaderUserFileInfo
 {
-    uint32_t size;
+   uint32_t size;
-    uint32_t magic;
+   uint32_t magic;
-    uint32_t pathStringLength;
+   uint32_t pathStringLength;
-    char *pathString;
+   char *pathString;
-    uint32_t fileInfoFlags;
+   uint32_t fileInfoFlags;
-    int16_t tlsModuleIndex;
+   int16_t tlsModuleIndex;
-    int16_t tlsAlignShift;
+   int16_t tlsAlignShift;
-    void *tlsAddressStart;
+   void *tlsAddressStart;
-    uint32_t tlsSectionSize;
+   uint32_t tlsSectionSize;
-    uint32_t shstrndx;
+   uint32_t shstrndx;
-    uint32_t titleLocation;
+   uint32_t titleLocation;
-    WUT_UNKNOWN_BYTES(0x60 - 0x28);
+   WUT_UNKNOWN_BYTES(0x60 - 0x28);
 };
 WUT_CHECK_OFFSET(OSDynLoad_LoaderUserFileInfo, 0x00, size);
 WUT_CHECK_OFFSET(OSDynLoad_LoaderUserFileInfo, 0x04, magic);
@@ -126,17 +127,18 @@ WUT_CHECK_SIZE(OSDynLoad_LoaderUserFileInfo, 0x60);
 
 struct OSDynLoad_LoaderSectionInfo
 {
-    uint32_t type;
+   uint32_t type;
-    uint32_t flags;
+   uint32_t flags;
-    void *address;
+   void *address;
 
-    union {
+   union
-        //! Size of the section, set when type != SHT_RPL_IMPORTS
+   {
-        uint32_t size;
+      //! Size of the section, set when type != SHT_RPL_IMPORTS
+      uint32_t size;
 
-        //! Name offset of the section, set when type == SHT_RPL_IMPORTS
+      //! Name offset of the section, set when type == SHT_RPL_IMPORTS
-        uint32_t name;
+      uint32_t name;
-    };
+   };
 };
 WUT_CHECK_OFFSET(OSDynLoad_LoaderSectionInfo, 0x00, type);
 WUT_CHECK_OFFSET(OSDynLoad_LoaderSectionInfo, 0x04, flags);
@@ -148,29 +150,29 @@ WUT_CHECK_SIZE(OSDynLoad_LoaderSectionInfo, 0x10);
 
 struct OSDynLoad_InternalData
 {
-    uint32_t handle;
+   uint32_t handle;
-    void *loaderHandle;
+   void *loaderHandle;
-    char *moduleName;
+   char *moduleName;
-    uint32_t moduleNameLen;
+   uint32_t moduleNameLen;
-    uint32_t sectionInfoCount;
+   uint32_t sectionInfoCount;
-    OSDynLoad_LoaderSectionInfo *sectionInfo;
+   OSDynLoad_LoaderSectionInfo *sectionInfo;
-    OSDynLoad_InternalData **importModules;
+   OSDynLoad_InternalData **importModules;
-    uint32_t importModuleCount;
+   uint32_t importModuleCount;
-    uint32_t userFileInfoSize;
+   uint32_t userFileInfoSize;
-    OSDynLoad_LoaderUserFileInfo *userFileInfo;
+   OSDynLoad_LoaderUserFileInfo *userFileInfo;
-    OSDynLoad_NotifyData *notifyData;
+   OSDynLoad_NotifyData *notifyData;
-    void *entryPoint;
+   void *entryPoint;
-    uint32_t dataSectionSize;
+   uint32_t dataSectionSize;
-    void *dataSection;
+   void *dataSection;
-    uint32_t loadSectionSize;
+   uint32_t loadSectionSize;
-    void *loadSection;
+   void *loadSection;
-    OSDynLoadFreeFn dynLoadFreeFn;
+   OSDynLoadFreeFn dynLoadFreeFn;
-    void *codeExports;
+   void *codeExports;
-    uint32_t numCodeExports;
+   uint32_t numCodeExports;
-    void *dataExports;
+   void *dataExports;
-    uint32_t numDataExports;
+   uint32_t numDataExports;
-    OSDynLoad_InternalData *next;
+   OSDynLoad_InternalData *next;
-    WUT_UNKNOWN_BYTES(0x94 - 0x58);
+   WUT_UNKNOWN_BYTES(0x94 - 0x58);
 };
 WUT_CHECK_OFFSET(OSDynLoad_InternalData, 0x00, handle);
 WUT_CHECK_OFFSET(OSDynLoad_InternalData, 0x04, loaderHandle);
@@ -198,8 +200,8 @@ WUT_CHECK_SIZE(OSDynLoad_InternalData, 0x94);
 
 typedef enum OSDynLoad_NotifyReason
 {
-  OS_DYNLOAD_NOTIFY_UNLOADED              = 0,
+   OS_DYNLOAD_NOTIFY_UNLOADED = 0,
-  OS_DYNLOAD_NOTIFY_LOADED                = 1
+   OS_DYNLOAD_NOTIFY_LOADED   = 1
 } OSDynLoad_NotifyReason;
 
 typedef void (*OSDynLoadNotifyFunc)(OSDynLoad_Module module,
@@ -328,14 +330,14 @@ OSDynLoad_IsModuleLoaded(char const *name,
 * Registers a callback that's called whenever a new .rpl is loaded or unloaded
 **/
 OSDynLoad_Error
-OSDynLoad_AddNotifyCallback(OSDynLoadNotifyFunc notifyFn, 
+OSDynLoad_AddNotifyCallback(OSDynLoadNotifyFunc notifyFn,
                             void *userContext);
 
 /**
 * Removes a previously added a callback
 **/
 OSDynLoad_Error
-OSDynLoad_DelNotifyCallback(OSDynLoadNotifyFunc notifyFn, 
+OSDynLoad_DelNotifyCallback(OSDynLoadNotifyFunc notifyFn,
                             void *userContext);
 
 /**

include/coreinit/event.h

@@ -22,10 +22,10 @@ typedef struct OSEvent OSEvent;
 typedef enum OSEventMode
 {
    //! A manual event will only reset when OSResetEvent is called.
-   OS_EVENT_MODE_MANUAL    = 0,
+   OS_EVENT_MODE_MANUAL = 0,
 
    //! An auto event will reset everytime a thread is woken.
-   OS_EVENT_MODE_AUTO      = 1,
+   OS_EVENT_MODE_AUTO   = 1,
 } OSEventMode;
 
 #define OS_EVENT_TAG 0x65566E54u

include/coreinit/exception.h

@@ -16,30 +16,30 @@ typedef BOOL (*OSExceptionCallbackFn)(OSContext *context);
 
 typedef enum OSExceptionMode
 {
-   OS_EXCEPTION_MODE_SYSTEM               = 0,
+   OS_EXCEPTION_MODE_SYSTEM           = 0,
-   OS_EXCEPTION_MODE_THREAD               = 1,
+   OS_EXCEPTION_MODE_THREAD           = 1,
-   OS_EXCEPTION_MODE_GLOBAL               = 2,
+   OS_EXCEPTION_MODE_GLOBAL           = 2,
-   OS_EXCEPTION_MODE_THREAD_ALL_CORES     = 3,
+   OS_EXCEPTION_MODE_THREAD_ALL_CORES = 3,
-   OS_EXCEPTION_MODE_GLOBAL_ALL_CORES     = 4,
+   OS_EXCEPTION_MODE_GLOBAL_ALL_CORES = 4,
 } OSExceptionMode;
 
 typedef enum OSExceptionType
 {
-   OS_EXCEPTION_TYPE_SYSTEM_RESET         = 0,
+   OS_EXCEPTION_TYPE_SYSTEM_RESET        = 0,
-   OS_EXCEPTION_TYPE_MACHINE_CHECK        = 1,
+   OS_EXCEPTION_TYPE_MACHINE_CHECK       = 1,
-   OS_EXCEPTION_TYPE_DSI                  = 2,
+   OS_EXCEPTION_TYPE_DSI                 = 2,
-   OS_EXCEPTION_TYPE_ISI                  = 3,
+   OS_EXCEPTION_TYPE_ISI                 = 3,
-   OS_EXCEPTION_TYPE_EXTERNAL_INTERRUPT   = 4,
+   OS_EXCEPTION_TYPE_EXTERNAL_INTERRUPT  = 4,
-   OS_EXCEPTION_TYPE_ALIGNMENT            = 5,
+   OS_EXCEPTION_TYPE_ALIGNMENT           = 5,
-   OS_EXCEPTION_TYPE_PROGRAM              = 6,
+   OS_EXCEPTION_TYPE_PROGRAM             = 6,
-   OS_EXCEPTION_TYPE_FLOATING_POINT       = 7,
+   OS_EXCEPTION_TYPE_FLOATING_POINT      = 7,
-   OS_EXCEPTION_TYPE_DECREMENTER          = 8,
+   OS_EXCEPTION_TYPE_DECREMENTER         = 8,
-   OS_EXCEPTION_TYPE_SYSTEM_CALL          = 9,
+   OS_EXCEPTION_TYPE_SYSTEM_CALL         = 9,
-   OS_EXCEPTION_TYPE_TRACE                = 10,
+   OS_EXCEPTION_TYPE_TRACE               = 10,
-   OS_EXCEPTION_TYPE_PERFORMANCE_MONITOR  = 11,
+   OS_EXCEPTION_TYPE_PERFORMANCE_MONITOR = 11,
-   OS_EXCEPTION_TYPE_BREAKPOINT           = 12,
+   OS_EXCEPTION_TYPE_BREAKPOINT          = 12,
-   OS_EXCEPTION_TYPE_SYSTEM_INTERRUPT     = 13,
+   OS_EXCEPTION_TYPE_SYSTEM_INTERRUPT    = 13,
-   OS_EXCEPTION_TYPE_ICI                  = 14,
+   OS_EXCEPTION_TYPE_ICI                 = 14,
 } OSExceptionType;
 
 OSExceptionCallbackFn

include/coreinit/exit.h

@@ -11,8 +11,10 @@
 extern "C" {
 #endif
 
+// clang-format off
 void
 RPLWRAP(exit)(int code);
+// clang-format on
 
 void
 _Exit(int code);

include/coreinit/fiber.h

@@ -13,8 +13,7 @@ extern "C" {
 #endif
 
 typedef void (*OSFiberEntryFn)();
-typedef void (*OSFiberExEntryFn)(uint32_t arg1, uint32_t arg2,
+typedef void (*OSFiberExEntryFn)(uint32_t arg1, uint32_t arg2, uint32_t arg3, uint32_t arg4);
-                                 uint32_t arg3, uint32_t arg4);
 
 int32_t
 OSSwitchFiber(OSFiberEntryFn entry,

include/coreinit/filesystem.h

@@ -1,10 +1,10 @@
 #pragma once
 #include <wut.h>
+#include <coreinit/alarm.h>
+#include <coreinit/fastmutex.h>
+#include <coreinit/ios.h>
 #include <coreinit/messagequeue.h>
 #include <coreinit/time.h>
-#include <coreinit/ios.h>
-#include <coreinit/fastmutex.h>
-#include <coreinit/alarm.h>
 
 /**
  * \defgroup coreinit_fs Filesystem
@@ -25,7 +25,7 @@
 extern "C" {
 #endif
 
-#define FS_MAX_PATH (0x27F)
+#define FS_MAX_PATH    (0x27F)
 #define FS_MODE_LENGTH (0x10)
 
 typedef uint32_t FSDirectoryHandle;
@@ -52,100 +52,100 @@ typedef struct FSVolumeInfo FSVolumeInfo;
 
 typedef enum FSErrorFlag
 {
-   FS_ERROR_FLAG_NONE               =  0x0,
+   FS_ERROR_FLAG_NONE             = 0x0,
-   FS_ERROR_FLAG_MAX                =  0x1,
+   FS_ERROR_FLAG_MAX              = 0x1,
-   FS_ERROR_FLAG_ALREADY_OPEN       =  0x2,
+   FS_ERROR_FLAG_ALREADY_OPEN     = 0x2,
-   FS_ERROR_FLAG_EXISTS             =  0x4,
+   FS_ERROR_FLAG_EXISTS           = 0x4,
-   FS_ERROR_FLAG_NOT_FOUND          =  0x8,
+   FS_ERROR_FLAG_NOT_FOUND        = 0x8,
-   FS_ERROR_FLAG_NOT_FILE           =  0x10,
+   FS_ERROR_FLAG_NOT_FILE         = 0x10,
-   FS_ERROR_FLAG_NOT_DIR            =  0x20,
+   FS_ERROR_FLAG_NOT_DIR          = 0x20,
-   FS_ERROR_FLAG_ACCESS_ERROR       =  0x40,
+   FS_ERROR_FLAG_ACCESS_ERROR     = 0x40,
-   FS_ERROR_FLAG_PERMISSION_ERROR   =  0x80,
+   FS_ERROR_FLAG_PERMISSION_ERROR = 0x80,
-   FS_ERROR_FLAG_FILE_TOO_BIG       =  0x100,
+   FS_ERROR_FLAG_FILE_TOO_BIG     = 0x100,
-   FS_ERROR_FLAG_STORAGE_FULL       =  0x200,
+   FS_ERROR_FLAG_STORAGE_FULL     = 0x200,
-   FS_ERROR_FLAG_UNSUPPORTED_CMD    =  0x400,
+   FS_ERROR_FLAG_UNSUPPORTED_CMD  = 0x400,
-   FS_ERROR_FLAG_JOURNAL_FULL       =  0x800,
+   FS_ERROR_FLAG_JOURNAL_FULL     = 0x800,
-   FS_ERROR_FLAG_ALL                =  0xFFFFFFFF,
+   FS_ERROR_FLAG_ALL              = 0xFFFFFFFF,
 } FSErrorFlag;
 
 typedef enum FSStatus
 {
-   FS_STATUS_OK                     = 0,
+   FS_STATUS_OK               = 0,
-   FS_STATUS_CANCELLED              = -1,
+   FS_STATUS_CANCELLED        = -1,
-   FS_STATUS_END                    = -2,
+   FS_STATUS_END              = -2,
-   FS_STATUS_MAX                    = -3,
+   FS_STATUS_MAX              = -3,
-   FS_STATUS_ALREADY_OPEN           = -4,
+   FS_STATUS_ALREADY_OPEN     = -4,
-   FS_STATUS_EXISTS                 = -5,
+   FS_STATUS_EXISTS           = -5,
-   FS_STATUS_NOT_FOUND              = -6,
+   FS_STATUS_NOT_FOUND        = -6,
-   FS_STATUS_NOT_FILE               = -7,
+   FS_STATUS_NOT_FILE         = -7,
-   FS_STATUS_NOT_DIR                = -8,
+   FS_STATUS_NOT_DIR          = -8,
-   FS_STATUS_ACCESS_ERROR           = -9,
+   FS_STATUS_ACCESS_ERROR     = -9,
-   FS_STATUS_PERMISSION_ERROR       = -10,
+   FS_STATUS_PERMISSION_ERROR = -10,
-   FS_STATUS_FILE_TOO_BIG           = -11,
+   FS_STATUS_FILE_TOO_BIG     = -11,
-   FS_STATUS_STORAGE_FULL           = -12,
+   FS_STATUS_STORAGE_FULL     = -12,
-   FS_STATUS_JOURNAL_FULL           = -13,
+   FS_STATUS_JOURNAL_FULL     = -13,
-   FS_STATUS_UNSUPPORTED_CMD        = -14,
+   FS_STATUS_UNSUPPORTED_CMD  = -14,
-   FS_STATUS_MEDIA_NOT_READY        = -15,
+   FS_STATUS_MEDIA_NOT_READY  = -15,
-   FS_STATUS_MEDIA_ERROR            = -17,
+   FS_STATUS_MEDIA_ERROR      = -17,
-   FS_STATUS_CORRUPTED              = -18,
+   FS_STATUS_CORRUPTED        = -18,
-   FS_STATUS_FATAL_ERROR            = -0x400,
+   FS_STATUS_FATAL_ERROR      = -0x400,
 } FSStatus;
 
 typedef enum FSError
 {
-   FS_ERROR_OK                      = 0,
+   FS_ERROR_OK                   = 0,
-   FS_ERROR_NOT_INIT                = -0x30001,
+   FS_ERROR_NOT_INIT             = -0x30001,
-   FS_ERROR_BUSY                    = -0x30002,
+   FS_ERROR_BUSY                 = -0x30002,
-   FS_ERROR_CANCELLED               = -0x30003,
+   FS_ERROR_CANCELLED            = -0x30003,
-   FS_ERROR_END_OF_DIR              = -0x30004,
+   FS_ERROR_END_OF_DIR           = -0x30004,
-   FS_ERROR_END_OF_FILE             = -0x30005,
+   FS_ERROR_END_OF_FILE          = -0x30005,
-   FS_ERROR_MAX_MOUNT_POINTS        = -0x30010,
+   FS_ERROR_MAX_MOUNT_POINTS     = -0x30010,
-   FS_ERROR_MAX_VOLUMES             = -0x30011,
+   FS_ERROR_MAX_VOLUMES          = -0x30011,
-   FS_ERROR_MAX_CLIENTS             = -0x30012,
+   FS_ERROR_MAX_CLIENTS          = -0x30012,
-   FS_ERROR_MAX_FILES               = -0x30013,
+   FS_ERROR_MAX_FILES            = -0x30013,
-   FS_ERROR_MAX_DIRS                = -0x30014,
+   FS_ERROR_MAX_DIRS             = -0x30014,
-   FS_ERROR_ALREADY_OPEN            = -0x30015,
+   FS_ERROR_ALREADY_OPEN         = -0x30015,
-   FS_ERROR_ALREADY_EXISTS          = -0x30016,
+   FS_ERROR_ALREADY_EXISTS       = -0x30016,
-   FS_ERROR_NOT_FOUND               = -0x30017,
+   FS_ERROR_NOT_FOUND            = -0x30017,
-   FS_ERROR_NOT_EMPTY               = -0x30018,
+   FS_ERROR_NOT_EMPTY            = -0x30018,
-   FS_ERROR_ACCESS_ERROR            = -0x30019,
+   FS_ERROR_ACCESS_ERROR         = -0x30019,
-   FS_ERROR_PERMISSION_ERROR        = -0x3001A,
+   FS_ERROR_PERMISSION_ERROR     = -0x3001A,
-   FS_ERROR_DATA_CORRUPTED          = -0x3001B,
+   FS_ERROR_DATA_CORRUPTED       = -0x3001B,
-   FS_ERROR_STORAGE_FULL            = -0x3001C,
+   FS_ERROR_STORAGE_FULL         = -0x3001C,
-   FS_ERROR_JOURNAL_FULL            = -0x3001D,
+   FS_ERROR_JOURNAL_FULL         = -0x3001D,
-   FS_ERROR_UNAVAILABLE_COMMAND     = -0x3001F,
+   FS_ERROR_UNAVAILABLE_COMMAND  = -0x3001F,
-   FS_ERROR_UNSUPPORTED_COMMAND     = -0x30020,
+   FS_ERROR_UNSUPPORTED_COMMAND  = -0x30020,
-   FS_ERROR_INVALID_PARAM           = -0x30021,
+   FS_ERROR_INVALID_PARAM        = -0x30021,
-   FS_ERROR_INVALID_PATH            = -0x30022,
+   FS_ERROR_INVALID_PATH         = -0x30022,
-   FS_ERROR_INVALID_BUFFER          = -0x30023,
+   FS_ERROR_INVALID_BUFFER       = -0x30023,
-   FS_ERROR_INVALID_ALIGNMENT       = -0x30024,
+   FS_ERROR_INVALID_ALIGNMENT    = -0x30024,
-   FS_ERROR_INVALID_CLIENTHANDLE    = -0x30025,
+   FS_ERROR_INVALID_CLIENTHANDLE = -0x30025,
-   FS_ERROR_INVALID_FILEHANDLE      = -0x30026,
+   FS_ERROR_INVALID_FILEHANDLE   = -0x30026,
-   FS_ERROR_INVALID_DIRHANDLE       = -0x30027,
+   FS_ERROR_INVALID_DIRHANDLE    = -0x30027,
-   FS_ERROR_NOT_FILE                = -0x30028,
+   FS_ERROR_NOT_FILE             = -0x30028,
-   FS_ERROR_NOT_DIR                 = -0x30029,
+   FS_ERROR_NOT_DIR              = -0x30029,
-   FS_ERROR_FILE_TOO_BIG            = -0x3002A,
+   FS_ERROR_FILE_TOO_BIG         = -0x3002A,
-   FS_ERROR_OUT_OF_RANGE            = -0x3002B,
+   FS_ERROR_OUT_OF_RANGE         = -0x3002B,
-   FS_ERROR_OUT_OF_RESOURCES        = -0x3002C,
+   FS_ERROR_OUT_OF_RESOURCES     = -0x3002C,
-   FS_ERROR_MEDIA_NOT_READY         = -0x30040,
+   FS_ERROR_MEDIA_NOT_READY      = -0x30040,
-   FS_ERROR_MEDIA_ERROR             = -0x30041,
+   FS_ERROR_MEDIA_ERROR          = -0x30041,
-   FS_ERROR_WRITE_PROTECTED         = -0x30042,
+   FS_ERROR_WRITE_PROTECTED      = -0x30042,
-   FS_ERROR_INVALID_MEDIA           = -0x30043,
+   FS_ERROR_INVALID_MEDIA        = -0x30043,
 } FSError;
 
 typedef enum FSMode
 {
-   FS_MODE_READ_OWNER                   = 0x400,
+   FS_MODE_READ_OWNER  = 0x400,
-   FS_MODE_WRITE_OWNER                  = 0x200,
+   FS_MODE_WRITE_OWNER = 0x200,
-   FS_MODE_EXEC_OWNER                   = 0x100,
+   FS_MODE_EXEC_OWNER  = 0x100,
 
-   FS_MODE_READ_GROUP                   = 0x040,
+   FS_MODE_READ_GROUP  = 0x040,
-   FS_MODE_WRITE_GROUP                  = 0x020,
+   FS_MODE_WRITE_GROUP = 0x020,
-   FS_MODE_EXEC_GROUP                   = 0x010,
+   FS_MODE_EXEC_GROUP  = 0x010,
 
-   FS_MODE_READ_OTHER                   = 0x004,
+   FS_MODE_READ_OTHER  = 0x004,
-   FS_MODE_WRITE_OTHER                  = 0x002,
+   FS_MODE_WRITE_OTHER = 0x002,
-   FS_MODE_EXEC_OTHER                   = 0x001,
+   FS_MODE_EXEC_OTHER  = 0x001,
 } FSMode;
 
 //! Flags for \link FSStat \endlink.
@@ -153,81 +153,84 @@ typedef enum FSMode
 typedef enum FSStatFlags
 {
    //! The retrieved file entry is a (link to a) directory.
-   FS_STAT_DIRECTORY                = 0x80000000,
+   FS_STAT_DIRECTORY      = 0x80000000,
    //! The retrieved file entry also has a quota set.
-   FS_STAT_QUOTA                    = 0x60000000,
+   FS_STAT_QUOTA          = 0x60000000,
    //! The retrieved file entry is a (link to a) file.
-   FS_STAT_FILE                     = 0x01000000,
+   FS_STAT_FILE           = 0x01000000,
    //! The retrieved file entry also is encrypted and can't be opened (see vWii files for example).
-   FS_STAT_ENCRYPTED_FILE           = 0x00800000,
+   FS_STAT_ENCRYPTED_FILE = 0x00800000,
    //! The retrieved file entry also is a link to a different file on the filesystem.
    //! Note: It's currently not known how one can read the linked-to file entry.
-   FS_STAT_LINK                     = 0x00010000,
+   FS_STAT_LINK           = 0x00010000,
 } FSStatFlags;
 
 typedef enum FSVolumeState
 {
-   FS_VOLUME_STATE_INITIAL          = 0,
+   FS_VOLUME_STATE_INITIAL         = 0,
-   FS_VOLUME_STATE_READY            = 1,
+   FS_VOLUME_STATE_READY           = 1,
-   FS_VOLUME_STATE_NO_MEDIA         = 2,
+   FS_VOLUME_STATE_NO_MEDIA        = 2,
-   FS_VOLUME_STATE_INVALID_MEDIA    = 3,
+   FS_VOLUME_STATE_INVALID_MEDIA   = 3,
-   FS_VOLUME_STATE_DIRTY_MEDIA      = 4,
+   FS_VOLUME_STATE_DIRTY_MEDIA     = 4,
-   FS_VOLUME_STATE_WRONG_MEDIA      = 5,
+   FS_VOLUME_STATE_WRONG_MEDIA     = 5,
-   FS_VOLUME_STATE_MEDIA_ERROR      = 6,
+   FS_VOLUME_STATE_MEDIA_ERROR     = 6,
-   FS_VOLUME_STATE_DATA_CORRUPTED   = 7,
+   FS_VOLUME_STATE_DATA_CORRUPTED  = 7,
-   FS_VOLUME_STATE_WRITE_PROTECTED  = 8,
+   FS_VOLUME_STATE_WRITE_PROTECTED = 8,
-   FS_VOLUME_STATE_JOURNAL_FULL     = 9,
+   FS_VOLUME_STATE_JOURNAL_FULL    = 9,
-   FS_VOLUME_STATE_FATAL            = 10,
+   FS_VOLUME_STATE_FATAL           = 10,
-   FS_VOLUME_STATE_INVALID          = 11,
+   FS_VOLUME_STATE_INVALID         = 11,
 } FSVolumeState;
 
-typedef enum FSMediaState {
+typedef enum FSMediaState
-    FS_MEDIA_STATE_READY = 0,
+{
-    FS_MEDIA_STATE_NO_MEDIA = 1,
+   FS_MEDIA_STATE_READY         = 0,
-    FS_MEDIA_STATE_INVALID_MEDIA = 2,
+   FS_MEDIA_STATE_NO_MEDIA      = 1,
-    FS_MEDIA_STATE_DIRTY_MEDIA = 3,
+   FS_MEDIA_STATE_INVALID_MEDIA = 2,
-    FS_MEDIA_STATE_MEDIA_ERROR = 4,
+   FS_MEDIA_STATE_DIRTY_MEDIA   = 3,
+   FS_MEDIA_STATE_MEDIA_ERROR   = 4,
 } FSMediaState;
 
-typedef enum FSMountSourceType {
+typedef enum FSMountSourceType
-    FS_MOUNT_SOURCE_SD  = 0,
+{
-    FS_MOUNT_SOURCE_UNK = 1,
+   FS_MOUNT_SOURCE_SD   = 0,
+   //! Devkit only API currently. Uses the PCFS channel to perform I/O operations on the attached host machine.
+   FS_MOUNT_SOURCE_HFIO = 1,
 } FSMountSourceType;
 
 typedef enum FSOpenFileFlags
 {
    //! Open file normally
-   FS_OPEN_FLAG_NONE = (0 << 0),
+   FS_OPEN_FLAG_NONE          = (0 << 0),
    //! Open (new) unencrypted file. Used for vWii files since it allows for direct access without the Wii U filesystem through it's block address.
-   FS_OPEN_FLAG_UNENCRYPTED = (1 << 0),
+   FS_OPEN_FLAG_UNENCRYPTED   = (1 << 0),
    //! Preallocates new file size using given size
    FS_OPEN_FLAG_PREALLOC_SIZE = (1 << 1)
 } FSOpenFileFlags;
 
-typedef void(*FSAsyncCallback)(FSClient *, FSCmdBlock *, FSStatus, uint32_t);
+typedef void (*FSAsyncCallback)(FSClient *, FSCmdBlock *, FSStatus, uint32_t);
-typedef void(*FSStateChangeCallback)(FSClient *, FSVolumeState, void *);
+typedef void (*FSStateChangeCallback)(FSClient *, FSVolumeState, void *);
 
 struct FSFsm
 {
-    WUT_UNKNOWN_BYTES(0x38);
+   WUT_UNKNOWN_BYTES(0x38);
 };
 WUT_CHECK_SIZE(FSFsm, 0x38);
 
 struct FSCmdQueue
 {
-    WUT_UNKNOWN_BYTES(0x44);
+   WUT_UNKNOWN_BYTES(0x44);
 };
 WUT_CHECK_SIZE(FSCmdQueue, 0x44);
 
 struct FSMessage
 {
-    //! Message data
+   //! Message data
-    void *data;
+   void *data;
 
-    WUT_UNKNOWN_BYTES(8);
+   WUT_UNKNOWN_BYTES(8);
 
-    //! Type of message
+   //! Type of message
-    OSFunctionType type;
+   OSFunctionType type;
 };
 WUT_CHECK_OFFSET(FSMessage, 0x00, data);
 WUT_CHECK_OFFSET(FSMessage, 0x0C, type);
@@ -238,8 +241,8 @@ WUT_CHECK_SIZE(FSMessage, 0x10);
  */
 struct FSClientBodyLink
 {
-    FSClientBody* next;
+   FSClientBody *next;
-    FSClientBody* prev;
+   FSClientBody *prev;
 };
 WUT_CHECK_OFFSET(FSClientBodyLink, 0x00, next);
 WUT_CHECK_OFFSET(FSClientBodyLink, 0x04, prev);
@@ -247,52 +250,52 @@ WUT_CHECK_SIZE(FSClientBodyLink, 0x8);
 
 struct FSClientBody
 {
-    WUT_UNKNOWN_BYTES(0x1444);
+   WUT_UNKNOWN_BYTES(0x1444);
 
-    //! IOSHandle returned from fsaShimOpen.
+   //! IOSHandle returned from fsaShimOpen.
-    IOSHandle clientHandle;
+   IOSHandle clientHandle;
 
-    //! State machine.
+   //! State machine.
-    FSFsm fsm;
+   FSFsm fsm;
 
-    //! Command queue of FS commands.
+   //! Command queue of FS commands.
-    FSCmdQueue cmdQueue;
+   FSCmdQueue cmdQueue;
 
-    //! The last dequeued command.
+   //! The last dequeued command.
-    FSCmdBlockBody* lastDequeuedCommand;
+   FSCmdBlockBody *lastDequeuedCommand;
 
-    //! Emulated error, set with FSSetEmulatedError.
+   //! Emulated error, set with FSSetEmulatedError.
-    FSError emulatedError;
+   FSError emulatedError;
 
-    WUT_UNKNOWN_BYTES(0x1560 - 0x14CC);
+   WUT_UNKNOWN_BYTES(0x1560 - 0x14CC);
 
-    //! Mutex used to protect FSClientBody data.
+   //! Mutex used to protect FSClientBody data.
-    OSFastMutex mutex;
+   OSFastMutex mutex;
 
-    WUT_UNKNOWN_BYTES(4);
+   WUT_UNKNOWN_BYTES(4);
 
-    //! Alarm used by fsm for unknown reasons.
+   //! Alarm used by fsm for unknown reasons.
-    OSAlarm fsmAlarm;
+   OSAlarm fsmAlarm;
 
-    //! Error of last FS command.
+   //! Error of last FS command.
-    FSError lastError;
+   FSError lastError;
 
-    bool isLastErrorWithoutVolume;
+   bool isLastErrorWithoutVolume;
 
-    //! Message used to send FsCmdHandler message when FSA async callback is received.
+   //! Message used to send FsCmdHandler message when FSA async callback is received.
-    FSMessage fsCmdHandlerMsg;
+   FSMessage fsCmdHandlerMsg;
 
-    //! Device name of the last mount source returned by FSGetMountSourceNext.
+   //! Device name of the last mount source returned by FSGetMountSourceNext.
-    char lastMountSourceDevice[0x10];
+   char lastMountSourceDevice[0x10];
 
-    //! Mount source type to find with FSGetMountSourceNext.
+   //! Mount source type to find with FSGetMountSourceNext.
-    FSMountSourceType findMountSourceType;
+   FSMountSourceType findMountSourceType;
 
-    //! Link used for linked list of clients.
+   //! Link used for linked list of clients.
-    FSClientBodyLink link;
+   FSClientBodyLink link;
 
-    //! Pointer to unaligned FSClient structure.
+   //! Pointer to unaligned FSClient structure.
-    FSClient* client;
+   FSClient *client;
 };
 WUT_CHECK_OFFSET(FSClientBody, 0x1444, clientHandle);
 WUT_CHECK_OFFSET(FSClientBody, 0x1448, fsm);
@@ -397,10 +400,11 @@ WUT_CHECK_OFFSET(FSAsyncResult, 0x20, block);
 WUT_CHECK_OFFSET(FSAsyncResult, 0x24, status);
 WUT_CHECK_SIZE(FSAsyncResult, 0x28);
 
-struct FSCmdBlockBody {
+struct FSCmdBlockBody
-    WUT_UNKNOWN_BYTES(0x96C);
+{
-    FSAsyncResult asyncResult;
+   WUT_UNKNOWN_BYTES(0x96C);
-    WUT_UNKNOWN_BYTES(0x68);
+   FSAsyncResult asyncResult;
+   WUT_UNKNOWN_BYTES(0x68);
 };
 WUT_CHECK_OFFSET(FSCmdBlockBody, 0x96C, asyncResult);
 WUT_CHECK_SIZE(FSCmdBlockBody, 0x9FC);
@@ -419,19 +423,20 @@ struct FSMountSource
 };
 WUT_CHECK_SIZE(FSMountSource, 0x300);
 
-struct WUT_PACKED FSVolumeInfo {
+struct WUT_PACKED FSVolumeInfo
-    uint32_t flags;
+{
-    FSMediaState mediaState;
+   uint32_t flags;
-    WUT_UNKNOWN_BYTES(0x4);
+   FSMediaState mediaState;
-    uint32_t unk0x0C;
+   WUT_UNKNOWN_BYTES(0x4);
-    uint32_t unk0x10;
+   uint32_t unk0x0C;
-    int32_t unk0x14;
+   uint32_t unk0x10;
-    int32_t unk0x18;
+   int32_t unk0x14;
-    WUT_UNKNOWN_BYTES(0x10);
+   int32_t unk0x18;
-    char volumeLabel[128];
+   WUT_UNKNOWN_BYTES(0x10);
-    char volumeId[128];
+   char volumeLabel[128];
-    char devicePath[16];
+   char volumeId[128];
-    char mountPath[128];
+   char devicePath[16];
+   char mountPath[128];
 };
 WUT_CHECK_OFFSET(FSVolumeInfo, 0x00, flags);
 WUT_CHECK_OFFSET(FSVolumeInfo, 0x04, mediaState);
@@ -450,22 +455,24 @@ WUT_CHECK_SIZE(FSVolumeInfo, 444);
  * Get an aligned FSClientBody from an FSClient.
  */
 static inline FSClientBody *
-FSGetClientBody(FSClient *client) {
+FSGetClientBody(FSClient *client)
+{
    if (!client) {
       return NULL;
    }
-   return (FSClientBody *) ((((uint32_t) client) + 0x3F) & ~0x3F);
+   return (FSClientBody *)((((uint32_t)client) + 0x3F) & ~0x3F);
 }
 
 /**
  * Get an aligned FSCmdBlockBody from an FSCmdBlock.
  */
 static inline FSCmdBlockBody *
-FSGetCmdBlockBody(FSCmdBlock *cmdBlock) {
+FSGetCmdBlockBody(FSCmdBlock *cmdBlock)
+{
    if (!cmdBlock) {
       return NULL;
    }
-   return (FSCmdBlockBody *) ((((uint32_t) cmdBlock) + 0x3F) & ~0x3F);
+   return (FSCmdBlockBody *)((((uint32_t)cmdBlock) + 0x3F) & ~0x3F);
 }
 
 void
@@ -536,16 +543,16 @@ FSGetStatAsync(FSClient *client,
 
 FSStatus
 FSRemove(FSClient *client,
-          FSCmdBlock *block,
+         FSCmdBlock *block,
-          const char *path,
+         const char *path,
-          FSErrorFlag errorMask);
+         FSErrorFlag errorMask);
 
 FSStatus
 FSRemoveAsync(FSClient *client,
-          FSCmdBlock *block,
+              FSCmdBlock *block,
-          const char *path,
+              const char *path,
-          FSErrorFlag errorMask,
+              FSErrorFlag errorMask,
-          FSAsyncData *asyncData);
+              FSAsyncData *asyncData);
 
 
 FSStatus
@@ -624,10 +631,10 @@ FSMakeDir(FSClient *client,
 
 FSStatus
 FSMakeDirAsync(FSClient *client,
-          FSCmdBlock *block,
+               FSCmdBlock *block,
-          const char *path,
+               const char *path,
-          FSErrorFlag errorMask,
+               FSErrorFlag errorMask,
-          FSAsyncData *asyncData);
+               FSAsyncData *asyncData);
 
 FSStatus
 FSReadDir(FSClient *client,
@@ -646,9 +653,9 @@ FSReadDirAsync(FSClient *client,
 
 FSStatus
 FSRewindDir(FSClient *client,
-           FSCmdBlock *block,
+            FSCmdBlock *block,
-           FSDirectoryHandle handle,
+            FSDirectoryHandle handle,
-           FSErrorFlag errorMask);
+            FSErrorFlag errorMask);
 
 FSStatus
 FSCloseDir(FSClient *client,
@@ -657,18 +664,18 @@ FSCloseDir(FSClient *client,
            FSErrorFlag errorMask);
 
 FSStatus
-FSGetVolumeInfo(FSClient *client, 
+FSGetVolumeInfo(FSClient *client,
-                FSCmdBlock *block, 
+                FSCmdBlock *block,
-                const char *path, 
+                const char *path,
-                FSVolumeInfo *volumeInfo, 
+                FSVolumeInfo *volumeInfo,
-                FSErrorFlag  errorMask);
+                FSErrorFlag errorMask);
 
 FSStatus
-FSGetVolumeInfoAsync(FSClient *client, 
+FSGetVolumeInfoAsync(FSClient *client,
-                     FSCmdBlock *block, 
+                     FSCmdBlock *block,
-                     const char *path, 
+                     const char *path,
-                     FSVolumeInfo *volumeInfo, 
+                     FSVolumeInfo *volumeInfo,
-                     FSErrorFlag  errorMask,
+                     FSErrorFlag errorMask,
                      FSAsyncData *asyncData);
 
 FSStatus
@@ -770,47 +777,47 @@ FSReadFileWithPosAsync(FSClient *client,
 
 FSStatus
 FSWriteFile(FSClient *client,
-           FSCmdBlock *block,
+            FSCmdBlock *block,
-           uint8_t *buffer,
+            uint8_t *buffer,
-           uint32_t size,
+            uint32_t size,
-           uint32_t count,
+            uint32_t count,
-           FSFileHandle handle,
+            FSFileHandle handle,
-           uint32_t unk1,
+            uint32_t unk1,
-           FSErrorFlag errorMask);
+            FSErrorFlag errorMask);
 
 FSStatus
 FSWriteFileAsync(FSClient *client,
-                FSCmdBlock *block,
+                 FSCmdBlock *block,
-                uint8_t *buffer,
+                 uint8_t *buffer,
-                uint32_t size,
+                 uint32_t size,
-                uint32_t count,
+                 uint32_t count,
-                FSFileHandle handle,
+                 FSFileHandle handle,
-                uint32_t unk1,
+                 uint32_t unk1,
-                FSErrorFlag errorMask,
+                 FSErrorFlag errorMask,
-                FSAsyncData *asyncData);
+                 FSAsyncData *asyncData);
 
 FSStatus
 FSWriteFileWithPos(FSClient *client,
-                  FSCmdBlock *block,
+                   FSCmdBlock *block,
-                  uint8_t *buffer,
+                   uint8_t *buffer,
-                  uint32_t size,
+                   uint32_t size,
-                  uint32_t count,
+                   uint32_t count,
-                  uint32_t pos,
+                   uint32_t pos,
-                  FSFileHandle handle,
+                   FSFileHandle handle,
-                  uint32_t unk1,
+                   uint32_t unk1,
-                  FSErrorFlag errorMask);
+                   FSErrorFlag errorMask);
 
 FSStatus
 FSWriteFileWithPosAsync(FSClient *client,
-                       FSCmdBlock *block,
+                        FSCmdBlock *block,
-                       uint8_t *buffer,
+                        uint8_t *buffer,
-                       uint32_t size,
+                        uint32_t size,
-                       uint32_t count,
+                        uint32_t count,
-                       uint32_t pos,
+                        uint32_t pos,
-                       FSFileHandle handle,
+                        FSFileHandle handle,
-                       uint32_t unk1,
+                        uint32_t unk1,
-                       FSErrorFlag errorMask,
+                        FSErrorFlag errorMask,
-                       FSAsyncData *asyncData);
+                        FSAsyncData *asyncData);
 
 FSStatus
 FSGetPosFile(FSClient *client,
@@ -844,44 +851,44 @@ FSSetPosFileAsync(FSClient *client,
 
 FSStatus
 FSFlushFile(FSClient *client,
-             FSCmdBlock *block,
+            FSCmdBlock *block,
-             FSFileHandle handle,
+            FSFileHandle handle,
-             FSErrorFlag errorMask);
+            FSErrorFlag errorMask);
 
 FSStatus
 FSFlushFileAsync(FSClient *client,
-                  FSCmdBlock *block,
+                 FSCmdBlock *block,
-                  FSFileHandle handle,
+                 FSFileHandle handle,
-                  FSErrorFlag errorMask,
+                 FSErrorFlag errorMask,
-                  FSAsyncData *asyncData);
+                 FSAsyncData *asyncData);
 
 FSStatus
 FSTruncateFile(FSClient *client,
-             FSCmdBlock *block,
+               FSCmdBlock *block,
-             FSFileHandle handle,
+               FSFileHandle handle,
-             FSErrorFlag errorMask);
+               FSErrorFlag errorMask);
 
 FSStatus
 FSTruncateFileAsync(FSClient *client,
-                  FSCmdBlock *block,
+                    FSCmdBlock *block,
-                  FSFileHandle handle,
+                    FSFileHandle handle,
-                  FSErrorFlag errorMask,
+                    FSErrorFlag errorMask,
-                  FSAsyncData *asyncData);
+                    FSAsyncData *asyncData);
 
 FSStatus
 FSRename(FSClient *client,
-          FSCmdBlock *block,
+         FSCmdBlock *block,
-          const char *oldPath,
+         const char *oldPath,
-          const char *newPath,
+         const char *newPath,
-          FSErrorFlag errorMask);
+         FSErrorFlag errorMask);
 
 FSStatus
 FSRenameAsync(FSClient *client,
-          FSCmdBlock *block,
+              FSCmdBlock *block,
-          const char *oldPath,
+              const char *oldPath,
-          const char *newPath,
+              const char *newPath,
-          FSErrorFlag errorMask,
+              FSErrorFlag errorMask,
-          FSAsyncData *asyncData);
+              FSAsyncData *asyncData);
 
 FSVolumeState
 FSGetVolumeState(FSClient *client);

include/coreinit/im.h

@@ -16,8 +16,28 @@ extern "C" {
 typedef struct IMRequest IMRequest;
 typedef struct IMHomeButtonParams IMHomeButtonParams;
 typedef struct IMParameters IMParameters;
+typedef struct IMDeviceStateEx IMDeviceStateEx;
 typedef uint32_t IMEventMask;
 
+typedef enum IMPadType
+{
+   IM_PAD_TYPE_NONE                 = 0,
+   IM_PAD_TYPE_WII_REMOTE           = 1,
+   IM_PAD_TYPE_WIIU_PRO_CONTROLLER  = 2,
+   IM_PAD_TYPE_WII_REMOTE_EXTENSION = 3,
+   IM_PAD_TYPE_WIIU_GAMEPAD         = 4,
+} IMPadType;
+
+typedef enum IMDeviceState
+{
+   IM_DEVICE_STATE_CLEAR    = 0,
+   IM_DEVICE_STATE_INACTIVE = 1,
+   IM_DEVICE_STATE_ACTIVE   = 2,
+   IM_DEVICE_STATE_HOME     = 3,
+   IM_DEVICE_STATE_POWER    = 4,
+   IM_DEVICE_STATE_SYNC     = 5,
+} IMDeviceState;
+
 struct WUT_PACKED IMRequest
 {
    uint8_t args[0x80];
@@ -42,8 +62,13 @@ WUT_CHECK_SIZE(IMRequest, 0xB4);
 
 struct IMHomeButtonParams
 {
-    WUT_UNKNOWN_BYTES(0x8);
+   //! The controller type which pressed the home button
+   IMPadType type;
+   //! The controller index which pressed the home button
+   int32_t index;
 };
+WUT_CHECK_OFFSET(IMHomeButtonParams, 0x0, type);
+WUT_CHECK_OFFSET(IMHomeButtonParams, 0x4, index);
 WUT_CHECK_SIZE(IMHomeButtonParams, 0x8);
 
 struct IMParameters
@@ -61,20 +86,29 @@ WUT_CHECK_OFFSET(IMParameters, 0x0C, apdEnabled);
 WUT_CHECK_OFFSET(IMParameters, 0x10, apdPeriod);
 WUT_CHECK_SIZE(IMParameters, 0x14);
 
+struct IMDeviceStateEx
+{
+   IMDeviceState state;
+   IMHomeButtonParams params;
+};
+WUT_CHECK_OFFSET(IMDeviceStateEx, 0x0, state);
+WUT_CHECK_OFFSET(IMDeviceStateEx, 0x4, params);
+WUT_CHECK_SIZE(IMDeviceStateEx, 0xC);
+
 typedef enum IMParameter
 {
-   IM_PARAMETER_INACTIVE_SECONDS     = 0,
+   IM_PARAMETER_INACTIVE_SECONDS = 0,
-   IM_PARAMETER_DIM_ENABLED          = 1,
+   IM_PARAMETER_DIM_ENABLED      = 1,
-   IM_PARAMETER_DIM_PERIOD           = 2,
+   IM_PARAMETER_DIM_PERIOD       = 2,
-   IM_PARAMETER_APD_ENABLED          = 3,
+   IM_PARAMETER_APD_ENABLED      = 3,
-   IM_PARAMETER_APD_PERIOD           = 4,
+   IM_PARAMETER_APD_PERIOD       = 4,
-   IM_PARAMETER_RESET_ENABLE         = 5,
+   IM_PARAMETER_RESET_ENABLE     = 5,
-   IM_PARAMETER_RESET_SECONDS        = 6,
+   IM_PARAMETER_RESET_SECONDS    = 6,
-   IM_PARAMETER_POWER_OFF_ENABLE     = 7,
+   IM_PARAMETER_POWER_OFF_ENABLE = 7,
-   IM_PARAMETER_APD_OCCURED          = 8,
+   IM_PARAMETER_APD_OCCURED      = 8,
-   IM_PARAMETER_DIM_ENABLE_TV        = 9,
+   IM_PARAMETER_DIM_ENABLE_TV    = 9,
-   IM_PARAMETER_DIM_ENABLE_DRC       = 10,
+   IM_PARAMETER_DIM_ENABLE_DRC   = 10,
-   IM_PARAMETER_MAX                  = 11,
+   IM_PARAMETER_MAX              = 11,
 } IMParameter;
 
 typedef enum IMTimer
@@ -85,14 +119,21 @@ typedef enum IMTimer
 
 typedef enum IMEvent
 {
-   IM_EVENT_UNK1 = 1 << 1,
+   IM_EVENT_ACTIVE    = 1 << 0,
-   IM_EVENT_UNK2 = 1 << 2,
+   IM_EVENT_INACTIVE  = 1 << 1,
-   IM_EVENT_UNK3 = 1 << 3,
+   IM_EVENT_DIM       = 1 << 2,
-   IM_EVENT_APD  = 1 << 4,
+   IM_EVENT_UNDIM     = 1 << 3,
-   IM_EVENT_UNK5 = 1 << 5,
+   //! Automatic power down
-   IM_EVENT_UNK6 = 1 << 6,
+   IM_EVENT_APD       = 1 << 4,
-   IM_EVENT_SYNC = 1 << 7,
+   //! Controller power button was pressed
-   IM_EVENT_UNK8 = 1 << 8,
+   IM_EVENT_POWER     = 1 << 5,
+   //! Home button was pressed
+   IM_EVENT_HOME      = 1 << 6,
+   //! Console sync button was pressed
+   IM_EVENT_SYNC      = 1 << 7,
+   IM_EVENT_RESET     = 1 << 8,
+   //! Event notify was cancelled
+   IM_EVENT_CANCELLED = 1 << 31,
 } IMEvent;
 
 IOSHandle
@@ -117,7 +158,7 @@ IM_GetParameter(IOSHandle handle,
                 void *asyncCallbackContext);
 
 IOSError
-IM_GetParameters(IMParameters* parameters);
+IM_GetParameters(IMParameters *parameters);
 
 IOSError
 IM_GetNvParameter(IOSHandle handle,
@@ -172,6 +213,20 @@ IM_CancelGetEventNotify(IOSHandle handle,
                         IOSAsyncCallbackFn asyncCallback,
                         void *asyncCallbackContext);
 
+IOSError
+IM_SetDeviceState(IOSHandle handle,
+                  IMRequest *request,
+                  IMDeviceState state,
+                  IOSAsyncCallbackFn asyncCallback,
+                  void *asyncCallbackContext);
+
+IOSError
+IM_SetDeviceStateEx(IOSHandle handle,
+                    IMRequest *request,
+                    IMDeviceStateEx *state,
+                    IOSAsyncCallbackFn asyncCallback,
+                    void *asyncCallbackContext);
+
 #ifdef __cplusplus
 }
 #endif

include/coreinit/internal.h

@@ -6,7 +6,11 @@ extern "C" {
 #endif
 
 int
-__os_snprintf(char *buf, size_t n, const char *format, ... );
+__os_snprintf(char *buf,
+              size_t n,
+              const char *format,
+              ...)
+   WUT_FORMAT_PRINTF(3, 4);
 
 #ifdef __cplusplus
 }

include/coreinit/interrupts.h

@@ -29,8 +29,8 @@ typedef enum OSInterruptType
    OS_INTERRUPT_TYPE_AHB        = 12
 } OSInterruptType;
 
-typedef void(*OSUserInterruptHandler)(OSInterruptType type, OSContext* interruptedContext);
+typedef void (*OSUserInterruptHandler)(OSInterruptType type, OSContext *interruptedContext);
-   
+
 BOOL
 OSEnableInterrupts();
 

include/coreinit/ios.h

@@ -16,56 +16,56 @@ typedef int32_t IOSHandle;
 
 typedef enum IOSOpenMode
 {
-   IOS_OPEN_READ        = 1 << 0,
+   IOS_OPEN_READ      = 1 << 0,
-   IOS_OPEN_WRITE       = 1 << 1,
+   IOS_OPEN_WRITE     = 1 << 1,
-   IOS_OPEN_READWRITE   = IOS_OPEN_READ | IOS_OPEN_WRITE,
+   IOS_OPEN_READWRITE = IOS_OPEN_READ | IOS_OPEN_WRITE,
 } IOSOpenMode;
 
 typedef enum IOSError
 {
-   IOS_ERROR_OK                  = 0,
+   IOS_ERROR_OK                = 0,
-   IOS_ERROR_ACCESS              = -1,
+   IOS_ERROR_ACCESS            = -1,
-   IOS_ERROR_EXISTS              = -2,
+   IOS_ERROR_EXISTS            = -2,
-   IOS_ERROR_INTR                = -3,
+   IOS_ERROR_INTR              = -3,
-   IOS_ERROR_INVALID             = -4,
+   IOS_ERROR_INVALID           = -4,
-   IOS_ERROR_MAX                 = -5,
+   IOS_ERROR_MAX               = -5,
-   IOS_ERROR_NOEXISTS            = -6,
+   IOS_ERROR_NOEXISTS          = -6,
-   IOS_ERROR_QEMPTY              = -7,
+   IOS_ERROR_QEMPTY            = -7,
-   IOS_ERROR_QFULL               = -8,
+   IOS_ERROR_QFULL             = -8,
-   IOS_ERROR_UNKNOWN             = -9,
+   IOS_ERROR_UNKNOWN           = -9,
-   IOS_ERROR_NOTREADY            = -10,
+   IOS_ERROR_NOTREADY          = -10,
-   IOS_ERROR_ECC                 = -11,
+   IOS_ERROR_ECC               = -11,
-   IOS_ERROR_ECCCRIT             = -12,
+   IOS_ERROR_ECCCRIT           = -12,
-   IOS_ERROR_BADBLOCK            = -13,
+   IOS_ERROR_BADBLOCK          = -13,
-   IOS_ERROR_INVALIDOBJTYPE      = -14,
+   IOS_ERROR_INVALIDOBJTYPE    = -14,
-   IOS_ERROR_INVALIDRNG          = -15,
+   IOS_ERROR_INVALIDRNG        = -15,
-   IOS_ERROR_INVALIDFLAG         = -16,
+   IOS_ERROR_INVALIDFLAG       = -16,
-   IOS_ERROR_INVALIDFORMAT       = -17,
+   IOS_ERROR_INVALIDFORMAT     = -17,
-   IOS_ERROR_INVALIDVERSION      = -18,
+   IOS_ERROR_INVALIDVERSION    = -18,
-   IOS_ERROR_INVALIDSIGNER       = -19,
+   IOS_ERROR_INVALIDSIGNER     = -19,
-   IOS_ERROR_FAILCHECKVALUE      = -20,
+   IOS_ERROR_FAILCHECKVALUE    = -20,
-   IOS_ERROR_FAILINTERNAL        = -21,
+   IOS_ERROR_FAILINTERNAL      = -21,
-   IOS_ERROR_FAILALLOC           = -22,
+   IOS_ERROR_FAILALLOC         = -22,
-   IOS_ERROR_INVALIDSIZE         = -23,
+   IOS_ERROR_INVALIDSIZE       = -23,
-   IOS_ERROR_NOLINK              = -24,
+   IOS_ERROR_NOLINK            = -24,
-   IOS_ERROR_ANFAILED            = -25,
+   IOS_ERROR_ANFAILED          = -25,
-   IOS_ERROR_MAXSEMCOUNT         = -26,
+   IOS_ERROR_MAXSEMCOUNT       = -26,
-   IOS_ERROR_SEMUNAVAILABLE      = -27,
+   IOS_ERROR_SEMUNAVAILABLE    = -27,
-   IOS_ERROR_INVALIDHANDLE       = -28,
+   IOS_ERROR_INVALIDHANDLE     = -28,
-   IOS_ERROR_INVALIDARG          = -29,
+   IOS_ERROR_INVALIDARG        = -29,
-   IOS_ERROR_NORESOURCE          = -30,
+   IOS_ERROR_NORESOURCE        = -30,
-   IOS_ERROR_BUSY                = -31,
+   IOS_ERROR_BUSY              = -31,
-   IOS_ERROR_TIMEOUT             = -32,
+   IOS_ERROR_TIMEOUT           = -32,
-   IOS_ERROR_ALIGNMENT           = -33,
+   IOS_ERROR_ALIGNMENT         = -33,
-   IOS_ERROR_BSP                 = -34,
+   IOS_ERROR_BSP               = -34,
-   IOS_ERROR_DATAPENDING         = -35,
+   IOS_ERROR_DATAPENDING       = -35,
-   IOS_ERROR_EXPIRED             = -36,
+   IOS_ERROR_EXPIRED           = -36,
-   IOS_ERROR_NOREADACCESS        = -37,
+   IOS_ERROR_NOREADACCESS      = -37,
-   IOS_ERROR_NOWRITEACCESS       = -38,
+   IOS_ERROR_NOWRITEACCESS     = -38,
-   IOS_ERROR_NOREADWRITEACCESS   = -39,
+   IOS_ERROR_NOREADWRITEACCESS = -39,
-   IOS_ERROR_CLIENTTXNLIMIT      = -40,
+   IOS_ERROR_CLIENTTXNLIMIT    = -40,
-   IOS_ERROR_STALEHANDLE         = -41,
+   IOS_ERROR_STALEHANDLE       = -41,
-   IOS_ERROR_UNKNOWNVALUE        = -42,
+   IOS_ERROR_UNKNOWNVALUE      = -42,
 } IOSError;
 
 struct IOSVec

include/coreinit/ipcbufpool.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include <wut.h>
-#include "mutex.h"
 #include "ios.h"
+#include "mutex.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -17,21 +17,22 @@ typedef struct IPCBufPool IPCBufPool;
 *
 * Functions similar to a ring buffer.
 */
-struct IPCBufPoolFIFO {
+struct IPCBufPoolFIFO
-    //! The current message index to push to.
+{
-    int32_t pushIndex;
+   //! The current message index to push to.
+   int32_t pushIndex;
 
-    //! The current message index to pop from.
+   //! The current message index to pop from.
-    int32_t popIndex;
+   int32_t popIndex;
 
-    //! The number of messages in the queue.
+   //! The number of messages in the queue.
-    int32_t count;
+   int32_t count;
 
-    //! Tracks the total number of messages in the count.
+   //! Tracks the total number of messages in the count.
-    int32_t maxCount;
+   int32_t maxCount;
 
-    //! Messages in the queue.
+   //! Messages in the queue.
-    void **messages;
+   void **messages;
 };
 WUT_CHECK_OFFSET(IPCBufPoolFIFO, 0x00, pushIndex);
 WUT_CHECK_OFFSET(IPCBufPoolFIFO, 0x04, popIndex);
@@ -43,15 +44,16 @@ WUT_CHECK_SIZE(IPCBufPoolFIFO, 0x14);
 /**
  * Attributes returned by IPCBufPoolGetAttributes.
  */
-struct IPCBufPoolAttributes {
+struct IPCBufPoolAttributes
-    //! Size of a message in the buffer pool.
+{
-    uint32_t messageSize;
+   //! Size of a message in the buffer pool.
+   uint32_t messageSize;
 
-    //! Size of the buffer pool.
+   //! Size of the buffer pool.
-    uint32_t poolSize;
+   uint32_t poolSize;
 
-    //! Number of pending messages in the pool fifo.
+   //! Number of pending messages in the pool fifo.
-    uint32_t numMessages;
+   uint32_t numMessages;
 };
 WUT_CHECK_OFFSET(IPCBufPoolAttributes, 0x00, messageSize);
 WUT_CHECK_OFFSET(IPCBufPoolAttributes, 0x04, poolSize);
@@ -63,41 +65,42 @@ WUT_CHECK_SIZE(IPCBufPoolAttributes, 0x0C);
 /**
 * A simple message buffer pool used for IPC communication.
 */
-struct IPCBufPool {
+struct IPCBufPool
-    //! Magic header always set to IPCBufPool::MagicHeader.
+{
-    uint32_t magic;
+   //! Magic header always set to IPCBufPool::MagicHeader.
+   uint32_t magic;
 
-    //! Pointer to buffer used for this IPCBufPool.
+   //! Pointer to buffer used for this IPCBufPool.
-    void *buffer;
+   void *buffer;
 
-    //! Size of buffer.
+   //! Size of buffer.
-    uint32_t size;
+   uint32_t size;
 
-    uint32_t unk0x0C;
+   uint32_t unk0x0C;
-    uint32_t unk0x10;
+   uint32_t unk0x10;
 
-    //! Message size from IPCBufPoolCreate.
+   //! Message size from IPCBufPoolCreate.
-    uint32_t messageSize0x14;
+   uint32_t messageSize0x14;
 
-    //! Message size from IPCBufPoolCreate.
+   //! Message size from IPCBufPoolCreate.
-    uint32_t messageSize0x18;
+   uint32_t messageSize0x18;
 
-    //! Number of messages in the IPCBufPoolFIFO.
+   //! Number of messages in the IPCBufPoolFIFO.
-    uint32_t messageCount;
+   uint32_t messageCount;
 
-    //! Pointer to start of messages.
+   //! Pointer to start of messages.
-    void *messages;
+   void *messages;
 
-    //! Number of bytes used for the message pointers in IPCBufPoolFIFO.
+   //! Number of bytes used for the message pointers in IPCBufPoolFIFO.
-    uint32_t *messageIndexSize;
+   uint32_t *messageIndexSize;
 
-    //! FIFO queue of messages.
+   //! FIFO queue of messages.
-    IPCBufPoolFIFO fifo;
+   IPCBufPoolFIFO fifo;
 
-    //! Mutex used to secure access to fifo.
+   //! Mutex used to secure access to fifo.
-    OSMutex mutex;
+   OSMutex mutex;
 
-    WUT_UNKNOWN_BYTES(0x04);
+   WUT_UNKNOWN_BYTES(0x04);
 };
 WUT_CHECK_OFFSET(IPCBufPool, 0x00, magic);
 WUT_CHECK_OFFSET(IPCBufPool, 0x04, buffer);

include/coreinit/kernel.h

@@ -12,86 +12,90 @@
 extern "C" {
 #endif
 
-typedef enum OSICICommand {
+typedef enum OSICICommand
-    OS_ICI_COMMAND_INVALID_IC_RANGE     = 1,
+{
-    OS_ICI_COMMAND_RESCHEDULE_CORE      = 2,
+   OS_ICI_COMMAND_INVALID_IC_RANGE     = 1,
-    OS_ICI_COMMAND_HALT_CORE            = 3,
+   OS_ICI_COMMAND_RESCHEDULE_CORE      = 2,
-    OS_ICI_COMMAND_PROC_EXIT            = 4,
+   OS_ICI_COMMAND_HALT_CORE            = 3,
-    OS_ICI_COMMAND_SET_DABR             = 5,
+   OS_ICI_COMMAND_PROC_EXIT            = 4,
-    OS_ICI_COMMAND_PROC_SCHED           = 6,
+   OS_ICI_COMMAND_SET_DABR             = 5,
-    OS_ICI_COMMAND_FAST_BG_EXIT         = 7,
+   OS_ICI_COMMAND_PROC_SCHED           = 6,
-    OS_ICI_COMMAND_IOP_SHELL_CORE_TRACE = 8,
+   OS_ICI_COMMAND_FAST_BG_EXIT         = 7,
-    OS_ICI_COMMAND_SYSTEM_FATAL         = 9,
+   OS_ICI_COMMAND_IOP_SHELL_CORE_TRACE = 8,
-    OS_ICI_COMMAND_SET_IABR             = 10,
+   OS_ICI_COMMAND_SYSTEM_FATAL         = 9,
-    OS_ICI_COMMAND_PANIC_0X15           = 0xB,
+   OS_ICI_COMMAND_SET_IABR             = 10,
-    OS_ICI_COMMAND_PROC_KILL            = 0xC,
+   OS_ICI_COMMAND_PANIC_0X15           = 0xB,
-    OS_ICI_COMMAND_PROC_CRASH           = 0xD,
+   OS_ICI_COMMAND_PROC_KILL            = 0xC,
-    OS_ICI_COMMAND_UNKNOWN              = 0xE, // Waits for rendezvous, then updates heartbeat
+   OS_ICI_COMMAND_PROC_CRASH           = 0xD,
-    OS_ICI_COMMAND_OVERLAY_ARENA        = 0xF,
+   OS_ICI_COMMAND_UNKNOWN              = 0xE, // Waits for rendezvous, then updates heartbeat
+   OS_ICI_COMMAND_OVERLAY_ARENA        = 0xF,
 } OSICICommand;
 
-typedef void (*OSExceptionCallbackExFn)(OSExceptionType exceptionType, OSContext * interruptedContext, OSContext *cbContext);
+typedef void (*OSExceptionCallbackExFn)(OSExceptionType exceptionType, OSContext *interruptedContext, OSContext *cbContext);
 
 typedef void (*KernelTimerCallbackFn)(OSExceptionType exception, OSContext *interruptedContext, OSContext *currentContext);
 
 typedef uint32_t KernelTimerHandle;
 
-typedef struct OSExceptionChainInfo {
+typedef struct OSExceptionChainInfo
-    OSExceptionCallbackExFn callback;
+{
-    void *stack;
+   OSExceptionCallbackExFn callback;
-    OSContext *context;
+   void *stack;
+   OSContext *context;
 } OSExceptionChainInfo;
 WUT_CHECK_OFFSET(OSExceptionChainInfo, 0, callback);
 WUT_CHECK_OFFSET(OSExceptionChainInfo, 4, stack);
 WUT_CHECK_OFFSET(OSExceptionChainInfo, 8, context);
 WUT_CHECK_SIZE(OSExceptionChainInfo, 12);
 
-typedef struct KernelInfo0 {
+typedef struct KernelInfo0
-    struct CoreinitInfo {
+{
-        void *loaderHandle;
+   struct CoreinitInfo
-        void *textAddr;
+   {
-        uint32_t textOffset;
+      void *loaderHandle;
-        uint32_t textSize;
+      void *textAddr;
-        void *dataAddr;
+      uint32_t textOffset;
-        uint32_t dataOffset;
+      uint32_t textSize;
-        uint32_t dataSize;
+      void *dataAddr;
-        void *loadAddr;
+      uint32_t dataOffset;
-        uint32_t loadOffset;
+      uint32_t dataSize;
-        uint32_t loadSize;
+      void *loadAddr;
-    };
+      uint32_t loadOffset;
+      uint32_t loadSize;
+   };
 
-    int32_t upid;
+   int32_t upid;
-    int32_t rampid;
+   int32_t rampid;
-    uint32_t appFlags;
+   uint32_t appFlags;
-    void *dataAreaStart;
+   void *dataAreaStart;
-    void *dataAreaEnd;
+   void *dataAreaEnd;
-    void *physDataAreaStart;
+   void *physDataAreaStart;
-    void *physDataAreaEnd;
+   void *physDataAreaEnd;
-    void *physAvailStart;
+   void *physAvailStart;
-    void *physAvailEnd;
+   void *physAvailEnd;
-    void *physCodeGenStart;
+   void *physCodeGenStart;
-    void *physCodeGenEnd;
+   void *physCodeGenEnd;
-    void *sdaBase;
+   void *sdaBase;
-    void *sda2Base;
+   void *sda2Base;
-    uint32_t systemHeapSize;
+   uint32_t systemHeapSize;
-    void *stackEnd0;
+   void *stackEnd0;
-    void *stackEnd1;
+   void *stackEnd1;
-    void *stackEnd2;
+   void *stackEnd2;
-    void *stackBase0;
+   void *stackBase0;
-    void *stackBase1;
+   void *stackBase1;
-    void *stackBase2;
+   void *stackBase2;
-    void *exceptionStackEnd0;
+   void *exceptionStackEnd0;
-    void *exceptionStackEnd1;
+   void *exceptionStackEnd1;
-    void *exceptionStackEnd2;
+   void *exceptionStackEnd2;
-    void *exceptionStackBase0;
+   void *exceptionStackBase0;
-    void *exceptionStackBase1;
+   void *exceptionStackBase1;
-    void *exceptionStackBase2;
+   void *exceptionStackBase2;
-    void *lockedCacheBase0;
+   void *lockedCacheBase0;
-    void *lockedCacheBase1;
+   void *lockedCacheBase1;
-    void *lockedCacheBase2;
+   void *lockedCacheBase2;
-    struct CoreinitInfo coreinit;
+   struct CoreinitInfo coreinit;
-    uint32_t unk0x9C;
+   uint32_t unk0x9C;
-    uint64_t titleId;
+   uint64_t titleId;
 } KernelInfo0;
 WUT_CHECK_OFFSET(KernelInfo0, 0x00, upid);
 WUT_CHECK_OFFSET(KernelInfo0, 0x04, rampid);
@@ -127,23 +131,43 @@ WUT_CHECK_OFFSET(KernelInfo0, 0x9C, unk0x9C);
 WUT_CHECK_OFFSET(KernelInfo0, 0xA0, titleId);
 WUT_CHECK_SIZE(KernelInfo0, 0xA8);
 
-typedef struct KernelInfo6 {
+typedef struct KernelInfo6
-    uint64_t osTitleId;
+{
-    uint32_t unk0x08;
+   uint64_t osTitleId;
-    WUT_PADDING_BYTES(0x108 - 0xC);
+   uint32_t unk0x08;
+   WUT_PADDING_BYTES(0x108 - 0xC);
 } KernelInfo6;
 WUT_CHECK_OFFSET(KernelInfo6, 0x00, osTitleId);
 WUT_CHECK_OFFSET(KernelInfo6, 0x08, unk0x08);
 WUT_CHECK_SIZE(KernelInfo6, 0x108);
 
-void __KernelSetUserModeExHandler(OSExceptionType exceptionType, OSExceptionChainInfo *chainInfo, OSExceptionChainInfo *prevChainInfo);
+void
+__KernelSetUserModeExHandler(OSExceptionType exceptionType,
+                             OSExceptionChainInfo *chainInfo,
+                             OSExceptionChainInfo *prevChainInfo);
 
-KernelTimerHandle __KernelAllocateTimer(KernelTimerCallbackFn, void *exceptionStack, OSContext *context);
+KernelTimerHandle
-uint32_t __KernelPrimeTimer(KernelTimerHandle handle, uint64_t startTimeInTicks, uint64_t intervalInTicks, uint32_t unknown);
+__KernelAllocateTimer(KernelTimerCallbackFn,
+                      void *exceptionStack,
+                      OSContext *context);
 
-void __KernelSendICI(OSICICommand cmd, void *arg1, uint32_t unknown1, uint32_t unknown2);
+uint32_t
+__KernelPrimeTimer(KernelTimerHandle handle,
+                   uint64_t startTimeInTicks,
+                   uint64_t intervalInTicks,
+                   uint32_t unknown);
 
-void __KernelGetInfo(uint32_t type, void *outBuffer, uint32_t outBufferSize, uint32_t core);
+void
+__KernelSendICI(OSICICommand cmd,
+                void *arg1,
+                uint32_t unknown1,
+                uint32_t unknown2);
+
+void
+__KernelGetInfo(uint32_t type,
+                void *outBuffer,
+                uint32_t outBufferSize,
+                uint32_t core);
 
 static inline void
 __KernelGetInfo0(KernelInfo0 *outBuffer, uint32_t core)

include/coreinit/launch.h

@@ -20,7 +20,7 @@ extern "C" {
 /**
  * Magic title ID used for triggering a full system reboot.
  */
-#define OS_TITLE_ID_REBOOT 0xFFFFFFFFFFFFFFFEllu
+#define OS_TITLE_ID_REBOOT   0xFFFFFFFFFFFFFFFEllu
 
 /**
  * Forces a OS relaunch on the next title launch.

include/coreinit/mcp.h

@@ -24,72 +24,74 @@ typedef struct MCPTitleListType MCPTitleListType;
 
 typedef enum MCPAppType
 {
-   MCP_APP_TYPE_GAME_UPDATE            = 0x0800001B,
+   MCP_APP_TYPE_GAME_UPDATE           = 0x0800001B,
-   MCP_APP_TYPE_GAME_DLC               = 0x0800000E,
+   MCP_APP_TYPE_GAME_DLC              = 0x0800000E,
-   MCP_APP_TYPE_BOOT1                  = 0x10000009,
+   MCP_APP_TYPE_BOOT1                 = 0x10000009,
-   MCP_APP_TYPE_SYSTEM_LIBRARIES       = 0x1000000A,
+   MCP_APP_TYPE_SYSTEM_LIBRARIES      = 0x1000000A,
-   MCP_APP_TYPE_BLUETOOTH_FIRMWARE     = 0x10000012,
+   MCP_APP_TYPE_BLUETOOTH_FIRMWARE    = 0x10000012,
-   MCP_APP_TYPE_DRH_FIRMWARE           = 0x10000013,
+   MCP_APP_TYPE_DRC_FIRMWARE          = 0x10000013,
-   MCP_APP_TYPE_DRC_FIRMWARE           = 0x10000014,
+   MCP_APP_TYPE_DRH_FIRMWARE          = 0x10000014,
-   MCP_APP_TYPE_SYSTEM_VERSION         = 0x10000015,
+   MCP_APP_TYPE_SYSTEM_VERSION        = 0x10000015,
-   MCP_APP_TYPE_DRC_LANGUAGE           = 0x1000001A,
+   MCP_APP_TYPE_DRC_LANGUAGE          = 0x1000001A,
-   MCP_APP_TYPE_EXCEPTIONS_DATA        = 0x18000010,
+   MCP_APP_TYPE_EXCEPTIONS_DATA       = 0x18000010,
-   MCP_APP_TYPE_SHARED_DATA            = 0x1800001C,
+   MCP_APP_TYPE_SHARED_DATA           = 0x1800001C,
-   MCP_APP_TYPE_CERT_STORE             = 0x1800001E,
+   MCP_APP_TYPE_CERT_STORE            = 0x1800001E,
-   MCP_APP_TYPE_PATCH_MAP_DATA         = 0x18000023,
+   MCP_APP_TYPE_PATCH_MAP_DATA        = 0x18000023,
-   MCP_APP_TYPE_WAGONU_MIGRATION_LIST  = 0x18000029,
+   MCP_APP_TYPE_WAGONU_MIGRATION_LIST = 0x18000029,
-   MCP_APP_TYPE_CAFFEINE_TITLE_LIST    = 0x18000030,
+   MCP_APP_TYPE_CAFFEINE_TITLE_LIST   = 0x18000030,
-   MCP_APP_TYPE_MCP_TITLE_LIST         = 0x18000031,
+   MCP_APP_TYPE_MCP_TITLE_LIST        = 0x18000031,
-   MCP_APP_TYPE_GAME                   = 0x80000000,
+   MCP_APP_TYPE_GAME                  = 0x80000000,
-   MCP_APP_TYPE_GAME_WII               = 0x8000002E,
+   MCP_APP_TYPE_GAME_WII              = 0x8000002E,
-   MCP_APP_TYPE_SYSTEM_MENU            = 0x90000001,
+   MCP_APP_TYPE_SYSTEM_MENU           = 0x90000001,
-   MCP_APP_TYPE_SYSTEM_UPDATER         = 0x9000000B,
+   MCP_APP_TYPE_SYSTEM_UPDATER        = 0x9000000B,
-   MCP_APP_TYPE_SYSTEM_APPS            = 0x90000020,
+   MCP_APP_TYPE_SYSTEM_APPS           = 0x90000020,
-   MCP_APP_TYPE_ACCOUNT_APPS           = 0x90000021,
+   MCP_APP_TYPE_ACCOUNT_APPS          = 0x90000021,
-   MCP_APP_TYPE_SYSTEM_SETTINGS        = 0x90000022,
+   MCP_APP_TYPE_SYSTEM_SETTINGS       = 0x90000022,
-   MCP_APP_TYPE_ECO_PROCESS            = 0x9000002F,
+   MCP_APP_TYPE_ECO_PROCESS           = 0x9000002F,
-   MCP_APP_TYPE_EMANUAL                = 0xD0000003,
+   MCP_APP_TYPE_EMANUAL               = 0xD0000003,
-   MCP_APP_TYPE_HOME_MENU              = 0xD0000004,
+   MCP_APP_TYPE_HOME_MENU             = 0xD0000004,
-   MCP_APP_TYPE_ERROR_DISPLAY          = 0xD0000005,
+   MCP_APP_TYPE_ERROR_DISPLAY         = 0xD0000005,
-   MCP_APP_TYPE_BROWSER                = 0xD0000006,
+   MCP_APP_TYPE_BROWSER               = 0xD0000006,
-   MCP_APP_TYPE_MIIVERSE_POST          = 0xD000000D,
+   MCP_APP_TYPE_MIIVERSE_POST         = 0xD000000D,
-   MCP_APP_TYPE_MIIVERSE               = 0xD0000016,
+   MCP_APP_TYPE_MIIVERSE              = 0xD0000016,
-   MCP_APP_TYPE_ESHOP                  = 0xD0000017,
+   MCP_APP_TYPE_ESHOP                 = 0xD0000017,
-   MCP_APP_TYPE_FRIEND_LIST            = 0xD0000018,
+   MCP_APP_TYPE_FRIEND_LIST           = 0xD0000018,
-   MCP_APP_TYPE_DOWNLOAD_MANAGEMENT    = 0xD0000019,
+   MCP_APP_TYPE_DOWNLOAD_MANAGEMENT   = 0xD0000019,
-   MCP_APP_TYPE_AOC_OVERLAY            = 0xD000002C,
+   MCP_APP_TYPE_AOC_OVERLAY           = 0xD000002C,
-   MCP_APP_TYPE_AMIIBO_SETTINGS        = 0xD0000033,
+   MCP_APP_TYPE_AMIIBO_SETTINGS       = 0xD0000033,
 } MCPAppType;
 
 typedef enum MCPDeviceType
 {
-   MCP_DEVICE_TYPE_ODD                 = 2,
+   MCP_DEVICE_TYPE_AUTO = 1, /* returns result for ODD, MLC and USB */
-   MCP_DEVICE_TYPE_MLC                 = 3,
+   MCP_DEVICE_TYPE_ODD  = 2,
-   MCP_DEVICE_TYPE_USB                 = 4,
+   MCP_DEVICE_TYPE_MLC  = 3,
+   MCP_DEVICE_TYPE_USB  = 4,
+   /* any value >= 5 is MCP_DEVICE_TYPE_AUTO */
 } MCPDeviceType;
 
 typedef enum MCPDeviceFlags
 {
-   MCP_DEVICE_FLAG_UNK_1               = 0x1,
+   MCP_DEVICE_FLAG_UNK_1 = 0x1,
-   MCP_DEVICE_FLAG_UNK_2               = 0x2,
+   MCP_DEVICE_FLAG_UNK_2 = 0x2,
-   MCP_DEVICE_FLAG_UNK_4               = 0x4,
+   MCP_DEVICE_FLAG_UNK_4 = 0x4,
-   MCP_DEVICE_FLAG_UNK_8               = 0x8,
+   MCP_DEVICE_FLAG_UNK_8 = 0x8,
 } MCPDeviceFlags;
 
 typedef enum MCPInstallTarget
 {
-   MCP_INSTALL_TARGET_MLC              = 0,
+   MCP_INSTALL_TARGET_MLC = 0,
-   MCP_INSTALL_TARGET_USB              = 1,
+   MCP_INSTALL_TARGET_USB = 1,
 } MCPInstallTarget;
 
 typedef enum MCPRegion
 {
-   MCP_REGION_JAPAN                    = 0x01,
+   MCP_REGION_JAPAN  = 0x01,
-   MCP_REGION_USA                      = 0x02,
+   MCP_REGION_USA    = 0x02,
-   MCP_REGION_EUROPE                   = 0x04,
+   MCP_REGION_EUROPE = 0x04,
-   MCP_REGION_CHINA                    = 0x10,
+   MCP_REGION_CHINA  = 0x10,
-   MCP_REGION_KOREA                    = 0x20,
+   MCP_REGION_KOREA  = 0x20,
-   MCP_REGION_TAIWAN                   = 0x40,
+   MCP_REGION_TAIWAN = 0x40,
 } MCPRegion;
 
 typedef enum MCPCompatAVFile
@@ -100,6 +102,16 @@ typedef enum MCPCompatAVFile
    MCP_COMPAT_AV_FILE_DEINT = 0x01,
 } MCPCompatAVFile;
 
+typedef enum MCPSystemMode
+{
+   //! This unit is in 'retail'/'production' mode.
+   MCP_PRODUCTION  = 0x00,
+   //! This unit is in 'development' mode (default for CAT-DEV).
+   MCP_DEVELOPMENT = 0x01,
+   //! This unit is in 'test' mode.
+   MCP_TEST        = 0x02,
+} MCPSystemMode;
+
 struct WUT_PACKED MCPDevice
 {
    char type[8];
@@ -239,6 +251,10 @@ MCPError
 MCP_GetOwnTitleInfo(int32_t handle,
                     MCPTitleListType *titleInfo);
 
+MCPError
+MCP_GetSystemMode(int32_t handle,
+                  MCPSystemMode *mode);
+
 MCPError
 MCP_GetSysProdSettings(int32_t handle,
                        MCPSysProdSettings *settings);
@@ -310,7 +326,7 @@ MCP_TitleListByUniqueId(int32_t handle,
 
 MCPError
 MCP_TitleListByDevice(int32_t handle,
-                      const char *device,
+                      const char *deviceName,
                       uint32_t *outTitleCount,
                       MCPTitleListType *titleList,
                       uint32_t titleListSizeBytes);
@@ -324,7 +340,7 @@ MCP_TitleListByDeviceType(int32_t handle,
 MCPError
 MCP_TitleListByAppAndDevice(int32_t handle,
                             MCPAppType appType,
-                            const char *device,
+                            const char *deviceName,
                             uint32_t *outTitleCount,
                             MCPTitleListType *titleList,
                             uint32_t titleListSizeBytes);
@@ -358,6 +374,44 @@ MCP_CompatLoadAVFile(int32_t handle,
                      uint32_t *size,
                      MCPCompatAVFile file);
 
+/**
+ * Saves the current Cafe log to the SLC logs directory.
+ * Internally calls IOS_Ioctl() with request \c 0xCD .
+ *
+ * \return
+ * \c 0 on success.
+ */
+MCPError
+MCP_TriggerCrashLogCollection(int32_t handle);
+
+/**
+ * Sets values to /storage_slc/sys/config/eco.xml
+ *
+ * \return
+ * \c 0 on success.
+ */
+MCPError
+MCP_ChangeEcoSettings(int32_t handle,
+                      uint32_t enable,
+                      uint32_t maxOnTime,
+                      uint16_t defaultOffTime);
+
+static inline const char *
+MCP_GetDeviceNameByDeviceType(MCPDeviceType deviceType)
+{
+   switch (deviceType) {
+      case MCP_DEVICE_TYPE_AUTO:
+         return "auto";
+      case MCP_DEVICE_TYPE_ODD:
+         return "odd";
+      case MCP_DEVICE_TYPE_MLC:
+         return "mlc";
+      case MCP_DEVICE_TYPE_USB:
+         return "usb";
+   }
+   return "auto";
+}
+
 #ifdef __cplusplus
 }
 #endif

include/coreinit/memallocator.h

@@ -0,0 +1,108 @@
+#pragma once
+#include <wut.h>
+#include "memheap.h"
+
+/**
+ * \defgroup coreinit_memallocator Allocator
+ * \ingroup coreinit
+ *
+ * Functions for managing generic allocator objects.
+ * @{
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct MEMAllocatorFunctions MEMAllocatorFunctions;
+typedef struct MEMAllocator MEMAllocator;
+
+typedef void *(*MEMAllocatorAllocFn)(MEMAllocator *allocator, uint32_t size);
+typedef void (*MEMAllocatorFreeFn)(MEMAllocator *allocator, void *ptr);
+
+//! Holds context information that will be used to allocate and free memory.
+struct MEMAllocator
+{
+   //! Points to the alloc/free functions.
+   MEMAllocatorFunctions *funcs;
+   //! The heap handle.
+   MEMHeapHandle heap;
+   //! The alignment the allocator will use.
+   uint32_t align;
+   WUT_UNKNOWN_BYTES(4);
+};
+WUT_CHECK_OFFSET(MEMAllocator, 0x0, funcs);
+WUT_CHECK_OFFSET(MEMAllocator, 0x4, heap);
+WUT_CHECK_OFFSET(MEMAllocator, 0x8, align);
+WUT_CHECK_SIZE(MEMAllocator, 0x10);
+
+//! The alloc/free functions.
+struct MEMAllocatorFunctions
+{
+   MEMAllocatorAllocFn alloc;
+   MEMAllocatorFreeFn free;
+};
+WUT_CHECK_OFFSET(MEMAllocatorFunctions, 0x0, alloc);
+WUT_CHECK_OFFSET(MEMAllocatorFunctions, 0x4, free);
+WUT_CHECK_SIZE(MEMAllocatorFunctions, 0x8);
+
+/**
+ * Allocates memory from the allocator.
+ *
+ * \return `allocator->funcs.alloc(allocator, size)`.
+ */
+void *
+MEMAllocFromAllocator(MEMAllocator *allocator,
+                      uint32_t size);
+
+/**
+ * Frees memory back to the allocator.
+ *
+ * It simply calls `allocator->funcs.free(allocator, ptr)`.
+ */
+void
+MEMFreeToAllocator(MEMAllocator *allocator,
+                   void *ptr);
+
+/**
+ * Initializes an allocator from an Expanded Heap.
+ */
+void
+MEMInitAllocatorForExpHeap(MEMAllocator *allocator,
+                           MEMHeapHandle heap,
+                           uint32_t alignment);
+
+/**
+ * Initializes an allocator from a Frame Heap.
+ */
+void
+MEMInitAllocatorForFrmHeap(MEMAllocator *allocator,
+                           MEMHeapHandle heap,
+                           uint32_t alignment);
+
+/**
+ * Initializes an allocator from a Unit Heap.
+ */
+void
+MEMInitAllocatorForUnitHeap(MEMAllocator *allocator,
+                            MEMHeapHandle heap);
+
+/**
+ * Initializes an allocator from the Default Heap.
+ */
+void
+MEMInitAllocatorForDefaultHeap(MEMAllocator *allocator);
+
+/**
+ * Initializes an allocator from a Block Heap.
+ */
+void
+MEMInitAllocatorForBlockHeap(MEMAllocator *allocator,
+                             MEMHeapHandle heap,
+                             uint32_t alignment);
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */

include/coreinit/memblockheap.h

@@ -75,6 +75,8 @@ struct WUT_PACKED MEMBlockHeap
 
    //! Free block count
    uint32_t numFreeBlocks;
+
+   WUT_PADDING_BYTES(0xC);
 };
 WUT_CHECK_OFFSET(MEMBlockHeap, 0x00, header);
 WUT_CHECK_OFFSET(MEMBlockHeap, 0x40, defaultTrack);
@@ -83,7 +85,7 @@ WUT_CHECK_OFFSET(MEMBlockHeap, 0x64, firstBlock);
 WUT_CHECK_OFFSET(MEMBlockHeap, 0x68, lastBlock);
 WUT_CHECK_OFFSET(MEMBlockHeap, 0x6C, firstFreeBlock);
 WUT_CHECK_OFFSET(MEMBlockHeap, 0x70, numFreeBlocks);
-WUT_CHECK_SIZE(MEMBlockHeap, 0x74);
+WUT_CHECK_SIZE(MEMBlockHeap, 0x80);
 
 MEMHeapHandle
 MEMInitBlockHeap(MEMBlockHeap *heap,

include/coreinit/memexpheap.h

@@ -16,21 +16,26 @@ typedef struct MEMExpHeap MEMExpHeap;
 typedef struct MEMExpHeapBlock MEMExpHeapBlock;
 typedef struct MEMExpHeapBlockList MEMExpHeapBlockList;
 
-typedef void (*MEMExpHeapBlockVisitor)(void *block, MEMHeapHandle heap,
+typedef void (*MEMExpHeapBlockVisitor)(void *block, MEMHeapHandle heap, void *context);
-                                       void *context);
 
 typedef enum MEMExpHeapMode
 {
-   MEM_EXP_HEAP_MODE_FIRST_FREE     = 0,
+   MEM_EXP_HEAP_MODE_FIRST_FREE   = 0,
-   MEM_EXP_HEAP_MODE_NEAREST_SIZE   = 1,
+   MEM_EXP_HEAP_MODE_NEAREST_SIZE = 1,
 } MEMExpHeapMode;
 
 typedef enum MEMExpHeapDirection
 {
-   MEM_EXP_HEAP_DIR_FROM_TOP        = 0,
+   MEM_EXP_HEAP_DIR_FROM_TOP    = 0,
-   MEM_EXP_HEAP_DIR_FROM_BOTTOM     = 1,
+   MEM_EXP_HEAP_DIR_FROM_BOTTOM = 1,
 } MEMExpHeapDirection;
 
+typedef enum MEMExpHeapCheckFlags
+{
+   MEM_EXP_HEAP_CHECK_FLAGS_NONE       = 0,
+   MEM_EXP_HEAP_CHECK_FLAGS_LOG_ERRORS = 1,
+} MEMExpHeapCheckFlags;
+
 struct MEMExpHeapBlock
 {
    uint32_t attribs;
@@ -131,6 +136,10 @@ MEMVisitAllocatedForExpHeap(MEMHeapHandle heap,
                             MEMExpHeapBlockVisitor callback,
                             void *context);
 
+BOOL
+MEMCheckExpHeap(MEMHeapHandle handle,
+                MEMExpHeapCheckFlags mode);
+
 #ifdef __cplusplus
 }
 #endif

include/coreinit/memfrmheap.h

@@ -14,9 +14,9 @@ extern "C" {
 
 typedef enum MEMFrmHeapFreeMode
 {
-   MEM_FRM_HEAP_FREE_HEAD   = 1 << 0,
+   MEM_FRM_HEAP_FREE_HEAD = 1 << 0,
-   MEM_FRM_HEAP_FREE_TAIL   = 1 << 1,
+   MEM_FRM_HEAP_FREE_TAIL = 1 << 1,
-   MEM_FRM_HEAP_FREE_ALL    = MEM_FRM_HEAP_FREE_HEAD | MEM_FRM_HEAP_FREE_TAIL,
+   MEM_FRM_HEAP_FREE_ALL  = MEM_FRM_HEAP_FREE_HEAD | MEM_FRM_HEAP_FREE_TAIL,
 } MEMFrmHeapFreeMode;
 
 typedef struct MEMFrmHeap MEMFrmHeap;

include/coreinit/memheap.h

@@ -1,13 +1,13 @@
 #pragma once
 #include <wut.h>
-#include "spinlock.h"
 #include "memlist.h"
+#include "spinlock.h"
 
 /**
  * \defgroup coreinit_memheap Common Memory Heap
  * \ingroup coreinit
  *
- * Common memory heap fucntions.
+ * Common memory heap functions.
  * @{
  */
 
@@ -20,9 +20,9 @@ typedef MEMHeapHeader *MEMHeapHandle;
 
 typedef enum MEMBaseHeapType
 {
-   MEM_BASE_HEAP_MEM1   = 0,
+   MEM_BASE_HEAP_MEM1 = 0,
-   MEM_BASE_HEAP_MEM2   = 1,
+   MEM_BASE_HEAP_MEM2 = 1,
-   MEM_BASE_HEAP_FG     = 8,
+   MEM_BASE_HEAP_FG   = 8,
 } MEMBaseHeapType;
 
 typedef enum MEMHeapFillType
@@ -34,18 +34,18 @@ typedef enum MEMHeapFillType
 
 typedef enum MEMHeapTag
 {
-  MEM_BLOCK_HEAP_TAG      = 0x424C4B48u,
+   MEM_BLOCK_HEAP_TAG    = 0x424C4B48u,
-  MEM_EXPANDED_HEAP_TAG   = 0x45585048u,
+   MEM_EXPANDED_HEAP_TAG = 0x45585048u,
-  MEM_FRAME_HEAP_TAG      = 0x46524D48u,
+   MEM_FRAME_HEAP_TAG    = 0x46524D48u,
-  MEM_UNIT_HEAP_TAG       = 0x554E5448u,
+   MEM_UNIT_HEAP_TAG     = 0x554E5448u,
-  MEM_USER_HEAP_TAG       = 0x55535248u,
+   MEM_USER_HEAP_TAG     = 0x55535248u,
 } MEMHeapTag;
 
 typedef enum MEMHeapFlags
 {
-  MEM_HEAP_FLAG_ZERO_ALLOCATED  = 1 << 0,
+   MEM_HEAP_FLAG_ZERO_ALLOCATED = 1 << 0,
-  MEM_HEAP_FLAG_DEBUG_MODE      = 1 << 1,
+   MEM_HEAP_FLAG_DEBUG_MODE     = 1 << 1,
-  MEM_HEAP_FLAG_USE_LOCK        = 1 << 2,
+   MEM_HEAP_FLAG_USE_LOCK       = 1 << 2,
 } MEMHeapFlags;
 
 struct MEMHeapHeader
@@ -144,6 +144,12 @@ void
 MEMSetFillValForHeap(MEMHeapFillType type,
                      uint32_t value);
 
+/**
+ * Checks the heap for corruption
+ */
+BOOL
+MEMCheckHeap(MEMHeapHandle handle);
+
 #ifdef __cplusplus
 }
 #endif

include/coreinit/memory.h

@@ -20,11 +20,11 @@ typedef enum OSMemoryType
 
 typedef enum OSSharedDataType
 {
-   OS_SHAREDDATATYPE_FONT_CHINESE      = 0,
+   OS_SHAREDDATATYPE_FONT_CHINESE   = 0,
-   OS_SHAREDDATATYPE_FONT_KOREAN       = 1,
+   OS_SHAREDDATATYPE_FONT_KOREAN    = 1,
-   OS_SHAREDDATATYPE_FONT_STANDARD     = 2,
+   OS_SHAREDDATATYPE_FONT_STANDARD  = 2,
-   OS_SHAREDDATATYPE_FONT_TAIWANESE    = 3,
+   OS_SHAREDDATATYPE_FONT_TAIWANESE = 3,
-   OS_SHAREDDATATYPE_FONT_MAX          = 4,
+   OS_SHAREDDATATYPE_FONT_MAX       = 4,
 } OSSharedDataType;
 
 BOOL

include/coreinit/memorymap.h

@@ -14,11 +14,11 @@ extern "C" {
 
 typedef enum OSMemoryMapMode
 {
-   OS_MAP_MEMORY_INVALID      = 0,
+   OS_MAP_MEMORY_INVALID    = 0,
-   OS_MAP_MEMORY_READ_ONLY    = 1,
+   OS_MAP_MEMORY_READ_ONLY  = 1,
-   OS_MAP_MEMORY_READ_WRITE   = 2,
+   OS_MAP_MEMORY_READ_WRITE = 2,
-   OS_MAP_MEMORY_FREE         = 3,
+   OS_MAP_MEMORY_FREE       = 3,
-   OS_MAP_MEMORY_ALLOCATED    = 4,
+   OS_MAP_MEMORY_ALLOCATED  = 4,
 } OSMemoryMapMode;
 
 #define OS_PAGE_SIZE (128 * 1024)
@@ -26,6 +26,12 @@ typedef enum OSMemoryMapMode
 uint32_t
 OSEffectiveToPhysical(uint32_t virtualAddress);
 
+uint32_t
+__OSPhysicalToEffectiveCached(uint32_t physicalAddress);
+
+uint32_t
+__OSPhysicalToEffectiveUncached(uint32_t physicalAddress);
+
 BOOL
 OSIsAddressValid(uint32_t virtualAddress);
 

include/coreinit/messagequeue.h

@@ -17,24 +17,24 @@ typedef struct OSMessageQueue OSMessageQueue;
 
 typedef enum OSMessageFlags
 {
-   OS_MESSAGE_FLAGS_NONE            = 0,
+   OS_MESSAGE_FLAGS_NONE          = 0,
-   OS_MESSAGE_FLAGS_BLOCKING        = 1 << 0,
+   OS_MESSAGE_FLAGS_BLOCKING      = 1 << 0,
-   OS_MESSAGE_FLAGS_HIGH_PRIORITY   = 1 << 1,
+   OS_MESSAGE_FLAGS_HIGH_PRIORITY = 1 << 1,
 } OSMessageFlags;
 
 typedef enum OSFunctionType
 {
-  OS_FUNCTION_TYPE_HIO_OPEN                     = 1,
+   OS_FUNCTION_TYPE_HIO_OPEN                  = 1,
-  OS_FUNCTION_TYPE_HIO_READ_ASYNC               = 2,
+   OS_FUNCTION_TYPE_HIO_READ_ASYNC            = 2,
-  OS_FUNCTION_TYPE_HIO_WRITE_ASYNC              = 3,
+   OS_FUNCTION_TYPE_HIO_WRITE_ASYNC           = 3,
-  OS_FUNCTION_TYPE_FSA_CMD_ASYNC                = 4,
+   OS_FUNCTION_TYPE_FSA_CMD_ASYNC             = 4,
-  OS_FUNCTION_TYPE_FSA_PR_CMD_ASYNC             = 5,
+   OS_FUNCTION_TYPE_FSA_PR_CMD_ASYNC          = 5,
-  OS_FUNCTION_TYPE_FSA_PR_CMD_ASYNC_NO_ALLOC    = 6,
+   OS_FUNCTION_TYPE_FSA_PR_CMD_ASYNC_NO_ALLOC = 6,
-  OS_FUNCTION_TYPE_FSA_ATTACH_EVENT             = 7,
+   OS_FUNCTION_TYPE_FSA_ATTACH_EVENT          = 7,
-  OS_FUNCTION_TYPE_FS_CMD_ASYNC                 = 8,
+   OS_FUNCTION_TYPE_FS_CMD_ASYNC              = 8,
-  OS_FUNCTION_TYPE_FS_CMD_HANDLER               = 9,
+   OS_FUNCTION_TYPE_FS_CMD_HANDLER            = 9,
-  OS_FUNCTION_TYPE_FS_ATTACH_EVENT              = 10,
+   OS_FUNCTION_TYPE_FS_ATTACH_EVENT           = 10,
-  OS_FUNCTION_TYPE_FS_STATE_CHANGE_EVENT        = 11,
+   OS_FUNCTION_TYPE_FS_STATE_CHANGE_EVENT     = 11,
 } OSFunctionType;
 
 struct OSMessage

include/coreinit/performancemonitor.h

@@ -0,0 +1,206 @@
+#pragma once
+#include <wut.h>
+
+/**
+ * \defgroup coreinit_performancemonitor Performance Monitor
+ * \ingroup coreinit
+ *
+ * @{
+ */
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/// Used to tell OSSetPerformanceMonitor() which arguments are valid.
+typedef enum OSPerfMonArg
+{
+   OS_PM_ARG_MMCR0 = 1u << 0u,
+   OS_PM_ARG_MMCR1 = 1u << 1u,
+   OS_PM_ARG_PMC1  = 1u << 2u,
+   OS_PM_ARG_PMC2  = 1u << 3u,
+   OS_PM_ARG_PMC3  = 1u << 4u,
+   OS_PM_ARG_PMC4  = 1u << 5u,
+} OSPerfMonArg;
+
+/**
+ * Flags to write to (U)MMCR0 register.
+ *
+ * \sa OSSetPerformanceMonitor
+ */
+typedef enum OSPerfMonMMCR0Flags
+{
+   OS_PM_MMCR0_PMC1_CURRENT                             = 0b0000000u << 6,
+   OS_PM_MMCR0_PMC1_CPU_CYCLES                          = 0b0000001u << 6,
+   OS_PM_MMCR0_PMC1_INSTRUCTIONS_COMPLETED              = 0b0000010u << 6,
+   OS_PM_MMCR0_PMC1_TBL_RISING_TRANSITIONS              = 0b0000011u << 6,
+   OS_PM_MMCR0_PMC1_INSTRUCTIONS_DISPATCHED             = 0b0000100u << 6,
+   OS_PM_MMCR0_PMC1_EIEIO_INSTRUCTIONS_COMPLETED        = 0b0000101u << 6,
+   OS_PM_MMCR0_PMC1_ITLB_SEARCH_CYCLES                  = 0b0000110u << 6,
+   OS_PM_MMCR0_PMC1_L2_HITS                             = 0b0000111u << 6,
+   OS_PM_MMCR0_PMC1_INSTRUCTIONS_EA_DELIVERED           = 0b0001000u << 6,
+   OS_PM_MMCR0_PMC1_INSTRUCTIONS_COMPLETED_MATCHES_IABR = 0b0001001u << 6,
+   OS_PM_MMCR0_PMC1_SLOW_L1_MISSES                      = 0b0001010u << 6,
+   OS_PM_MMCR0_PMC1_UNRESOLVED_BRANCHES                 = 0b0001011u << 6,
+   OS_PM_MMCR0_PMC1_UNRESOLVED_STALL_CYCLES             = 0b0001100u << 6,
+   OS_PM_MMCR0_PMC1_L1_SHARED_STORES                    = 0b0001110u << 6,
+   OS_PM_MMCR0_PMC1_L2_SHARED_INTERVENTIONS             = 0b0001111u << 6,
+   OS_PM_MMCR0_PMC1_CACHE_PARADOXES                     = 0b0010000u << 6,
+   OS_PM_MMCR0_PMC1_CIU_LOAD_REQUESTS                   = 0b0010100u << 6,
+   OS_PM_MMCR0_PMC1_BIU_ADDRESS_ONLY_REQUESTS           = 0b0010101u << 6,
+   OS_PM_MMCR0_PMC1_CIU_PARADOXES                       = 0b0010110u << 6,
+   OS_PM_MMCR0_PMC1_60XE_BUS_DATA_BEATS                 = 0b0010111u << 6,
+
+   OS_PM_MMCR0_PMC2_CURRENT                             = 0b000000u,
+   OS_PM_MMCR0_PMC2_CPU_CYCLES                          = 0b000001u,
+   OS_PM_MMCR0_PMC2_INSTRUCTIONS_COMPLETED              = 0b000010u,
+   OS_PM_MMCR0_PMC2_TBL_RISING_TRANSITIONS              = 0b000011u,
+   OS_PM_MMCR0_PMC2_INSTRUCTIONS_DISPATCHED             = 0b000100u,
+   OS_PM_MMCR0_PMC2_L1_ICACHE_MISSES                    = 0b000101u,
+   OS_PM_MMCR0_PMC2_ITLB_MISSES                         = 0b000110u,
+   OS_PM_MMCR0_PMC2_L2_INSTRUCTION_MISSES               = 0b000111u,
+   OS_PM_MMCR0_PMC2_PRED_BRANCHES_NOT_TAKEN             = 0b001000u,
+   OS_PM_MMCR0_PMC2_RESERVED_LOADS                      = 0b001010u,
+   OS_PM_MMCR0_PMC2_LOADS_AND_STORES                    = 0b001011u,
+   OS_PM_MMCR0_PMC2_CACHE_SNOOPS                        = 0b001100u,
+   OS_PM_MMCR0_PMC2_L1_TO_L2_CASTOUTS                   = 0b001101u,
+   OS_PM_MMCR0_PMC2_SYSTEM_UNIT_INSTRUCTIONS            = 0b001110u,
+   OS_PM_MMCR0_PMC2_L1_INSTRUCTION_MISS_CYCLES          = 0b001111u,
+   OS_PM_MMCR0_PMC2_FIRST_SPECULATIVE_BRANCH_RESOLVES   = 0b010000u,
+   OS_PM_MMCR0_PMC2_L2_SHARED_STORES                    = 0b010001u,
+   OS_PM_MMCR0_PMC2_L1_SHARED_INTERVENTIONS             = 0b010010u,
+   OS_PM_MMCR0_PMC2_CIU_STORE_REQUESTS                  = 0b010100u,
+   OS_PM_MMCR0_PMC2_SLOW_OUTSTANDING_BIU_TRANSACTIONS   = 0b010101u,
+   OS_PM_MMCR0_PMC2_CIU_MODIFIED_INTERVENTIONS          = 0b010110u,
+} OSPerfMonMMCR0Flags;
+
+/**
+ * Flags to write to (U)MMCR1 register.
+ *
+ * \sa OSSetPerformanceMonitor
+ */
+typedef enum OSPerfMonMMCR1Flags
+{
+   OS_PM_MMCR1_PMC3_CURRENT                            = 0b00000u << 27,
+   OS_PM_MMCR1_PMC3_CPU_CYCLES                         = 0b00001u << 27,
+   OS_PM_MMCR1_PMC3_INSTRUCTIONS_COMPLETED             = 0b00010u << 27,
+   OS_PM_MMCR1_PMC3_TBL_RISING_TRANSITIONS             = 0b00011u << 27,
+   OS_PM_MMCR1_PMC3_INSTRUCTIONS_DISPATCHED            = 0b00100u << 27,
+   OS_PM_MMCR1_PMC3_L1_DCACHE_MISSES                   = 0b00101u << 27,
+   OS_PM_MMCR1_PMC3_DTLB_MISSES                        = 0b00110u << 27,
+   OS_PM_MMCR1_PMC3_L2_DATA_MISSES                     = 0b00111u << 27,
+   OS_PM_MMCR1_PMC3_PRED_BRANCHES_TAKEN                = 0b01000u << 27,
+   OS_PM_MMCR1_PMC3_COND_STORES_COMPLETED              = 0b01010u << 27,
+   OS_PM_MMCR1_PMC3_FPU_INSTRUCTIONS_COMPLETED         = 0b01011u << 27,
+   OS_PM_MMCR1_PMC3_L2_CASTOUTS_BY_SNOOPS              = 0b01100u << 27,
+   OS_PM_MMCR1_PMC3_L2_CACHE_OPERATIONS                = 0b01101u << 27,
+   OS_PM_MMCR1_PMC3_L1_LOAD_MISS_CYCLES                = 0b01111u << 27,
+   OS_PM_MMCR1_PMC3_SECOND_SPECULATIVE_BRANCH_RESOLVES = 0b10000u << 27,
+   OS_PM_MMCR1_PMC3_BPU_STALL_LR_CR_CYCLES             = 0b10001u << 27,
+   OS_PM_MMCR1_PMC3_L1_MODIFIED_INTERVENTIONS          = 0b10010u << 27,
+   OS_PM_MMCR1_PMC3_ICBI_SNOOPS                        = 0b10011u << 27,
+   OS_PM_MMCR1_PMC3_CIU_ADDRESS_ONLY_REQUESTS          = 0b10100u << 27,
+   OS_PM_MMCR1_PMC3_BIU_LOAD_REQUESTS                  = 0b10101u << 27,
+   OS_PM_MMCR1_PMC3_CIU_SHARED_INTERVENTIONS           = 0b10110u << 27,
+
+   OS_PM_MMCR1_PMC4_CURRENT                            = 0b00000u << 22,
+   OS_PM_MMCR1_PMC4_CPU_CYCLES                         = 0b00001u << 22,
+   OS_PM_MMCR1_PMC4_INSTRUCTIONS_COMPLETED             = 0b00010u << 22,
+   OS_PM_MMCR1_PMC4_TBL_RISING_TRANSITIONS             = 0b00011u << 22,
+   OS_PM_MMCR1_PMC4_INSTRUCTIONS_DISPATCHED            = 0b00100u << 22,
+   OS_PM_MMCR1_PMC4_L2_CASTOUTS                        = 0b00101u << 22,
+   OS_PM_MMCR1_PMC4_DTLB_SEARCH_CYCLES                 = 0b00110u << 22,
+   OS_PM_MMCR1_PMC4_BRANCHES_MISPREDICTED              = 0b01000u << 22,
+   OS_PM_MMCR1_PMC4_INTACT_COND_STORES_COMPLETED       = 0b01010u << 22,
+   OS_PM_MMCR1_PMC4_SYNC_INSTRUCTIONS_COMPLETED        = 0b01011u << 22,
+   OS_PM_MMCR1_PMC4_SNOOP_RETRIES                      = 0b01100u << 22,
+   OS_PM_MMCR1_PMC4_INTEGER_OPERATIONS                 = 0b01101u << 22,
+   OS_PM_MMCR1_PMC4_BPU_STALL_TWO_BRANCHES_CYCLES      = 0b01110u << 22,
+   OS_PM_MMCR1_PMC4_L2_MODIFIED_INTERVENTIONS          = 0b10000u << 22,
+   OS_PM_MMCR1_PMC4_TLBIE_SNOOPS                       = 0b10001u << 22,
+   OS_PM_MMCR1_PMC4_L2_BANK_REFRESH_OVERFLOWS          = 0b10010u << 22,
+   OS_PM_MMCR1_PMC4_CIU_ARTRY_COUNT                    = 0b10100u << 22,
+   OS_PM_MMCR1_PMC4_BIU_STORE_REQUESTS                 = 0b10101u << 22,
+   OS_PM_MMCR1_PMC4_CIU_TWO_CORE_SHARED_INTERVENTIONS  = 0b10110u << 22,
+} OSPerfMonMMCR1Flags;
+
+/**
+ * Write to performance monitor registers.
+ *
+ * Performance monitor registers can only be written by the kernel, this allows userspace
+ * to write to them.
+ *
+ * \param arg_mask OR-ed values from `OSPerfMonArg`, indicating which of the following
+ * arguments are to be written to registers.
+ *
+ * \param mmcr0 OR-ed values from `OSPerfMonMMCR0Flags` to write to register MMCR0.
+ * \param mmcr1 OR-ed values from `OSPerfMonMMCR1Flags` to write to register MMCR1.
+ * \param pmc1 Value to write to register PMC1.
+ * \param pmc2 Value to write to register PMC2.
+ * \param pmc3 Value to write to register PMC3.
+ * \param pmc4 Value to write to register PMC4.
+ */
+void
+OSSetPerformanceMonitor(uint32_t arg_mask,
+                        uint32_t mmcr0,
+                        uint32_t mmcr1,
+                        uint32_t pmc1,
+                        uint32_t pmc2,
+                        uint32_t pmc3,
+                        uint32_t pmc4);
+
+/**
+ * Convenience function to read from UPMC1.
+ */
+static inline uint32_t
+OSGetUPMC1()
+{
+   uint32_t result;
+   asm("mfupmc1 %[result]"
+       : [result] "=r"(result));
+   return result;
+}
+
+/**
+ * Convenience function to read from UPMC2.
+ */
+static inline uint32_t
+OSGetUPMC2()
+{
+   uint32_t result;
+   asm("mfupmc2 %[result]"
+       : [result] "=r"(result));
+   return result;
+}
+
+/**
+ * Convenience function to read from UPMC3.
+ */
+static inline uint32_t
+OSGetUPMC3()
+{
+   uint32_t result;
+   asm("mfupmc3 %[result]"
+       : [result] "=r"(result));
+   return result;
+}
+
+/**
+ * Convenience function to read from UPMC4.
+ */
+static inline uint32_t
+OSGetUPMC4()
+{
+   uint32_t result;
+   asm("mfupmc4 %[result]"
+       : [result] "=r"(result));
+   return result;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */

include/coreinit/savedframe.h

@@ -0,0 +1,106 @@
+#pragma once
+#include <wut.h>
+
+/**
+ * \defgroup coreinit_savedframe
+ * \ingroup coreinit
+ * @{
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum OSSavedFrameType
+{
+   OS_SAVED_FRAME_A = 0,
+   OS_SAVED_FRAME_B = 1,
+} OSSavedFrameType;
+
+typedef enum OSSavedFrameScreen
+{
+   OS_SAVED_FRAME_SCREEN_TV  = 2,
+   OS_SAVED_FRAME_SCREEN_DRC = 4,
+} OSSavedFrameScreen;
+
+uint32_t
+__OSClearSavedFrame(OSSavedFrameType type,
+                    OSSavedFrameScreen screen);
+
+/**
+ * Gets the GX2Texture saved via \link __OSSetSavedFrame \endlink
+ * @param ptr_size  must be <= 0x100
+ */
+void
+__OSGetSavedFrame(OSSavedFrameScreen screen,
+                  void *outPtr,
+                  uint32_t ptr_size);
+
+/**
+ * Gets the GX2Texture saved via \link __OSSetSavedFrame \endlink
+ * @param ptr_size  must be <= 0x100
+ */
+void
+__OSGetSavedFrameA(OSSavedFrameScreen screen,
+                   void *outPtr,
+                   uint32_t ptr_size);
+
+/**
+ * Gets the GX2Texture saved via \link __OSSetSavedFrame \endlink
+ * @param ptr_size  must be <= 0x100
+ */
+void
+__OSGetSavedFrameB(OSSavedFrameScreen screen,
+                   void *outPtr,
+                   uint32_t ptr_size);
+
+BOOL
+__OSGetSavedFrameGammaA(OSSavedFrameScreen screen,
+                        float *outGamma);
+
+BOOL
+__OSGetSavedFrameGammaB(OSSavedFrameScreen screen,
+                        float *outGamma);
+
+void *
+__OSGetSavedFramePtr(OSSavedFrameType type,
+                     OSSavedFrameScreen screen);
+
+void *
+__OSGetSavedFramePtrForRead(OSSavedFrameScreen screen);
+
+void *
+__OSGetSavedFramePtrForWrite(OSSavedFrameScreen screen);
+
+uint32_t
+__OSGetSavedFrames();
+
+uint32_t
+__OSGetSavedFramesA();
+
+uint32_t
+__OSGetSavedFramesB();
+
+void
+__OSResetSavedFrame(OSSavedFrameScreen screen);
+
+/**
+ *
+ * @param data expected to be a GX2Texture
+ * @param size must be <= 0x100
+ * @return 0 on succes, -1 on error
+ */
+int
+__OSSetSavedFrame(OSSavedFrameScreen screen,
+                  void *data,
+                  uint32_t size);
+
+void
+__OSSetSavedFrameGamma(float gamma,
+                       OSSavedFrameScreen screen);
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */

include/coreinit/scheduler.h

@@ -11,7 +11,7 @@
 extern "C" {
 #endif
 
-extern void* __OSSchedulerLock;
+extern void *__OSSchedulerLock;
 
 void
 __OSEnableScheduler();
@@ -20,17 +20,17 @@ void
 __OSDisableScheduler();
 
 void
-__OSLockScheduler(void* lockId);
+__OSLockScheduler(void *lockId);
 
 void
-__OSUnlockScheduler(void* lockId);
+__OSUnlockScheduler(void *lockId);
 
 BOOL
-OSIsSchedulerLocked(void* lockId);
+OSIsSchedulerLocked(void *lockId);
 
 void
-__OSTryLockScheduler(void* lockId);
+__OSTryLockScheduler(void *lockId);
- 
+
 void
 __OSTouchSchedulerLock();
 

include/coreinit/screen.h

@@ -44,9 +44,9 @@ extern "C" {
 typedef enum OSScreenID
 {
    //! Represents the TV connected to the system.
-   SCREEN_TV      = 0,
+   SCREEN_TV  = 0,
    //! Represents the screen in the DRC (gamepad).
-   SCREEN_DRC     = 1,
+   SCREEN_DRC = 1,
 } OSScreenID;
 
 /**
@@ -154,14 +154,14 @@ OSScreenFlipBuffersEx(OSScreenID screen);
  * \param screen
  * The ID of the screen to draw to. Only the work buffer will be affected.
  *
- * \param row
- * The row, in characters, to place the text in. 0 corresponds to the top of
- * the screen.
- *
  * \param column
  * The column, in characters, to place the text at. 0 corresponds to the left of
  * the screen.
  *
+ * \param row
+ * The row, in characters, to place the text in. 0 corresponds to the top of
+ * the screen.
+ *
  * \param buffer
  * Pointer to the string of text to draw. Null-terminated.
  *
@@ -176,8 +176,8 @@ OSScreenFlipBuffersEx(OSScreenID screen);
  */
 void
 OSScreenPutFontEx(OSScreenID screen,
-                  uint32_t row,
                   uint32_t column,
+                  uint32_t row,
                   const char *buffer);
 
 /**

include/coreinit/smd.h

@@ -26,39 +26,39 @@ typedef struct SmdSimpleBufPool SmdSimpleBufPool;
 
 typedef enum SmdLockType
 {
-    //! Locking is done with a mutex
+   //! Locking is done with a mutex
-    SMD_LOCK_TYPE_MUTEX                 = 0,
+   SMD_LOCK_TYPE_MUTEX              = 0,
-    //! Locking is done by disabling interrupts
+   //! Locking is done by disabling interrupts
-    SMD_LOCK_TYPE_DISABLE_INTERRUPTS    = 1,
+   SMD_LOCK_TYPE_DISABLE_INTERRUPTS = 1,
-    //! No locking is done
+   //! No locking is done
-    SMD_LOCK_TYPE_NONE                  = 2,
+   SMD_LOCK_TYPE_NONE               = 2,
 } SmdLockType;
 
 typedef enum SmdPpcState
 {
-    SMD_PPC_STATE_INVALID       = 0,
+   SMD_PPC_STATE_INVALID     = 0,
-    SMD_PPC_STATE_INITIALIZED   = 1,
+   SMD_PPC_STATE_INITIALIZED = 1,
-    SMD_PPC_STATE_CLOSED        = 2,
+   SMD_PPC_STATE_CLOSED      = 2,
-    SMD_PPC_STATE_OPENED        = 3,
+   SMD_PPC_STATE_OPENED      = 3,
 } SmdPpcState;
 
 typedef enum SmdInterfaceState
 {
-    SMD_INTERFACE_STATE_OPENED = 0x2222,
+   SMD_INTERFACE_STATE_OPENED = 0x2222,
-    SMD_INTERFACE_STATE_CLOSED = 0x3333,
+   SMD_INTERFACE_STATE_CLOSED = 0x3333,
 } SmdInterfaceState;
 
 typedef enum SmdElementType
 {
-    SMD_ELEMENT_TYPE_MESSAGE        = 0,
+   SMD_ELEMENT_TYPE_MESSAGE     = 0,
-    SMD_ELEMENT_TYPE_VECTOR_SPEC    = 1,
+   SMD_ELEMENT_TYPE_VECTOR_SPEC = 1,
-    SMD_ELEMENT_TYPE_VECTOR         = 2,
+   SMD_ELEMENT_TYPE_VECTOR      = 2,
 } SmdElementType;
 
 struct SmdVectorSpec
 {
-    void *ptr;
+   void *ptr;
-    uint32_t size;
+   uint32_t size;
 };
 WUT_CHECK_OFFSET(SmdVectorSpec, 0x00, ptr);
 WUT_CHECK_OFFSET(SmdVectorSpec, 0x04, size);
@@ -66,9 +66,9 @@ WUT_CHECK_SIZE(SmdVectorSpec, 0x8);
 
 struct SmdVector
 {
-    uint32_t command;
+   uint32_t command;
-    int32_t count;
+   int32_t count;
-    SmdVectorSpec vecs[4];
+   SmdVectorSpec vecs[4];
 };
 WUT_CHECK_OFFSET(SmdVector, 0x00, command);
 WUT_CHECK_OFFSET(SmdVector, 0x04, count);
@@ -77,13 +77,14 @@ WUT_CHECK_SIZE(SmdVector, 0x28);
 
 struct SmdElement
 {
-    SmdElementType type;
+   SmdElementType type;
-    uint32_t size;
+   uint32_t size;
-    union {
+   union
-        uint8_t data[0xf8];
+   {
-        SmdVector spec;
+      uint8_t data[0xf8];
-        uint32_t vectorPaddr;
+      SmdVector spec;
-    };
+      uint32_t vectorPaddr;
+   };
 };
 WUT_CHECK_OFFSET(SmdElement, 0x00, type);
 WUT_CHECK_OFFSET(SmdElement, 0x04, size);
@@ -94,13 +95,14 @@ WUT_CHECK_SIZE(SmdElement, 0x100);
 
 struct SmdReceiveData
 {
-    SmdElementType type;
+   SmdElementType type;
-    uint32_t size;
+   uint32_t size;
-    union {
+   union
-        uint8_t message[0x80];
+   {
-        SmdVector spec;
+      uint8_t message[0x80];
-        SmdVector *vector;
+      SmdVector spec;
-    };
+      SmdVector *vector;
+   };
 };
 WUT_CHECK_OFFSET(SmdReceiveData, 0x00, type);
 WUT_CHECK_OFFSET(SmdReceiveData, 0x04, size);
@@ -111,16 +113,16 @@ WUT_CHECK_SIZE(SmdReceiveData, 0x88);
 
 struct SmdInterface
 {
-    SmdInterfaceState state;
+   SmdInterfaceState state;
-    WUT_PADDING_BYTES(0x7C);
+   WUT_PADDING_BYTES(0x7C);
-    uint32_t elementCount;
+   uint32_t elementCount;
-    WUT_PADDING_BYTES(0x7C);
+   WUT_PADDING_BYTES(0x7C);
-    int32_t readOffset;
+   int32_t readOffset;
-    WUT_PADDING_BYTES(0x7C);
+   WUT_PADDING_BYTES(0x7C);
-    int32_t writeOffset;
+   int32_t writeOffset;
-    WUT_PADDING_BYTES(0x7C);
+   WUT_PADDING_BYTES(0x7C);
-    uint32_t bufPaddr;
+   uint32_t bufPaddr;
-    WUT_PADDING_BYTES(0x7C);
+   WUT_PADDING_BYTES(0x7C);
 };
 WUT_CHECK_OFFSET(SmdInterface, 0x000, state);
 WUT_CHECK_OFFSET(SmdInterface, 0x080, elementCount);
@@ -131,13 +133,13 @@ WUT_CHECK_SIZE(SmdInterface, 0x280);
 
 struct SmdCtrlTable
 {
-    char name[0x10];
+   char name[0x10];
-    uint32_t reusedCount;
+   uint32_t reusedCount;
-    WUT_PADDING_BYTES(0x6C);
+   WUT_PADDING_BYTES(0x6C);
-    SmdInterface iopInterface;
+   SmdInterface iopInterface;
-    WUT_PADDING_BYTES(0x40);
+   WUT_PADDING_BYTES(0x40);
-    SmdInterface ppcInterface;
+   SmdInterface ppcInterface;
-    WUT_PADDING_BYTES(0x40);
+   WUT_PADDING_BYTES(0x40);
 };
 WUT_CHECK_OFFSET(SmdCtrlTable, 0x000, name);
 WUT_CHECK_OFFSET(SmdCtrlTable, 0x010, reusedCount);
@@ -147,12 +149,12 @@ WUT_CHECK_SIZE(SmdCtrlTable, 0x600);
 
 struct SmdPpcCtrlTableVectors
 {
-    SmdCtrlTable *ctrlTable;
+   SmdCtrlTable *ctrlTable;
-    uint32_t ctrlTableSize;
+   uint32_t ctrlTableSize;
-    SmdElement *writeBuf;
+   SmdElement *writeBuf;
-    uint32_t writeBufSize;
+   uint32_t writeBufSize;
-    SmdElement *readBuf;
+   SmdElement *readBuf;
-    uint32_t readBufSize;
+   uint32_t readBufSize;
 };
 WUT_CHECK_OFFSET(SmdPpcCtrlTableVectors, 0x00, ctrlTable);
 WUT_CHECK_OFFSET(SmdPpcCtrlTableVectors, 0x04, ctrlTableSize);
@@ -164,15 +166,15 @@ WUT_CHECK_SIZE(SmdPpcCtrlTableVectors, 0x18);
 
 struct SmdPpc
 {
-    SmdPpc *self;
+   SmdPpc *self;
-    SmdCtrlTable *ctrlTable;
+   SmdCtrlTable *ctrlTable;
-    SmdLockType lockType;
+   SmdLockType lockType;
-    OSMutex mutex;
+   OSMutex mutex;
-    uint32_t messageCount;
+   uint32_t messageCount;
-    SmdElement *writeBuf;
+   SmdElement *writeBuf;
-    SmdElement *readBuf;
+   SmdElement *readBuf;
-    SmdPpcState state;
+   SmdPpcState state;
-    WUT_PADDING_BYTES(0x38);
+   WUT_PADDING_BYTES(0x38);
 };
 WUT_CHECK_OFFSET(SmdPpc, 0x00, self);
 WUT_CHECK_OFFSET(SmdPpc, 0x04, ctrlTable);
@@ -186,19 +188,19 @@ WUT_CHECK_SIZE(SmdPpc, 0x80);
 
 struct SmdSimpleBufPool
 {
-    SmdSimpleBufPool *self;
+   SmdSimpleBufPool *self;
-    OSMutex mutex;
+   OSMutex mutex;
-    void *poolData;
+   void *poolData;
-    uint32_t poolDataSize;
+   uint32_t poolDataSize;
-    SmdLockType lockType;
+   SmdLockType lockType;
-    uint32_t allocSize;
+   uint32_t allocSize;
-    uint32_t realAllocSize;
+   uint32_t realAllocSize;
-    uint32_t maxAllocCount;
+   uint32_t maxAllocCount;
-    void *allocPoolStart;
+   void *allocPoolStart;
-    void *allocPoolEnd;
+   void *allocPoolEnd;
-    uint32_t elementsIn;
+   uint32_t elementsIn;
-    uint32_t freeErrorCount;
+   uint32_t freeErrorCount;
-    WUT_PADDING_BYTES(0x28);
+   WUT_PADDING_BYTES(0x28);
 };
 WUT_CHECK_OFFSET(SmdSimpleBufPool, 0x00, self);
 WUT_CHECK_OFFSET(SmdSimpleBufPool, 0x04, mutex);

include/coreinit/stopwatch.h

@@ -0,0 +1,93 @@
+#pragma once
+
+#include <wut.h>
+#include "spinlock.h"
+#include "time.h"
+
+/**
+ * \defgroup coreinit_stopwatch Lock-based Stopwatch
+ * \ingroup coreinit
+ *
+ * @{
+ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct OSStopwatch OSStopwatch;
+
+struct OSStopwatch
+{
+   //! Lock
+   OSSpinLock lock;
+   //! Tag
+   const char *name;
+   //! Number of times the stopwatch has been stopped
+   uint32_t hitCount;
+   //! Total time from first start to last stop
+   OSTime totalTime;
+   //! Minimum time between stops
+   OSTime minTime;
+   //! Maximum time between stops
+   OSTime maxTime;
+   //! Last time the watch was started
+   OSTime startTime;
+   //! Whether the stopwatch is running
+   BOOL running;
+   WUT_PADDING_BYTES(0x4);
+};
+WUT_CHECK_OFFSET(OSStopwatch, 0x00, lock);
+WUT_CHECK_OFFSET(OSStopwatch, 0x10, name);
+WUT_CHECK_OFFSET(OSStopwatch, 0x14, hitCount);
+WUT_CHECK_OFFSET(OSStopwatch, 0x18, totalTime);
+WUT_CHECK_OFFSET(OSStopwatch, 0x20, minTime);
+WUT_CHECK_OFFSET(OSStopwatch, 0x28, maxTime);
+WUT_CHECK_OFFSET(OSStopwatch, 0x30, startTime);
+WUT_CHECK_OFFSET(OSStopwatch, 0x38, running);
+WUT_CHECK_SIZE(OSStopwatch, 0x40);
+
+/**
+ * Initialises the stopwatch,
+ * stopwatches must be initialized before any other stopwatch functions are used
+ */
+void
+OSInitStopwatch(OSStopwatch *stopwatch,
+                const char *name);
+
+/**
+ *  Resets all stopwatch data
+ */
+void
+OSResetStopwatch(OSStopwatch *stopwatch);
+
+/**
+ * Starts the stopwatch.
+ * if already started, will update the start time without resetting the total time
+ */
+void
+OSStartStopwatch(OSStopwatch *stopwatch);
+
+/**
+ * Stops the stopwatch and increments hit count.
+ * Nothing happens if the stopwatch has already been stopped
+ */
+void
+OSStopStopwatch(OSStopwatch *stopwatch);
+
+/**
+ * Returns the total time the stopwatch has been running
+ */
+OSTime
+OSCheckStopwatch(OSStopwatch *stopwatch);
+
+/**
+ *  Dumps stopwatch info to the Cafe OS warn log
+ */
+void
+OSDumpStopwatch(OSStopwatch *stopwatch);
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */

include/coreinit/stopwatchatomic.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <wut.h>
+#include "time.h"
+
+/**
+ * \defgroup coreinit_stopwatchatomic Atomic Stopwatch
+ * \ingroup coreinit
+ *
+ * @{
+ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct OSStopWatchAtomic OSStopWatchAtomic;
+
+struct OSStopWatchAtomic
+{
+   //! Last time the watch was started
+   OSTime startTime;
+   //! Total time from first start to last stop
+   OSTime totalTime;
+};
+WUT_CHECK_OFFSET(OSStopWatchAtomic, 0x00, startTime);
+WUT_CHECK_OFFSET(OSStopWatchAtomic, 0x08, totalTime);
+WUT_CHECK_SIZE(OSStopWatchAtomic, 0x10);
+
+/**
+ * Start the stopwatch.
+ * Only updates the start time
+ * \returns total time on stopwatch
+ */
+OSTime
+OSStopWatchStart(OSStopWatchAtomic *stopWatch);
+
+/**
+ * Stop the stopwatch.
+ * Resets the start time to 0
+ * \returns total time on stopwatch
+ */
+OSTime
+OSStopWatchStop(OSStopWatchAtomic *stopWatch);
+
+/**
+ * Get the current time on the stopwatch
+ * \returns current time on stopwatch
+ */
+OSTime
+OSStopWatchLap(OSStopWatchAtomic *stopWatch);
+
+
+/**
+ * Stops and resets the stop watch.
+ * Clears start and total time
+ * \returns previous total time
+ */
+OSTime
+OSStopWatchReset(OSStopWatchAtomic *stopWatch);
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */

include/coreinit/taskqueue.h

@@ -21,19 +21,19 @@ typedef uint32_t (*MPTaskFunc)(uint32_t, uint32_t);
 
 typedef enum MPTaskState
 {
-   MP_TASK_STATE_INITIALISED           = 1 << 0,
+   MP_TASK_STATE_INITIALISED = 1 << 0,
-   MP_TASK_STATE_READY                 = 1 << 1,
+   MP_TASK_STATE_READY       = 1 << 1,
-   MP_TASK_STATE_RUNNING               = 1 << 2,
+   MP_TASK_STATE_RUNNING     = 1 << 2,
-   MP_TASK_STATE_FINISHED              = 1 << 3,
+   MP_TASK_STATE_FINISHED    = 1 << 3,
 } MPTaskState;
 
 typedef enum MPTaskQueueState
 {
-   MP_TASK_QUEUE_STATE_INITIALISED     = 1 << 0,
+   MP_TASK_QUEUE_STATE_INITIALISED = 1 << 0,
-   MP_TASK_QUEUE_STATE_READY           = 1 << 1,
+   MP_TASK_QUEUE_STATE_READY       = 1 << 1,
-   MP_TASK_QUEUE_STATE_STOPPING        = 1 << 2,
+   MP_TASK_QUEUE_STATE_STOPPING    = 1 << 2,
-   MP_TASK_QUEUE_STATE_STOPPED         = 1 << 3,
+   MP_TASK_QUEUE_STATE_STOPPED     = 1 << 3,
-   MP_TASK_QUEUE_STATE_FINISHED        = 1 << 4,
+   MP_TASK_QUEUE_STATE_FINISHED    = 1 << 4,
 } MPTaskQueueState;
 
 #pragma pack(push, 1)
@@ -177,7 +177,7 @@ MPInitTask(MPTask *task,
            uint32_t userArg2);
 
 BOOL
-MPTermTask(MPTask* task);
+MPTermTask(MPTask *task);
 
 BOOL
 MPGetTaskInfo(MPTask *task,

include/coreinit/thread.h

@@ -3,9 +3,9 @@
 #include <time.h>
 #include "alarm.h"
 #include "context.h"
-#include "time.h"
-#include "threadqueue.h"
 #include "exception.h"
+#include "threadqueue.h"
+#include "time.h"
 
 /**
  * \defgroup coreinit_thread Thread
@@ -60,73 +60,74 @@ typedef void (*OSThreadDeallocatorFn)(OSThread *thread, void *stack);
 typedef enum OSThreadSpecificID
 {
    //! These can be used by applications
-   OS_THREAD_SPECIFIC_0                = 0,
+   OS_THREAD_SPECIFIC_0              = 0,
-   OS_THREAD_SPECIFIC_1                = 1,
+   OS_THREAD_SPECIFIC_1              = 1,
-   OS_THREAD_SPECIFIC_2                = 2,
+   OS_THREAD_SPECIFIC_2              = 2,
-   OS_THREAD_SPECIFIC_3                = 3,
+   OS_THREAD_SPECIFIC_3              = 3,
-   OS_THREAD_SPECIFIC_4                = 4,
+   OS_THREAD_SPECIFIC_4              = 4,
-   OS_THREAD_SPECIFIC_5                = 5,
+   OS_THREAD_SPECIFIC_5              = 5,
-   OS_THREAD_SPECIFIC_6                = 6,
+   OS_THREAD_SPECIFIC_6              = 6,
-   OS_THREAD_SPECIFIC_7                = 7,
+   OS_THREAD_SPECIFIC_7              = 7,
-   OS_THREAD_SPECIFIC_8                = 8,
+   OS_THREAD_SPECIFIC_8              = 8,
-   OS_THREAD_SPECIFIC_9                = 9,
+   OS_THREAD_SPECIFIC_9              = 9,
-   OS_THREAD_SPECIFIC_10               = 10,
+   OS_THREAD_SPECIFIC_10             = 10,
-   OS_THREAD_SPECIFIC_11               = 11,
+   OS_THREAD_SPECIFIC_11             = 11,
-   OS_THREAD_SPECIFIC_12               = 12,
+   OS_THREAD_SPECIFIC_12             = 12,
-   OS_THREAD_SPECIFIC_13               = 13,
+   OS_THREAD_SPECIFIC_13             = 13,
    //! These are reserved to wut for internal use
-   OS_THREAD_SPECIFIC_WUT_RESERVED_0   = 14,
+   OS_THREAD_SPECIFIC_WUT_RESERVED_0 = 14,
-   OS_THREAD_SPECIFIC_WUT_RESERVED_1   = 15,
+   OS_THREAD_SPECIFIC_WUT_RESERVED_1 = 15,
 } OSThreadSpecificID;
 
 enum OS_THREAD_STATE
 {
-   OS_THREAD_STATE_NONE             = 0,
+   OS_THREAD_STATE_NONE     = 0,
 
    //! Thread is ready to run
-   OS_THREAD_STATE_READY            = 1 << 0,
+   OS_THREAD_STATE_READY    = 1 << 0,
 
    //! Thread is running
-   OS_THREAD_STATE_RUNNING          = 1 << 1,
+   OS_THREAD_STATE_RUNNING  = 1 << 1,
 
    //! Thread is waiting, i.e. on a mutex
-   OS_THREAD_STATE_WAITING          = 1 << 2,
+   OS_THREAD_STATE_WAITING  = 1 << 2,
 
    //! Thread is about to terminate
-   OS_THREAD_STATE_MORIBUND         = 1 << 3,
+   OS_THREAD_STATE_MORIBUND = 1 << 3,
 };
 
 enum OS_THREAD_REQUEST
 {
-   OS_THREAD_REQUEST_NONE           = 0,
+   OS_THREAD_REQUEST_NONE    = 0,
-   OS_THREAD_REQUEST_SUSPEND        = 1,
+   OS_THREAD_REQUEST_SUSPEND = 1,
-   OS_THREAD_REQUEST_CANCEL         = 2,
+   OS_THREAD_REQUEST_CANCEL  = 2,
 };
 
 enum OS_THREAD_ATTRIB
 {
    //! Allow the thread to run on CPU0.
-   OS_THREAD_ATTRIB_AFFINITY_CPU0   = 1 << 0,
+   OS_THREAD_ATTRIB_AFFINITY_CPU0 = 1 << 0,
 
    //! Allow the thread to run on CPU1.
-   OS_THREAD_ATTRIB_AFFINITY_CPU1   = 1 << 1,
+   OS_THREAD_ATTRIB_AFFINITY_CPU1 = 1 << 1,
 
    //! Allow the thread to run on CPU2.
-   OS_THREAD_ATTRIB_AFFINITY_CPU2   = 1 << 2,
+   OS_THREAD_ATTRIB_AFFINITY_CPU2 = 1 << 2,
 
    //! Allow the thread to run any CPU.
-   OS_THREAD_ATTRIB_AFFINITY_ANY    = ((1 << 0) | (1 << 1) | (1 << 2)),
+   OS_THREAD_ATTRIB_AFFINITY_ANY  = ((1 << 0) | (1 << 1) | (1 << 2)),
 
    //! Start the thread detached.
-   OS_THREAD_ATTRIB_DETACHED        = 1 << 3,
+   OS_THREAD_ATTRIB_DETACHED      = 1 << 3,
 
    //! Enables tracking of stack usage.
-   OS_THREAD_ATTRIB_STACK_USAGE     = 1 << 5,
+   OS_THREAD_ATTRIB_STACK_USAGE   = 1 << 5,
 
-   OS_THREAD_ATTRIB_UNKNOWN         = 1 << 7
+   OS_THREAD_ATTRIB_UNKNOWN       = 1 << 7
 };
 
-enum OS_THREAD_TYPE {
+enum OS_THREAD_TYPE
+{
    OS_THREAD_TYPE_DRIVER = 0,
    OS_THREAD_TYPE_IO     = 1,
    OS_THREAD_TYPE_APP    = 2
@@ -169,7 +170,7 @@ WUT_CHECK_SIZE(OSFastMutexQueue, 0x08);
 
 struct OSTLSSection
 {
-   void* data;
+   void *data;
    WUT_UNKNOWN_BYTES(4);
 };
 WUT_CHECK_OFFSET(OSTLSSection, 0x00, data);
@@ -309,10 +310,10 @@ struct WUT_ALIGNAS(8) OSThread
    WUT_UNKNOWN_BYTES(0x2);
 
    //! TLS Sections
-   OSTLSSection* tlsSections;
+   OSTLSSection *tlsSections;
 
    //! The fast mutex we are currently waiting for
-   OSFastMutex* fastMutex;
+   OSFastMutex *fastMutex;
 
    //! The fast mutexes we are currently contended on
    OSFastMutexQueue contendedFastMutexes;

include/coreinit/time.h

@@ -53,17 +53,17 @@ WUT_CHECK_OFFSET(OSCalendarTime, 0x20, tm_msec);
 WUT_CHECK_OFFSET(OSCalendarTime, 0x24, tm_usec);
 WUT_CHECK_SIZE(OSCalendarTime, 0x28);
 
-#define OSTimerClockSpeed ((OSGetSystemInfo()->busClockSpeed) / 4)
+#define OSTimerClockSpeed          ((OSGetSystemInfo()->busClockSpeed) / 4)
 
-#define OSSecondsToTicks(val)        ((uint64_t)(val) * (uint64_t)OSTimerClockSpeed)
+#define OSSecondsToTicks(val)      ((uint64_t)(val) * (uint64_t)OSTimerClockSpeed)
-#define OSMillisecondsToTicks(val)  (((uint64_t)(val) * (uint64_t)OSTimerClockSpeed) / 1000ull)
+#define OSMillisecondsToTicks(val) (((uint64_t)(val) * (uint64_t)OSTimerClockSpeed) / 1000ull)
-#define OSMicrosecondsToTicks(val)  (((uint64_t)(val) * (uint64_t)OSTimerClockSpeed) / 1000000ull)
+#define OSMicrosecondsToTicks(val) (((uint64_t)(val) * (uint64_t)OSTimerClockSpeed) / 1000000ull)
-#define OSNanosecondsToTicks(val)   (((uint64_t)(val) * ((uint64_t)OSTimerClockSpeed) / 31250ull) / 32000ull)
+#define OSNanosecondsToTicks(val)  (((uint64_t)(val) * ((uint64_t)OSTimerClockSpeed) / 31250ull) / 32000ull)
 
-#define OSTicksToSeconds(val)        ((uint64_t)(val) / (uint64_t)OSTimerClockSpeed)
+#define OSTicksToSeconds(val)      ((uint64_t)(val) / (uint64_t)OSTimerClockSpeed)
-#define OSTicksToMilliseconds(val)  (((uint64_t)(val) * 1000ull) / (uint64_t)OSTimerClockSpeed)
+#define OSTicksToMilliseconds(val) (((uint64_t)(val) * 1000ull) / (uint64_t)OSTimerClockSpeed)
-#define OSTicksToMicroseconds(val)  (((uint64_t)(val) * 1000000ull) / (uint64_t)OSTimerClockSpeed)
+#define OSTicksToMicroseconds(val) (((uint64_t)(val) * 1000000ull) / (uint64_t)OSTimerClockSpeed)
-#define OSTicksToNanoseconds(val)   (((uint64_t)(val) * 32000ull) / ((uint64_t)OSTimerClockSpeed / 31250ull))
+#define OSTicksToNanoseconds(val)  (((uint64_t)(val) * 32000ull) / ((uint64_t)OSTimerClockSpeed / 31250ull))
 
 OSTime
 OSGetTime();
@@ -84,6 +84,9 @@ void
 OSTicksToCalendarTime(OSTime time,
                       OSCalendarTime *calendarTime);
 
+BOOL
+__OSSetAbsoluteSystemTime(OSTime time);
+
 #ifdef __cplusplus
 }
 #endif

include/coreinit/title.h

@@ -11,7 +11,8 @@
 extern "C" {
 #endif
 
-uint64_t OSGetTitleID(void);
+uint64_t
+OSGetTitleID(void);
 
 #ifdef __cplusplus
 }

include/coreinit/transition.h

@@ -9,8 +9,9 @@ extern "C" {
 int
 __OSGetSavedAudioFlags();
 
-int __OSGetTransitionAudioBuffer(void **buffer,
+int
-                                 uint32_t *size);
+__OSGetTransitionAudioBuffer(void **buffer,
+                             uint32_t *size);
 
 void
 __OSSetTransitionAudioSize(uint32_t size);

include/coreinit/userconfig.h

@@ -20,75 +20,75 @@ typedef struct UCAsyncParams UCAsyncParams;
 
 typedef enum UCCommand
 {
-   UC_CMD_READ_SYS_CONFIG        = 0x30,
+   UC_CMD_READ_SYS_CONFIG   = 0x30,
-   UC_CMD_WRITE_SYS_CONFIG       = 0x31,
+   UC_CMD_WRITE_SYS_CONFIG  = 0x31,
-   UC_CMD_DELETE_SYS_CONFIG      = 0x32,
+   UC_CMD_DELETE_SYS_CONFIG = 0x32,
-   UC_CMD_QUERY_SYS_CONFIG       = 0x33,
+   UC_CMD_QUERY_SYS_CONFIG  = 0x33,
-   UC_CMD_LIST_SYS_CONFIG        = 0x34,
+   UC_CMD_LIST_SYS_CONFIG   = 0x34,
 } UCCommand;
 
 typedef enum UCDataType
 {
-   UC_DATATYPE_UNDEFINED         = 0x00,
+   UC_DATATYPE_UNDEFINED      = 0x00,
-   UC_DATATYPE_UNSIGNED_BYTE     = 0x01,
+   UC_DATATYPE_UNSIGNED_BYTE  = 0x01,
-   UC_DATATYPE_UNSIGNED_SHORT    = 0x02,
+   UC_DATATYPE_UNSIGNED_SHORT = 0x02,
-   UC_DATATYPE_UNSIGNED_INT      = 0x03,
+   UC_DATATYPE_UNSIGNED_INT   = 0x03,
-   UC_DATATYPE_SIGNED_INT        = 0x04,
+   UC_DATATYPE_SIGNED_INT     = 0x04,
-   UC_DATATYPE_FLOAT             = 0x05,
+   UC_DATATYPE_FLOAT          = 0x05,
-   UC_DATATYPE_STRING            = 0x06,
+   UC_DATATYPE_STRING         = 0x06,
-   UC_DATATYPE_HEXBINARY         = 0x07,
+   UC_DATATYPE_HEXBINARY      = 0x07,
-   UC_DATATYPE_COMPLEX           = 0x08,
+   UC_DATATYPE_COMPLEX        = 0x08,
-   UC_DATATYPE_INVALID           = 0xFF,
+   UC_DATATYPE_INVALID        = 0xFF,
 } UCDataType;
 
 typedef enum UCErrors
 {
-   UC_ERROR_OK                   = 0,
+   UC_ERROR_OK               = 0,
-   UC_ERROR_ERROR                = -1,
+   UC_ERROR_ERROR            = -1,
-   UC_ERROR_OTHER                = -0x200001,
+   UC_ERROR_OTHER            = -0x200001,
-   UC_ERROR_SYSTEM               = -0x200002,
+   UC_ERROR_SYSTEM           = -0x200002,
-   UC_ERROR_ALLOC                = -0x200003,
+   UC_ERROR_ALLOC            = -0x200003,
-   UC_ERROR_OPCODE               = -0x200004,
+   UC_ERROR_OPCODE           = -0x200004,
-   UC_ERROR_INVALID_PARAM        = -0x200005,
+   UC_ERROR_INVALID_PARAM    = -0x200005,
-   UC_ERROR_INVALID_TYPE         = -0x200006,
+   UC_ERROR_INVALID_TYPE     = -0x200006,
-   UC_ERROR_UNSUPPORTED          = -0x200007,
+   UC_ERROR_UNSUPPORTED      = -0x200007,
-   UC_ERROR_NON_LEAF_NODE        = -0x200008,
+   UC_ERROR_NON_LEAF_NODE    = -0x200008,
-   UC_ERROR_KEY_NOT_FOUND        = -0x200009,
+   UC_ERROR_KEY_NOT_FOUND    = -0x200009,
-   UC_ERROR_MODIFY               = -0x20000A,
+   UC_ERROR_MODIFY           = -0x20000A,
-   UC_ERROR_STRING_TOO_LONG      = -0x20000B,
+   UC_ERROR_STRING_TOO_LONG  = -0x20000B,
-   UC_ERROR_ROOT_KEYS_DIFFER     = -0x20000C,
+   UC_ERROR_ROOT_KEYS_DIFFER = -0x20000C,
-   UC_ERROR_INVALID_LOCATION     = -0x20000D,
+   UC_ERROR_INVALID_LOCATION = -0x20000D,
-   UC_ERROR_BAD_COMMENT          = -0x20000E,
+   UC_ERROR_BAD_COMMENT      = -0x20000E,
-   UC_ERROR_READ_ACCESS          = -0x20000F,
+   UC_ERROR_READ_ACCESS      = -0x20000F,
-   UC_ERROR_WRITE_ACCESS         = -0x200010,
+   UC_ERROR_WRITE_ACCESS     = -0x200010,
-   UC_ERROR_CREATE_ACCESS        = -0x200011,
+   UC_ERROR_CREATE_ACCESS    = -0x200011,
-   UC_ERROR_FILE_SYS_NAME        = -0x200012,
+   UC_ERROR_FILE_SYS_NAME    = -0x200012,
-   UC_ERROR_FILE_SYS_INIT        = -0x200013,
+   UC_ERROR_FILE_SYS_INIT    = -0x200013,
-   UC_ERROR_FILE_SYS_MOUNT       = -0x200014,
+   UC_ERROR_FILE_SYS_MOUNT   = -0x200014,
-   UC_ERROR_FILE_OPEN            = -0x200015,
+   UC_ERROR_FILE_OPEN        = -0x200015,
-   UC_ERROR_FILE_STAT            = -0x200016,
+   UC_ERROR_FILE_STAT        = -0x200016,
-   UC_ERROR_FILE_READ            = -0x200017,
+   UC_ERROR_FILE_READ        = -0x200017,
-   UC_ERROR_FILE_WRITE           = -0x200018,
+   UC_ERROR_FILE_WRITE       = -0x200018,
-   UC_ERROR_FILE_TOO_BIG         = -0x200019,
+   UC_ERROR_FILE_TOO_BIG     = -0x200019,
-   UC_ERROR_FILE_REMOVE          = -0x20001A,
+   UC_ERROR_FILE_REMOVE      = -0x20001A,
-   UC_ERROR_FILE_RENAME          = -0x20001B,
+   UC_ERROR_FILE_RENAME      = -0x20001B,
-   UC_ERROR_FILE_CLOSE           = -0x20001C,
+   UC_ERROR_FILE_CLOSE       = -0x20001C,
-   UC_ERROR_FILE_SEEK            = -0x20001D,
+   UC_ERROR_FILE_SEEK        = -0x20001D,
-   UC_ERROR_FILE_CONFIRM         = -0x20001E,
+   UC_ERROR_FILE_CONFIRM     = -0x20001E,
-   UC_ERROR_FILE_BACKUP          = -0x20001F,
+   UC_ERROR_FILE_BACKUP      = -0x20001F,
-   UC_ERROR_MALFORMED_XML        = -0x200020,
+   UC_ERROR_MALFORMED_XML    = -0x200020,
-   UC_ERROR_VERSION              = -0x200021,
+   UC_ERROR_VERSION          = -0x200021,
-   UC_ERROR_NO_IPC_BUFFERS       = -0x200022,
+   UC_ERROR_NO_IPC_BUFFERS   = -0x200022,
-   UC_ERROR_FILE_LOCK_NEEDED     = -0x200024,
+   UC_ERROR_FILE_LOCK_NEEDED = -0x200024,
-   UC_ERROR_SYS_PROT             = -0x200028,
+   UC_ERROR_SYS_PROT         = -0x200028,
 } UCErrors;
 
 typedef enum UCFileSys
 {
-   UC_FILE_SYS_INVALID           = 0x00,
+   UC_FILE_SYS_INVALID = 0x00,
-   UC_FILE_SYS_SYS               = 0x01,
+   UC_FILE_SYS_SYS     = 0x01,
-   UC_FILE_SYS_SLC               = 0x02,
+   UC_FILE_SYS_SLC     = 0x02,
-   UC_FILE_SYS_RAM               = 0x03,
+   UC_FILE_SYS_RAM     = 0x03,
 } UCFileSys;
 
 #pragma pack(push, 1)
@@ -118,13 +118,13 @@ typedef void (*UCAsyncCallbackFn)(UCError result,
 #pragma pack(push, 1)
 struct UCAsyncParams
 {
-    UCAsyncCallbackFn callback;
+   UCAsyncCallbackFn callback;
-    void *context;
+   void *context;
-    UCCommand command;
+   UCCommand command;
-    uint32_t unk0x0C;
+   uint32_t unk0x0C;
-    uint32_t count;
+   uint32_t count;
-    UCSysConfig *settings;
+   UCSysConfig *settings;
-    IOSVec *vecs;
+   IOSVec *vecs;
 };
 #pragma pack(pop)
 WUT_CHECK_OFFSET(UCAsyncParams, 0x00, callback);

include/dmae/sync.h

@@ -1,5 +1,6 @@
 #pragma once
 #include <wut.h>
+#include <gx2/semaphore.h>
 
 /**
  * \defgroup dmae_sync Synchronization
@@ -14,6 +15,12 @@ extern "C" {
 //! Timestamp for a DMAE operation.
 typedef uint64_t DMAETimeStamp;
 
+DMAETimeStamp
+DMAEGetLastSubmittedTimeStamp(void);
+
+DMAETimeStamp
+DMAEGetRetiredTimeStamp(void);
+
 /**
  * Waits for a DMAE operation to complete.
  *
@@ -26,6 +33,16 @@ typedef uint64_t DMAETimeStamp;
 BOOL
 DMAEWaitDone(DMAETimeStamp timestamp);
 
+uint32_t
+DMAEGetTimeout(void);
+
+void
+DMAESetTimeout(uint32_t timeout);
+
+void
+DMAESemaphore(GX2Semaphore *semaphore,
+              GX2SemaphoreAction action);
+
 #ifdef __cplusplus
 }
 #endif

include/erreula/rpl_interface.h

@@ -17,30 +17,52 @@ struct FSClient;
 namespace Rpl
 {
 
-void ErrEulaSetVersion(int version);
+void
-bool ErrEulaJump(const char *buffer, uint32_t bufferSize);
+ErrEulaSetVersion(int version);
-void ErrEulaPlayAppearSE(bool playAppearSoundEffect);
+bool
-bool ErrEulaIsSelectCursorActive();
+ErrEulaJump(const char *buffer, uint32_t bufferSize);
-void ErrEulaChangeLang(nn::erreula::LangType language);
+void
-void ErrEulaDisappearHomeNixSign();
+ErrEulaPlayAppearSE(bool playAppearSoundEffect);
-bool ErrEulaIsAppearHomeNixSign();
+bool
-void ErrEulaAppearHomeNixSign(const nn::erreula::HomeNixSignArg &arg);
+ErrEulaIsSelectCursorActive();
-void ErrEulaSetControllerRemo(nn::erreula::ControllerType controller);
+void
-int32_t ErrEulaGetSelectButtonNumError();
+ErrEulaChangeLang(nn::erreula::LangType language);
-int32_t ErrEulaGetResultCode();
+void
-nn::erreula::ResultType ErrEulaGetResultType();
+ErrEulaDisappearHomeNixSign();
-nn::erreula::State ErrEulaGetStateErrorViewer();
+bool
-bool ErrEulaIsDecideSelectRightButtonError();
+ErrEulaIsAppearHomeNixSign();
-bool ErrEulaIsDecideSelectLeftButtonError();
+void
-bool ErrEulaIsDecideSelectButtonError();
+ErrEulaAppearHomeNixSign(const nn::erreula::HomeNixSignArg &arg);
-void ErrEulaDisappearError();
+void
-void ErrEulaAppearError(const nn::erreula::AppearArg &arg);
+ErrEulaSetControllerRemo(nn::erreula::ControllerType controller);
-void ErrEulaCalc(const nn::erreula::ControllerInfo &controllerInfo);
+int32_t
-void ErrEulaDrawDRC();
+ErrEulaGetSelectButtonNumError();
-void ErrEulaDrawTV();
+int32_t
-void ErrEulaDestroy();
+ErrEulaGetResultCode();
-void ErrEulaCreate(void *workMemory, nn::erreula::RegionType region,
+nn::erreula::ResultType
-                   nn::erreula::LangType language, FSClient *fsClient);
+ErrEulaGetResultType();
+nn::erreula::State
+ErrEulaGetStateErrorViewer();
+bool
+ErrEulaIsDecideSelectRightButtonError();
+bool
+ErrEulaIsDecideSelectLeftButtonError();
+bool
+ErrEulaIsDecideSelectButtonError();
+void
+ErrEulaDisappearError();
+void
+ErrEulaAppearError(const nn::erreula::AppearArg &arg);
+void
+ErrEulaCalc(const nn::erreula::ControllerInfo &controllerInfo);
+void
+ErrEulaDrawDRC();
+void
+ErrEulaDrawTV();
+void
+ErrEulaDestroy();
+void
+ErrEulaCreate(void *workMemory, nn::erreula::RegionType region, nn::erreula::LangType language, FSClient *fsClient);
 
 } // namespace Rpl
 

include/gx2/aperture.h

@@ -0,0 +1,62 @@
+#pragma once
+#include <wut.h>
+#include "enum.h"
+#include "surface.h"
+
+/**
+ * \defgroup gx2_aperture Aperture
+ * \ingroup gx2
+ * @{
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef uint32_t GX2ApertureHandle;
+
+/**
+ * Allocates a tiling aperture.
+ * This function creates a linear and untiled buffer to read from and write to the surface.
+ * The total size of the buffer will be width * height * bpp.
+ * 
+ * \param surface
+ * A pointer to the surface to create the tiling aperture for.
+ * 
+ * \param level
+ * The level of the surface to create the tiling aperture for.
+ *
+ * \param depth
+ * The depth of the surface to create the tiling aperture for.
+ * 
+ * \param endian
+ * The endian swap mode.
+ * 
+ * \param outHandle
+ * A pointer to store the handle for the aperture.
+ * 
+ * \param outAddress
+ * A pointer to store the address for the aperture.
+ */
+void
+GX2AllocateTilingApertureEx(GX2Surface *surface,
+                            uint32_t level,
+                            uint32_t depth,
+                            GX2EndianSwapMode endian,
+                            GX2ApertureHandle *outHandle,
+                            void **outAddress);
+
+/**
+ * Frees an allocated tiling aperture.
+ *
+ * \param handle
+ * The handle of the tiling aperture which should be freed.
+ */
+void
+GX2FreeTilingAperture(GX2ApertureHandle handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */

include/gx2/debug.h

@@ -16,27 +16,27 @@ typedef struct GX2DebugCaptureInterface GX2DebugCaptureInterface;
 
 typedef enum GX2DebugCaptureInterfaceVersion
 {
-   GX2_DEBUG_CAPTURE_INTERFACE_VERSION                = 1,
+   GX2_DEBUG_CAPTURE_INTERFACE_VERSION = 1,
 } GX2DebugCaptureInterfaceVersion;
 
 //! Options for \link GX2DebugCaptureStart \endlink.
 typedef enum GX2DebugCaptureStartFlags
 {
    //! When set \link GX2DebugCaptureStart \endlink will call \link GX2DrawDone \endlink before the capture is started.
-   GX2_DEBUG_CAPTURE_START_FLAGS_NONE                 = 0,
+   GX2_DEBUG_CAPTURE_START_FLAGS_NONE                = 0,
 
    //! When set \link GX2DebugCaptureStart \endlink will NOT call \link GX2DrawDone \endlink.
-   GX2_DEBUG_CAPTURE_START_FLAGS_DISABLE_GX2DRAWDONE  = 1,
+   GX2_DEBUG_CAPTURE_START_FLAGS_DISABLE_GX2DRAWDONE = 1,
 } GX2DebugCaptureStartFlags;
 
 //! Options for \link GX2DebugCaptureEnd \endlink.
 typedef enum GX2DebugCaptureEndFlags
 {
    //! When set \link GX2DebugCaptureEnd \endlink will call \link GX2Flush \endlink before the capture is completed.
-   GX2_DEBUG_CAPTURE_END_FLAGS_NONE                   = 0,
+   GX2_DEBUG_CAPTURE_END_FLAGS_NONE             = 0,
 
    //! When set \link GX2DebugCaptureEnd \endlink will NOT call \link GX2Flush \endlink.
-   GX2_DEBUG_CAPTURE_END_FLAGS_DISABLE_GX2FLUSH       = 1,
+   GX2_DEBUG_CAPTURE_END_FLAGS_DISABLE_GX2FLUSH = 1,
 } GX2DebugCaptureEndFlags;
 
 struct GX2DebugCaptureInterface
@@ -140,7 +140,7 @@ GX2DebugCaptureEnd(GX2DebugCaptureEndFlags flags);
  * Equivalent to calling GX2DebugCaptureFrames(filename, 1)
  */
 void
-GX2DebugCaptureFrame(const char* filename);
+GX2DebugCaptureFrame(const char *filename);
 
 
 /**
@@ -152,7 +152,7 @@ GX2DebugCaptureFrame(const char* filename);
  * Capture begins and ends during GX2SwapScanBuffers.
  */
 void
-GX2DebugCaptureFrames(const char* filename,
+GX2DebugCaptureFrames(const char *filename,
                       uint32_t count);
 
 #ifdef __cplusplus

include/gx2/display.h

@@ -57,6 +57,9 @@ void
 GX2SetDRCScale(uint32_t x,
                uint32_t y);
 
+GX2AspectRatio
+GX2GetSystemTVAspectRatio();
+
 GX2TVScanMode
 GX2GetSystemTVScanMode();
 

include/gx2/enum.h

@@ -11,176 +11,188 @@
 extern "C" {
 #endif
 
-#define GX2_FALSE                           (0)
+#define GX2_FALSE                    (0)
-#define GX2_TRUE                            (1)
+#define GX2_TRUE                     (1)
-#define GX2_DISABLE                         (0)
+#define GX2_DISABLE                  (0)
-#define GX2_ENABLE                          (1)
+#define GX2_ENABLE                   (1)
 
-#define GX2_COMMAND_BUFFER_ALIGNMENT        (0x40)
+#define GX2_COMMAND_BUFFER_ALIGNMENT (0x40)
-#define GX2_CONTEXT_STATE_ALIGNMENT         (0x100)
+#define GX2_CONTEXT_STATE_ALIGNMENT  (0x100)
-#define GX2_SCAN_BUFFER_ALIGNMENT           (0x1000)
+#define GX2_SCAN_BUFFER_ALIGNMENT    (0x1000)
-#define GX2_SHADER_PROGRAM_ALIGNMENT        (0x100)
+#define GX2_SHADER_PROGRAM_ALIGNMENT (0x100)
-#define GX2_VERTEX_BUFFER_ALIGNMENT         (0x40)
+#define GX2_VERTEX_BUFFER_ALIGNMENT  (0x40)
-#define GX2_INDEX_BUFFER_ALIGNMENT          (0x20)
+#define GX2_INDEX_BUFFER_ALIGNMENT   (0x20)
+#define GX2_UNIFORM_BLOCK_ALIGNMENT  (0x100)
 
-#define GX2_COMMAND_BUFFER_SIZE             (0x400000)
+#define GX2_COMMAND_BUFFER_SIZE      (0x400000)
 
 typedef enum GX2AAMode
 {
-   GX2_AA_MODE1X                          = 0,
+   GX2_AA_MODE1X = 0,
-   GX2_AA_MODE2X                          = 1,
+   GX2_AA_MODE2X = 1,
-   GX2_AA_MODE4X                          = 2
+   GX2_AA_MODE4X = 2,
+   GX2_AA_MODE8X = 3,
 } GX2AAMode;
 
 typedef enum GX2AlphaToMaskMode
 {
-   GX2_ALPHA_TO_MASK_MODE_NON_DITHERED    = 0,
+   GX2_ALPHA_TO_MASK_MODE_NON_DITHERED = 0,
-   GX2_ALPHA_TO_MASK_MODE_DITHER_0        = 1,
+   GX2_ALPHA_TO_MASK_MODE_DITHER_0     = 1,
-   GX2_ALPHA_TO_MASK_MODE_DITHER_90       = 2,
+   GX2_ALPHA_TO_MASK_MODE_DITHER_90    = 2,
-   GX2_ALPHA_TO_MASK_MODE_DITHER_180      = 3,
+   GX2_ALPHA_TO_MASK_MODE_DITHER_180   = 3,
-   GX2_ALPHA_TO_MASK_MODE_DITHER_270      = 4,
+   GX2_ALPHA_TO_MASK_MODE_DITHER_270   = 4,
 } GX2AlphaToMaskMode;
 
+typedef enum GX2AspectRatio
+{
+   GX2_ASPECT_RATIO_4_3  = 0,
+   GX2_ASPECT_RATIO_16_9 = 1,
+} GX2AspectRatio;
+
 typedef enum GX2AttribFormat
 {
-   GX2_ATTRIB_TYPE_8                      = 0x00,
+   GX2_ATTRIB_TYPE_8                   = 0x00,
-   GX2_ATTRIB_TYPE_4_4                    = 0x01,
+   GX2_ATTRIB_TYPE_4_4                 = 0x01,
-   GX2_ATTRIB_TYPE_16                     = 0x02,
+   GX2_ATTRIB_TYPE_16                  = 0x02,
-   GX2_ATTRIB_TYPE_16_FLOAT               = 0x03,
+   GX2_ATTRIB_TYPE_16_FLOAT            = 0x03,
-   GX2_ATTRIB_TYPE_8_8                    = 0x04,
+   GX2_ATTRIB_TYPE_8_8                 = 0x04,
-   GX2_ATTRIB_TYPE_32                     = 0x05,
+   GX2_ATTRIB_TYPE_32                  = 0x05,
-   GX2_ATTRIB_TYPE_32_FLOAT               = 0x06,
+   GX2_ATTRIB_TYPE_32_FLOAT            = 0x06,
-   GX2_ATTRIB_TYPE_16_16                  = 0x07,
+   GX2_ATTRIB_TYPE_16_16               = 0x07,
-   GX2_ATTRIB_TYPE_16_16_FLOAT            = 0x08,
+   GX2_ATTRIB_TYPE_16_16_FLOAT         = 0x08,
-   GX2_ATTRIB_TYPE_10_11_11_FLOAT         = 0x09,
+   GX2_ATTRIB_TYPE_10_11_11_FLOAT      = 0x09,
-   GX2_ATTRIB_TYPE_8_8_8_8                = 0x0A,
+   GX2_ATTRIB_TYPE_8_8_8_8             = 0x0A,
-   GX2_ATTRIB_TYPE_10_10_10_2             = 0x0B,
+   GX2_ATTRIB_TYPE_10_10_10_2          = 0x0B,
-   GX2_ATTRIB_TYPE_32_32                  = 0x0C,
+   GX2_ATTRIB_TYPE_32_32               = 0x0C,
-   GX2_ATTRIB_TYPE_32_32_FLOAT            = 0x0D,
+   GX2_ATTRIB_TYPE_32_32_FLOAT         = 0x0D,
-   GX2_ATTRIB_TYPE_16_16_16_16            = 0x0E,
+   GX2_ATTRIB_TYPE_16_16_16_16         = 0x0E,
-   GX2_ATTRIB_TYPE_16_16_16_16_FLOAT      = 0x0F,
+   GX2_ATTRIB_TYPE_16_16_16_16_FLOAT   = 0x0F,
-   GX2_ATTRIB_TYPE_32_32_32               = 0x10,
+   GX2_ATTRIB_TYPE_32_32_32            = 0x10,
-   GX2_ATTRIB_TYPE_32_32_32_FLOAT         = 0x11,
+   GX2_ATTRIB_TYPE_32_32_32_FLOAT      = 0x11,
-   GX2_ATTRIB_TYPE_32_32_32_32            = 0x12,
+   GX2_ATTRIB_TYPE_32_32_32_32         = 0x12,
-   GX2_ATTRIB_TYPE_32_32_32_32_FLOAT      = 0x13,
+   GX2_ATTRIB_TYPE_32_32_32_32_FLOAT   = 0x13,
 
-   GX2_ATTRIB_FLAG_INTEGER                = 0x100,
+   GX2_ATTRIB_FLAG_INTEGER             = 0x100,
-   GX2_ATTRIB_FLAG_SIGNED                 = 0x200,
+   GX2_ATTRIB_FLAG_SIGNED              = 0x200,
-   GX2_ATTRIB_FLAG_DEGAMMA                = 0x400,
+   GX2_ATTRIB_FLAG_DEGAMMA             = 0x400,
-   GX2_ATTRIB_FLAG_SCALED                 = 0x800,
+   GX2_ATTRIB_FLAG_SCALED              = 0x800,
 
-   GX2_ATTRIB_FORMAT_UNORM_8              = GX2_ATTRIB_TYPE_8,
+   GX2_ATTRIB_FORMAT_UNORM_8           = GX2_ATTRIB_TYPE_8,
-   GX2_ATTRIB_FORMAT_UNORM_8_8            = GX2_ATTRIB_TYPE_8_8,
+   GX2_ATTRIB_FORMAT_UNORM_8_8         = GX2_ATTRIB_TYPE_8_8,
-   GX2_ATTRIB_FORMAT_UNORM_8_8_8_8        = GX2_ATTRIB_TYPE_8_8_8_8,
+   GX2_ATTRIB_FORMAT_UNORM_8_8_8_8     = GX2_ATTRIB_TYPE_8_8_8_8,
 
-   GX2_ATTRIB_FORMAT_UINT_8               = GX2_ATTRIB_FLAG_INTEGER | GX2_ATTRIB_TYPE_8,
+   GX2_ATTRIB_FORMAT_UINT_8            = GX2_ATTRIB_FLAG_INTEGER | GX2_ATTRIB_TYPE_8,
-   GX2_ATTRIB_FORMAT_UINT_8_8             = GX2_ATTRIB_FLAG_INTEGER | GX2_ATTRIB_TYPE_8_8,
+   GX2_ATTRIB_FORMAT_UINT_8_8          = GX2_ATTRIB_FLAG_INTEGER | GX2_ATTRIB_TYPE_8_8,
-   GX2_ATTRIB_FORMAT_UINT_8_8_8_8         = GX2_ATTRIB_FLAG_INTEGER | GX2_ATTRIB_TYPE_8_8_8_8,
+   GX2_ATTRIB_FORMAT_UINT_8_8_8_8      = GX2_ATTRIB_FLAG_INTEGER | GX2_ATTRIB_TYPE_8_8_8_8,
 
-   GX2_ATTRIB_FORMAT_SNORM_8              = GX2_ATTRIB_FLAG_SIGNED | GX2_ATTRIB_TYPE_8,
+   GX2_ATTRIB_FORMAT_SNORM_8           = GX2_ATTRIB_FLAG_SIGNED | GX2_ATTRIB_TYPE_8,
-   GX2_ATTRIB_FORMAT_SNORM_8_8            = GX2_ATTRIB_FLAG_SIGNED | GX2_ATTRIB_TYPE_8_8,
+   GX2_ATTRIB_FORMAT_SNORM_8_8         = GX2_ATTRIB_FLAG_SIGNED | GX2_ATTRIB_TYPE_8_8,
-   GX2_ATTRIB_FORMAT_SNORM_8_8_8_8        = GX2_ATTRIB_FLAG_SIGNED | GX2_ATTRIB_TYPE_8_8_8_8,
+   GX2_ATTRIB_FORMAT_SNORM_8_8_8_8     = GX2_ATTRIB_FLAG_SIGNED | GX2_ATTRIB_TYPE_8_8_8_8,
 
-   GX2_ATTRIB_FORMAT_SINT_8               = GX2_ATTRIB_FLAG_SIGNED | GX2_ATTRIB_FLAG_INTEGER | GX2_ATTRIB_TYPE_8,
+   GX2_ATTRIB_FORMAT_SINT_8            = GX2_ATTRIB_FLAG_SIGNED | GX2_ATTRIB_FLAG_INTEGER | GX2_ATTRIB_TYPE_8,
-   GX2_ATTRIB_FORMAT_SINT_8_8             = GX2_ATTRIB_FLAG_SIGNED | GX2_ATTRIB_FLAG_INTEGER | GX2_ATTRIB_TYPE_8_8,
+   GX2_ATTRIB_FORMAT_SINT_8_8          = GX2_ATTRIB_FLAG_SIGNED | GX2_ATTRIB_FLAG_INTEGER | GX2_ATTRIB_TYPE_8_8,
-   GX2_ATTRIB_FORMAT_SINT_8_8_8_8         = GX2_ATTRIB_FLAG_SIGNED | GX2_ATTRIB_FLAG_INTEGER | GX2_ATTRIB_TYPE_8_8_8_8,
+   GX2_ATTRIB_FORMAT_SINT_8_8_8_8      = GX2_ATTRIB_FLAG_SIGNED | GX2_ATTRIB_FLAG_INTEGER | GX2_ATTRIB_TYPE_8_8_8_8,
 
-   GX2_ATTRIB_FORMAT_FLOAT_32             = GX2_ATTRIB_FLAG_SCALED | GX2_ATTRIB_TYPE_32_FLOAT,
+   GX2_ATTRIB_FORMAT_FLOAT_32          = GX2_ATTRIB_FLAG_SCALED | GX2_ATTRIB_TYPE_32_FLOAT,
-   GX2_ATTRIB_FORMAT_FLOAT_32_32          = GX2_ATTRIB_FLAG_SCALED | GX2_ATTRIB_TYPE_32_32_FLOAT,
+   GX2_ATTRIB_FORMAT_FLOAT_32_32       = GX2_ATTRIB_FLAG_SCALED | GX2_ATTRIB_TYPE_32_32_FLOAT,
-   GX2_ATTRIB_FORMAT_FLOAT_32_32_32       = GX2_ATTRIB_FLAG_SCALED | GX2_ATTRIB_TYPE_32_32_32_FLOAT,
+   GX2_ATTRIB_FORMAT_FLOAT_32_32_32    = GX2_ATTRIB_FLAG_SCALED | GX2_ATTRIB_TYPE_32_32_32_FLOAT,
-   GX2_ATTRIB_FORMAT_FLOAT_32_32_32_32    = GX2_ATTRIB_FLAG_SCALED | GX2_ATTRIB_TYPE_32_32_32_32_FLOAT,
+   GX2_ATTRIB_FORMAT_FLOAT_32_32_32_32 = GX2_ATTRIB_FLAG_SCALED | GX2_ATTRIB_TYPE_32_32_32_32_FLOAT,
 } GX2AttribFormat;
 
 WUT_ENUM_BITMASK_TYPE(GX2AttribFormat)
 
 typedef enum GX2AttribIndexType
 {
-   GX2_ATTRIB_INDEX_PER_VERTEX            = 0,
+   GX2_ATTRIB_INDEX_PER_VERTEX   = 0,
-   GX2_ATTRIB_INDEX_PER_INSTANCE          = 1,
+   GX2_ATTRIB_INDEX_PER_INSTANCE = 1,
 } GX2AttribIndexType;
 
 typedef enum GX2BlendMode
 {
-   GX2_BLEND_MODE_ZERO                    = 0,
+   GX2_BLEND_MODE_ZERO               = 0,
-   GX2_BLEND_MODE_ONE                     = 1,
+   GX2_BLEND_MODE_ONE                = 1,
-   GX2_BLEND_MODE_SRC_COLOR               = 2,
+   GX2_BLEND_MODE_SRC_COLOR          = 2,
-   GX2_BLEND_MODE_INV_SRC_COLOR           = 3,
+   GX2_BLEND_MODE_INV_SRC_COLOR      = 3,
-   GX2_BLEND_MODE_SRC_ALPHA               = 4,
+   GX2_BLEND_MODE_SRC_ALPHA          = 4,
-   GX2_BLEND_MODE_INV_SRC_ALPHA           = 5,
+   GX2_BLEND_MODE_INV_SRC_ALPHA      = 5,
-   GX2_BLEND_MODE_DST_ALPHA               = 6,
+   GX2_BLEND_MODE_DST_ALPHA          = 6,
-   GX2_BLEND_MODE_INV_DST_ALPHA           = 7,
+   GX2_BLEND_MODE_INV_DST_ALPHA      = 7,
-   GX2_BLEND_MODE_DST_COLOR               = 8,
+   GX2_BLEND_MODE_DST_COLOR          = 8,
-   GX2_BLEND_MODE_INV_DST_COLOR           = 9,
+   GX2_BLEND_MODE_INV_DST_COLOR      = 9,
-   GX2_BLEND_MODE_SRC_ALPHA_SAT           = 10,
+   GX2_BLEND_MODE_SRC_ALPHA_SAT      = 10,
-   GX2_BLEND_MODE_BOTH_SRC_ALPHA          = 11,
+   GX2_BLEND_MODE_BOTH_SRC_ALPHA     = 11,
-   GX2_BLEND_MODE_BOTH_INV_SRC_ALPHA      = 12,
+   GX2_BLEND_MODE_BOTH_INV_SRC_ALPHA = 12,
-   GX2_BLEND_MODE_BLEND_FACTOR            = 13,
+   GX2_BLEND_MODE_BLEND_FACTOR       = 13,
-   GX2_BLEND_MODE_INV_BLEND_FACTOR        = 14,
+   GX2_BLEND_MODE_INV_BLEND_FACTOR   = 14,
-   GX2_BLEND_MODE_SRC1_COLOR              = 15,
+   GX2_BLEND_MODE_SRC1_COLOR         = 15,
-   GX2_BLEND_MODE_INV_SRC1_COLOR          = 16,
+   GX2_BLEND_MODE_INV_SRC1_COLOR     = 16,
-   GX2_BLEND_MODE_SRC1_ALPHA              = 17,
+   GX2_BLEND_MODE_SRC1_ALPHA         = 17,
-   GX2_BLEND_MODE_INV_SRC1_ALPHA          = 18,
+   GX2_BLEND_MODE_INV_SRC1_ALPHA     = 18,
+   GX2_BLEND_MODE_CONSTANT_ALPHA     = 19,
+   GX2_BLEND_MODE_INV_CONSTANT_ALPHA = 20,
 } GX2BlendMode;
 
 typedef enum GX2BlendCombineMode
 {
-   GX2_BLEND_COMBINE_MODE_ADD             = 0,
+   GX2_BLEND_COMBINE_MODE_ADD     = 0,
-   GX2_BLEND_COMBINE_MODE_SUB             = 1,
+   GX2_BLEND_COMBINE_MODE_SUB     = 1,
-   GX2_BLEND_COMBINE_MODE_MIN             = 2,
+   GX2_BLEND_COMBINE_MODE_MIN     = 2,
-   GX2_BLEND_COMBINE_MODE_MAX             = 3,
+   GX2_BLEND_COMBINE_MODE_MAX     = 3,
-   GX2_BLEND_COMBINE_MODE_REV_SUB         = 4,
+   GX2_BLEND_COMBINE_MODE_REV_SUB = 4,
 } GX2BlendCombineMode;
 
 typedef enum GX2BufferingMode
 {
-   GX2_BUFFERING_MODE_SINGLE              = 1,
+   GX2_BUFFERING_MODE_SINGLE = 1,
-   GX2_BUFFERING_MODE_DOUBLE              = 2,
+   GX2_BUFFERING_MODE_DOUBLE = 2,
-   GX2_BUFFERING_MODE_TRIPLE              = 3,
+   GX2_BUFFERING_MODE_TRIPLE = 3,
 } GX2BufferingMode;
 
 typedef enum GX2ChannelMask
 {
-   GX2_CHANNEL_MASK_R                     = 1,
+   GX2_CHANNEL_MASK_R    = 1,
-   GX2_CHANNEL_MASK_G                     = 2,
+   GX2_CHANNEL_MASK_G    = 2,
-   GX2_CHANNEL_MASK_RG                    = 3,
+   GX2_CHANNEL_MASK_RG   = 3,
-   GX2_CHANNEL_MASK_B                     = 4,
+   GX2_CHANNEL_MASK_B    = 4,
-   GX2_CHANNEL_MASK_RB                    = 5,
+   GX2_CHANNEL_MASK_RB   = 5,
-   GX2_CHANNEL_MASK_GB                    = 6,
+   GX2_CHANNEL_MASK_GB   = 6,
-   GX2_CHANNEL_MASK_RGB                   = 7,
+   GX2_CHANNEL_MASK_RGB  = 7,
-   GX2_CHANNEL_MASK_A                     = 8,
+   GX2_CHANNEL_MASK_A    = 8,
-   GX2_CHANNEL_MASK_RA                    = 9,
+   GX2_CHANNEL_MASK_RA   = 9,
-   GX2_CHANNEL_MASK_GA                    = 10,
+   GX2_CHANNEL_MASK_GA   = 10,
-   GX2_CHANNEL_MASK_RGA                   = 11,
+   GX2_CHANNEL_MASK_RGA  = 11,
-   GX2_CHANNEL_MASK_BA                    = 12,
+   GX2_CHANNEL_MASK_BA   = 12,
-   GX2_CHANNEL_MASK_RBA                   = 13,
+   GX2_CHANNEL_MASK_RBA  = 13,
-   GX2_CHANNEL_MASK_GBA                   = 14,
+   GX2_CHANNEL_MASK_GBA  = 14,
-   GX2_CHANNEL_MASK_RGBA                  = 15,
+   GX2_CHANNEL_MASK_RGBA = 15,
 } GX2ChannelMask;
 
 typedef enum GX2ClearFlags
 {
-   GX2_CLEAR_FLAGS_DEPTH                  = 1,
+   GX2_CLEAR_FLAGS_DEPTH   = 1,
-   GX2_CLEAR_FLAGS_STENCIL                = 2,
+   GX2_CLEAR_FLAGS_STENCIL = 2,
-   GX2_CLEAR_FLAGS_BOTH                   = (GX2_CLEAR_FLAGS_DEPTH | GX2_CLEAR_FLAGS_STENCIL),
+   GX2_CLEAR_FLAGS_BOTH    = (GX2_CLEAR_FLAGS_DEPTH | GX2_CLEAR_FLAGS_STENCIL),
 } GX2ClearFlags;
 
+WUT_ENUM_BITMASK_TYPE(GX2ClearFlags)
+
 typedef enum GX2CompareFunction
 {
-   GX2_COMPARE_FUNC_NEVER                 = 0,
+   GX2_COMPARE_FUNC_NEVER     = 0,
-   GX2_COMPARE_FUNC_LESS                  = 1,
+   GX2_COMPARE_FUNC_LESS      = 1,
-   GX2_COMPARE_FUNC_EQUAL                 = 2,
+   GX2_COMPARE_FUNC_EQUAL     = 2,
-   GX2_COMPARE_FUNC_LEQUAL                = 3,
+   GX2_COMPARE_FUNC_LEQUAL    = 3,
-   GX2_COMPARE_FUNC_GREATER               = 4,
+   GX2_COMPARE_FUNC_GREATER   = 4,
-   GX2_COMPARE_FUNC_NOT_EQUAL             = 5,
+   GX2_COMPARE_FUNC_NOT_EQUAL = 5,
-   GX2_COMPARE_FUNC_GEQUAL                = 6,
+   GX2_COMPARE_FUNC_GEQUAL    = 6,
-   GX2_COMPARE_FUNC_ALWAYS                = 7,
+   GX2_COMPARE_FUNC_ALWAYS    = 7,
 } GX2CompareFunction;
 
 typedef enum GX2DrcRenderMode
 {
-   GX2_DRC_RENDER_MODE_DISABLED           = 0,
+   GX2_DRC_RENDER_MODE_DISABLED = 0,
-   GX2_DRC_RENDER_MODE_SINGLE             = 1,
+   GX2_DRC_RENDER_MODE_SINGLE   = 1,
-   GX2_DRC_RENDER_MODE_DOUBLE             = 2,
+   GX2_DRC_RENDER_MODE_DOUBLE   = 2,
 } GX2DrcRenderMode;
 
 typedef enum GX2EventType
@@ -194,10 +206,10 @@ typedef enum GX2EventType
 
 typedef enum GX2EndianSwapMode
 {
-   GX2_ENDIAN_SWAP_NONE                   = 0,
+   GX2_ENDIAN_SWAP_NONE    = 0,
-   GX2_ENDIAN_SWAP_8_IN_16                = 1,
+   GX2_ENDIAN_SWAP_8_IN_16 = 1,
-   GX2_ENDIAN_SWAP_8_IN_32                = 2,
+   GX2_ENDIAN_SWAP_8_IN_32 = 2,
-   GX2_ENDIAN_SWAP_DEFAULT                = 3,
+   GX2_ENDIAN_SWAP_DEFAULT = 3,
 } GX2EndianSwapMode;
 
 typedef enum GX2FetchShaderType
@@ -210,391 +222,407 @@ typedef enum GX2FetchShaderType
 
 typedef enum GX2FrontFace
 {
-  GX2_FRONT_FACE_CCW                      = 0,
+   GX2_FRONT_FACE_CCW = 0,
-  GX2_FRONT_FACE_CW                       = 1,
+   GX2_FRONT_FACE_CW  = 1,
 } GX2FrontFace;
 
 typedef enum GX2IndexType
 {
-   GX2_INDEX_TYPE_U16_LE                  = 0,
+   GX2_INDEX_TYPE_U16_LE = 0,
-   GX2_INDEX_TYPE_U32_LE                  = 1,
+   GX2_INDEX_TYPE_U32_LE = 1,
-   GX2_INDEX_TYPE_U16                     = 4,
+   GX2_INDEX_TYPE_U16    = 4,
-   GX2_INDEX_TYPE_U32                     = 9,
+   GX2_INDEX_TYPE_U32    = 9,
 } GX2IndexType;
 
 typedef enum GX2InvalidateMode
 {
-   GX2_INVALIDATE_MODE_NONE                = 0,
+   GX2_INVALIDATE_MODE_NONE                 = 0,
-   GX2_INVALIDATE_MODE_ATTRIBUTE_BUFFER    = 1 << 0,
+   GX2_INVALIDATE_MODE_ATTRIBUTE_BUFFER     = 1 << 0,
-   GX2_INVALIDATE_MODE_TEXTURE             = 1 << 1,
+   GX2_INVALIDATE_MODE_TEXTURE              = 1 << 1,
-   GX2_INVALIDATE_MODE_UNIFORM_BLOCK       = 1 << 2,
+   GX2_INVALIDATE_MODE_UNIFORM_BLOCK        = 1 << 2,
-   GX2_INVALIDATE_MODE_SHADER              = 1 << 3,
+   GX2_INVALIDATE_MODE_SHADER               = 1 << 3,
-   GX2_INVALIDATE_MODE_COLOR_BUFFER        = 1 << 4,
+   GX2_INVALIDATE_MODE_COLOR_BUFFER         = 1 << 4,
-   GX2_INVALIDATE_MODE_DEPTH_BUFFER        = 1 << 5,
+   GX2_INVALIDATE_MODE_DEPTH_BUFFER         = 1 << 5,
-   GX2_INVALIDATE_MODE_CPU                 = 1 << 6,
+   GX2_INVALIDATE_MODE_CPU                  = 1 << 6,
-   GX2_INVALIDATE_MODE_STREAM_OUT_BUFFER   = 1 << 7,
+   GX2_INVALIDATE_MODE_STREAM_OUT_BUFFER    = 1 << 7,
-   GX2_INVALIDATE_MODE_EXPORT_BUFFER       = 1 << 8,
+   GX2_INVALIDATE_MODE_EXPORT_BUFFER        = 1 << 8,
-   GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER= GX2_INVALIDATE_MODE_CPU | GX2_INVALIDATE_MODE_ATTRIBUTE_BUFFER,
+   GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER = GX2_INVALIDATE_MODE_CPU | GX2_INVALIDATE_MODE_ATTRIBUTE_BUFFER,
-   GX2_INVALIDATE_MODE_CPU_TEXTURE         = GX2_INVALIDATE_MODE_CPU | GX2_INVALIDATE_MODE_TEXTURE,
+   GX2_INVALIDATE_MODE_CPU_TEXTURE          = GX2_INVALIDATE_MODE_CPU | GX2_INVALIDATE_MODE_TEXTURE,
-   GX2_INVALIDATE_MODE_CPU_SHADER          = GX2_INVALIDATE_MODE_CPU | GX2_INVALIDATE_MODE_SHADER,
+   GX2_INVALIDATE_MODE_CPU_SHADER           = GX2_INVALIDATE_MODE_CPU | GX2_INVALIDATE_MODE_SHADER,
 } GX2InvalidateMode;
 
 WUT_ENUM_BITMASK_TYPE(GX2InvalidateMode)
 
 typedef enum GX2InitAttributes
 {
-   GX2_INIT_END                           = 0,
+   GX2_INIT_END                      = 0,
-   GX2_INIT_CMD_BUF_BASE                  = 1,
+   GX2_INIT_CMD_BUF_BASE             = 1,
-   GX2_INIT_CMD_BUF_POOL_SIZE             = 2,
+   GX2_INIT_CMD_BUF_POOL_SIZE        = 2,
-   GX2_INIT_ARGC                          = 7,
+   GX2_INIT_ARGC                     = 7,
-   GX2_INIT_ARGV                          = 8,
+   GX2_INIT_ARGV                     = 8,
-   GX2_INIT_PROFILE_MODE                  = 9,
+   GX2_INIT_PROFILE_MODE             = 9,
-   GX2_INIT_TOSS_STAGE                    = 10,
+   GX2_INIT_TOSS_STAGE               = 10,
-   GX2_INIT_APP_IO_THREAD_STACK_SIZE      = 11,
+   GX2_INIT_APP_IO_THREAD_STACK_SIZE = 11,
 } GX2InitAttributes;
 
 typedef enum GX2LogicOp
 {
-   GX2_LOGIC_OP_CLEAR                     = 0x00,
+   GX2_LOGIC_OP_CLEAR    = 0x00,
-   GX2_LOGIC_OP_NOR                       = 0x11,
+   GX2_LOGIC_OP_NOR      = 0x11,
-   GX2_LOGIC_OP_INV_AND                   = 0x22,
+   GX2_LOGIC_OP_INV_AND  = 0x22,
-   GX2_LOGIC_OP_INV_COPY                  = 0x33,
+   GX2_LOGIC_OP_INV_COPY = 0x33,
-   GX2_LOGIC_OP_REV_AND                   = 0x44,
+   GX2_LOGIC_OP_REV_AND  = 0x44,
-   GX2_LOGIC_OP_INV                       = 0x55,
+   GX2_LOGIC_OP_INV      = 0x55,
-   GX2_LOGIC_OP_XOR                       = 0x66,
+   GX2_LOGIC_OP_XOR      = 0x66,
-   GX2_LOGIC_OP_NOT_AND                   = 0x77,
+   GX2_LOGIC_OP_NOT_AND  = 0x77,
-   GX2_LOGIC_OP_AND                       = 0x88,
+   GX2_LOGIC_OP_AND      = 0x88,
-   GX2_LOGIC_OP_EQUIV                     = 0x99,
+   GX2_LOGIC_OP_EQUIV    = 0x99,
-   GX2_LOGIC_OP_NOP                       = 0xAA,
+   GX2_LOGIC_OP_NOP      = 0xAA,
-   GX2_LOGIC_OP_INV_OR                    = 0xBB,
+   GX2_LOGIC_OP_INV_OR   = 0xBB,
-   GX2_LOGIC_OP_COPY                      = 0xCC,
+   GX2_LOGIC_OP_COPY     = 0xCC,
-   GX2_LOGIC_OP_REV_OR                    = 0xDD,
+   GX2_LOGIC_OP_REV_OR   = 0xDD,
-   GX2_LOGIC_OP_OR                        = 0xEE,
+   GX2_LOGIC_OP_OR       = 0xEE,
-   GX2_LOGIC_OP_SET                       = 0xFF,
+   GX2_LOGIC_OP_SET      = 0xFF,
 } GX2LogicOp;
 
 typedef enum GX2PrimitiveMode
 {
-   GX2_PRIMITIVE_MODE_POINTS                    = 1,
+   GX2_PRIMITIVE_MODE_POINTS                   = 1,
-   GX2_PRIMITIVE_MODE_LINES                     = 2,
+   GX2_PRIMITIVE_MODE_LINES                    = 2,
-   GX2_PRIMITIVE_MODE_LINE_STRIP                = 3,
+   GX2_PRIMITIVE_MODE_LINE_STRIP               = 3,
-   GX2_PRIMITIVE_MODE_TRIANGLES                 = 4,
+   GX2_PRIMITIVE_MODE_TRIANGLES                = 4,
-   GX2_PRIMITIVE_MODE_TRIANGLE_FAN              = 5,
+   GX2_PRIMITIVE_MODE_TRIANGLE_FAN             = 5,
-   GX2_PRIMITIVE_MODE_TRIANGLE_STRIP            = 6,
+   GX2_PRIMITIVE_MODE_TRIANGLE_STRIP           = 6,
-   GX2_PRIMITIVE_MODE_LINES_ADJACENCY           = 10,
+   GX2_PRIMITIVE_MODE_LINES_ADJACENCY          = 10,
-   GX2_PRIMITIVE_MODE_LINE_STRIP_ADJACENCY      = 11,
+   GX2_PRIMITIVE_MODE_LINE_STRIP_ADJACENCY     = 11,
-   GX2_PRIMITIVE_MODE_TRIANGLES_ADJACENCY       = 12,
+   GX2_PRIMITIVE_MODE_TRIANGLES_ADJACENCY      = 12,
-   GX2_PRIMITIVE_MODE_TRIANGLE_STRIP_ADJACENCY  = 13,
+   GX2_PRIMITIVE_MODE_TRIANGLE_STRIP_ADJACENCY = 13,
-   GX2_PRIMITIVE_MODE_RECTS                     = 17,
+   GX2_PRIMITIVE_MODE_RECTS                    = 17,
-   GX2_PRIMITIVE_MODE_LINE_LOOP                 = 18,
+   GX2_PRIMITIVE_MODE_LINE_LOOP                = 18,
-   GX2_PRIMITIVE_MODE_QUADS                     = 19,
+   GX2_PRIMITIVE_MODE_QUADS                    = 19,
-   GX2_PRIMITIVE_MODE_QUAD_STRIP                = 20,
+   GX2_PRIMITIVE_MODE_QUAD_STRIP               = 20,
 } GX2PrimitiveMode;
 
 typedef enum GX2PolygonMode
 {
-   GX2_POLYGON_MODE_POINT                 = 0,
+   GX2_POLYGON_MODE_POINT    = 0,
-   GX2_POLYGON_MODE_LINE                  = 1,
+   GX2_POLYGON_MODE_LINE     = 1,
-   GX2_POLYGON_MODE_TRIANGLE              = 2,
+   GX2_POLYGON_MODE_TRIANGLE = 2,
 } GX2PolygonMode;
 
 typedef enum GX2RenderTarget
 {
-   GX2_RENDER_TARGET_0                    = 0,
+   GX2_RENDER_TARGET_0 = 0,
-   GX2_RENDER_TARGET_1                    = 1,
+   GX2_RENDER_TARGET_1 = 1,
-   GX2_RENDER_TARGET_2                    = 2,
+   GX2_RENDER_TARGET_2 = 2,
-   GX2_RENDER_TARGET_3                    = 3,
+   GX2_RENDER_TARGET_3 = 3,
-   GX2_RENDER_TARGET_4                    = 4,
+   GX2_RENDER_TARGET_4 = 4,
-   GX2_RENDER_TARGET_5                    = 5,
+   GX2_RENDER_TARGET_5 = 5,
-   GX2_RENDER_TARGET_6                    = 6,
+   GX2_RENDER_TARGET_6 = 6,
-   GX2_RENDER_TARGET_7                    = 7,
+   GX2_RENDER_TARGET_7 = 7,
 } GX2RenderTarget;
 
 typedef enum GX2RoundingMode
 {
-   GX2_ROUNDING_MODE_ROUND_TO_EVEN        = 0,
+   GX2_ROUNDING_MODE_ROUND_TO_EVEN = 0,
-   GX2_ROUNDING_MODE_TRUNCATE             = 1,
+   GX2_ROUNDING_MODE_TRUNCATE      = 1,
 } GX2RoundingMode;
 
 typedef enum GX2SamplerVarType
 {
-   GX2_SAMPLER_VAR_TYPE_SAMPLER_1D        = 0,
+   GX2_SAMPLER_VAR_TYPE_SAMPLER_1D   = 0,
-   GX2_SAMPLER_VAR_TYPE_SAMPLER_2D        = 1,
+   GX2_SAMPLER_VAR_TYPE_SAMPLER_2D   = 1,
-   GX2_SAMPLER_VAR_TYPE_SAMPLER_3D        = 3,
+   GX2_SAMPLER_VAR_TYPE_SAMPLER_3D   = 3,
-   GX2_SAMPLER_VAR_TYPE_SAMPLER_CUBE      = 4,
+   GX2_SAMPLER_VAR_TYPE_SAMPLER_CUBE = 4,
 } GX2SamplerVarType;
 
 typedef enum GX2ScanTarget
 {
-   GX2_SCAN_TARGET_TV0                    = 1 << 0,
+   GX2_SCAN_TARGET_TV0  = 1 << 0,
-   GX2_SCAN_TARGET_TV1                    = 1 << 1,
+   GX2_SCAN_TARGET_TV1  = 1 << 1,
-   GX2_SCAN_TARGET_DRC0                   = 1 << 2,
+   GX2_SCAN_TARGET_DRC0 = 1 << 2,
-   GX2_SCAN_TARGET_DRC1                   = 1 << 3,
+   GX2_SCAN_TARGET_DRC1 = 1 << 3,
-   GX2_SCAN_TARGET_TV                     = GX2_SCAN_TARGET_TV0,
+   GX2_SCAN_TARGET_TV   = GX2_SCAN_TARGET_TV0,
-   GX2_SCAN_TARGET_DRC                    = GX2_SCAN_TARGET_DRC0,
+   GX2_SCAN_TARGET_DRC  = GX2_SCAN_TARGET_DRC0,
 } GX2ScanTarget;
 
+WUT_ENUM_BITMASK_TYPE(GX2ScanTarget)
+
+typedef enum GX2SemaphoreAction
+{
+   GX2_SEMAPHORE_ACTION_WAIT   = 0,
+   GX2_SEMAPHORE_ACTION_SIGNAL = 1,
+} GX2SemaphoreAction;
+
 typedef enum GX2ShaderMode
 {
-   GX2_SHADER_MODE_UNIFORM_REGISTER       = 0,
+   GX2_SHADER_MODE_UNIFORM_REGISTER = 0,
-   GX2_SHADER_MODE_UNIFORM_BLOCK          = 1,
+   GX2_SHADER_MODE_UNIFORM_BLOCK    = 1,
-   GX2_SHADER_MODE_GEOMETRY_SHADER        = 2,
+   GX2_SHADER_MODE_GEOMETRY_SHADER  = 2,
-   GX2_SHADER_MODE_COMPUTE_SHADER         = 3,
+   GX2_SHADER_MODE_COMPUTE_SHADER   = 3,
 } GX2ShaderMode;
 
 typedef enum GX2ShaderVarType
 {
-   GX2_SHADER_VAR_TYPE_VOID               = 0,
+   GX2_SHADER_VAR_TYPE_VOID      = 0,
-   GX2_SHADER_VAR_TYPE_BOOL               = 1,
+   GX2_SHADER_VAR_TYPE_BOOL      = 1,
-   GX2_SHADER_VAR_TYPE_INT                = 2,
+   GX2_SHADER_VAR_TYPE_INT       = 2,
-   GX2_SHADER_VAR_TYPE_UINT               = 3,
+   GX2_SHADER_VAR_TYPE_UINT      = 3,
-   GX2_SHADER_VAR_TYPE_FLOAT              = 4,
+   GX2_SHADER_VAR_TYPE_FLOAT     = 4,
-   GX2_SHADER_VAR_TYPE_DOUBLE             = 5,
+   GX2_SHADER_VAR_TYPE_DOUBLE    = 5,
-   GX2_SHADER_VAR_TYPE_DOUBLE2            = 6,
+   GX2_SHADER_VAR_TYPE_DOUBLE2   = 6,
-   GX2_SHADER_VAR_TYPE_DOUBLE3            = 7,
+   GX2_SHADER_VAR_TYPE_DOUBLE3   = 7,
-   GX2_SHADER_VAR_TYPE_DOUBLE4            = 8,
+   GX2_SHADER_VAR_TYPE_DOUBLE4   = 8,
-   GX2_SHADER_VAR_TYPE_FLOAT2             = 9,
+   GX2_SHADER_VAR_TYPE_FLOAT2    = 9,
-   GX2_SHADER_VAR_TYPE_FLOAT3             = 10,
+   GX2_SHADER_VAR_TYPE_FLOAT3    = 10,
-   GX2_SHADER_VAR_TYPE_FLOAT4             = 11,
+   GX2_SHADER_VAR_TYPE_FLOAT4    = 11,
-   GX2_SHADER_VAR_TYPE_BOOL2              = 12,
+   GX2_SHADER_VAR_TYPE_BOOL2     = 12,
-   GX2_SHADER_VAR_TYPE_BOOL3              = 13,
+   GX2_SHADER_VAR_TYPE_BOOL3     = 13,
-   GX2_SHADER_VAR_TYPE_BOOL4              = 14,
+   GX2_SHADER_VAR_TYPE_BOOL4     = 14,
-   GX2_SHADER_VAR_TYPE_INT2               = 15,
+   GX2_SHADER_VAR_TYPE_INT2      = 15,
-   GX2_SHADER_VAR_TYPE_INT3               = 16,
+   GX2_SHADER_VAR_TYPE_INT3      = 16,
-   GX2_SHADER_VAR_TYPE_INT4               = 17,
+   GX2_SHADER_VAR_TYPE_INT4      = 17,
-   GX2_SHADER_VAR_TYPE_UINT2              = 18,
+   GX2_SHADER_VAR_TYPE_UINT2     = 18,
-   GX2_SHADER_VAR_TYPE_UINT3              = 19,
+   GX2_SHADER_VAR_TYPE_UINT3     = 19,
-   GX2_SHADER_VAR_TYPE_UINT4              = 20,
+   GX2_SHADER_VAR_TYPE_UINT4     = 20,
-   GX2_SHADER_VAR_TYPE_FLOAT2X2           = 21,
+   GX2_SHADER_VAR_TYPE_FLOAT2X2  = 21,
-   GX2_SHADER_VAR_TYPE_FLOAT2X3           = 22,
+   GX2_SHADER_VAR_TYPE_FLOAT2X3  = 22,
-   GX2_SHADER_VAR_TYPE_FLOAT2X4           = 23,
+   GX2_SHADER_VAR_TYPE_FLOAT2X4  = 23,
-   GX2_SHADER_VAR_TYPE_FLOAT3X2           = 24,
+   GX2_SHADER_VAR_TYPE_FLOAT3X2  = 24,
-   GX2_SHADER_VAR_TYPE_FLOAT3X3           = 25,
+   GX2_SHADER_VAR_TYPE_FLOAT3X3  = 25,
-   GX2_SHADER_VAR_TYPE_FLOAT3X4           = 26,
+   GX2_SHADER_VAR_TYPE_FLOAT3X4  = 26,
-   GX2_SHADER_VAR_TYPE_FLOAT4X2           = 27,
+   GX2_SHADER_VAR_TYPE_FLOAT4X2  = 27,
-   GX2_SHADER_VAR_TYPE_FLOAT4X3           = 28,
+   GX2_SHADER_VAR_TYPE_FLOAT4X3  = 28,
-   GX2_SHADER_VAR_TYPE_FLOAT4X4           = 29,
+   GX2_SHADER_VAR_TYPE_FLOAT4X4  = 29,
-   GX2_SHADER_VAR_TYPE_DOUBLE2X2          = 30,
+   GX2_SHADER_VAR_TYPE_DOUBLE2X2 = 30,
-   GX2_SHADER_VAR_TYPE_DOUBLE2X3          = 31,
+   GX2_SHADER_VAR_TYPE_DOUBLE2X3 = 31,
-   GX2_SHADER_VAR_TYPE_DOUBLE2X4          = 32,
+   GX2_SHADER_VAR_TYPE_DOUBLE2X4 = 32,
-   GX2_SHADER_VAR_TYPE_DOUBLE3X2          = 33,
+   GX2_SHADER_VAR_TYPE_DOUBLE3X2 = 33,
-   GX2_SHADER_VAR_TYPE_DOUBLE3X3          = 34,
+   GX2_SHADER_VAR_TYPE_DOUBLE3X3 = 34,
-   GX2_SHADER_VAR_TYPE_DOUBLE3X4          = 35,
+   GX2_SHADER_VAR_TYPE_DOUBLE3X4 = 35,
-   GX2_SHADER_VAR_TYPE_DOUBLE4X2          = 36,
+   GX2_SHADER_VAR_TYPE_DOUBLE4X2 = 36,
-   GX2_SHADER_VAR_TYPE_DOUBLE4X3          = 37,
+   GX2_SHADER_VAR_TYPE_DOUBLE4X3 = 37,
-   GX2_SHADER_VAR_TYPE_DOUBLE4X4          = 38,
+   GX2_SHADER_VAR_TYPE_DOUBLE4X4 = 38,
 } GX2ShaderVarType;
 
 typedef enum GX2StencilFunction
 {
-   GX2_STENCIL_FUNCTION_KEEP              = 0,
+   GX2_STENCIL_FUNCTION_KEEP       = 0,
-   GX2_STENCIL_FUNCTION_ZERO              = 1,
+   GX2_STENCIL_FUNCTION_ZERO       = 1,
-   GX2_STENCIL_FUNCTION_REPLACE           = 2,
+   GX2_STENCIL_FUNCTION_REPLACE    = 2,
-   GX2_STENCIL_FUNCTION_INCR_CLAMP        = 3,
+   GX2_STENCIL_FUNCTION_INCR_CLAMP = 3,
-   GX2_STENCIL_FUNCTION_DECR_CLAMP        = 4,
+   GX2_STENCIL_FUNCTION_DECR_CLAMP = 4,
-   GX2_STENCIL_FUNCTION_INV               = 5,
+   GX2_STENCIL_FUNCTION_INV        = 5,
-   GX2_STENCIL_FUNCTION_INCR_WRAP         = 6,
+   GX2_STENCIL_FUNCTION_INCR_WRAP  = 6,
-   GX2_STENCIL_FUNCTION_DECR_WRAP         = 7,
+   GX2_STENCIL_FUNCTION_DECR_WRAP  = 7,
 } GX2StencilFunction;
 
 typedef enum GX2SurfaceDim
 {
-   GX2_SURFACE_DIM_TEXTURE_1D             = 0,
+   GX2_SURFACE_DIM_TEXTURE_1D            = 0,
-   GX2_SURFACE_DIM_TEXTURE_2D             = 1,
+   GX2_SURFACE_DIM_TEXTURE_2D            = 1,
-   GX2_SURFACE_DIM_TEXTURE_3D             = 2,
+   GX2_SURFACE_DIM_TEXTURE_3D            = 2,
-   GX2_SURFACE_DIM_TEXTURE_CUBE           = 3,
+   GX2_SURFACE_DIM_TEXTURE_CUBE          = 3,
-   GX2_SURFACE_DIM_TEXTURE_1D_ARRAY       = 4,
+   GX2_SURFACE_DIM_TEXTURE_1D_ARRAY      = 4,
-   GX2_SURFACE_DIM_TEXTURE_2D_ARRAY       = 5,
+   GX2_SURFACE_DIM_TEXTURE_2D_ARRAY      = 5,
-   GX2_SURFACE_DIM_TEXTURE_2D_MSAA        = 6,
+   GX2_SURFACE_DIM_TEXTURE_2D_MSAA       = 6,
-   GX2_SURFACE_DIM_TEXTURE_2D_MSAA_ARRAY  = 7,
+   GX2_SURFACE_DIM_TEXTURE_2D_MSAA_ARRAY = 7,
 } GX2SurfaceDim;
 
 typedef enum GX2SurfaceFormat
 {
-   GX2_SURFACE_FORMAT_INVALID                   = 0x00,
+   GX2_SURFACE_FORMAT_INVALID               = 0x00,
-   GX2_SURFACE_FORMAT_UNORM_R4_G4               = 0x02,
+   GX2_SURFACE_FORMAT_UNORM_R4_G4           = 0x02,
-   GX2_SURFACE_FORMAT_UNORM_R4_G4_B4_A4         = 0x0b,
+   GX2_SURFACE_FORMAT_UNORM_R4_G4_B4_A4     = 0x0b,
-   GX2_SURFACE_FORMAT_UNORM_R8                  = 0x01,
+   GX2_SURFACE_FORMAT_UNORM_R8              = 0x01,
-   GX2_SURFACE_FORMAT_UNORM_R8_G8               = 0x07,
+   GX2_SURFACE_FORMAT_UNORM_R8_G8           = 0x07,
-   GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8         = 0x01a,
+   GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8     = 0x01a,
-   GX2_SURFACE_FORMAT_UNORM_R16                 = 0x05,
+   GX2_SURFACE_FORMAT_UNORM_R16             = 0x05,
-   GX2_SURFACE_FORMAT_UNORM_R16_G16             = 0x0f,
+   GX2_SURFACE_FORMAT_UNORM_R16_G16         = 0x0f,
-   GX2_SURFACE_FORMAT_UNORM_R16_G16_B16_A16     = 0x01f,
+   GX2_SURFACE_FORMAT_UNORM_R16_G16_B16_A16 = 0x01f,
-   GX2_SURFACE_FORMAT_UNORM_R5_G6_B5            = 0x08,
+   GX2_SURFACE_FORMAT_UNORM_R5_G6_B5        = 0x08,
-   GX2_SURFACE_FORMAT_UNORM_R5_G5_B5_A1         = 0x0a,
+   GX2_SURFACE_FORMAT_UNORM_R5_G5_B5_A1     = 0x0a,
-   GX2_SURFACE_FORMAT_UNORM_A1_B5_G5_R5         = 0x0c,
+   GX2_SURFACE_FORMAT_UNORM_A1_B5_G5_R5     = 0x0c,
-   GX2_SURFACE_FORMAT_UNORM_R24_X8              = 0x011,
+   GX2_SURFACE_FORMAT_UNORM_R24_X8          = 0x011,
-   GX2_SURFACE_FORMAT_UNORM_A2_B10_G10_R10      = 0x01b,
+   GX2_SURFACE_FORMAT_UNORM_A2_B10_G10_R10  = 0x01b,
-   GX2_SURFACE_FORMAT_UNORM_R10_G10_B10_A2      = 0x019,
+   GX2_SURFACE_FORMAT_UNORM_R10_G10_B10_A2  = 0x019,
-   GX2_SURFACE_FORMAT_UNORM_BC1                 = 0x031,
+   GX2_SURFACE_FORMAT_UNORM_BC1             = 0x031,
-   GX2_SURFACE_FORMAT_UNORM_BC2                 = 0x032,
+   GX2_SURFACE_FORMAT_UNORM_BC2             = 0x032,
-   GX2_SURFACE_FORMAT_UNORM_BC3                 = 0x033,
+   GX2_SURFACE_FORMAT_UNORM_BC3             = 0x033,
-   GX2_SURFACE_FORMAT_UNORM_BC4                 = 0x034,
+   GX2_SURFACE_FORMAT_UNORM_BC4             = 0x034,
-   GX2_SURFACE_FORMAT_UNORM_BC5                 = 0x035,
+   GX2_SURFACE_FORMAT_UNORM_BC5             = 0x035,
-   GX2_SURFACE_FORMAT_UNORM_NV12                = 0x081,
+   GX2_SURFACE_FORMAT_UNORM_NV12            = 0x081,
 
-   GX2_SURFACE_FORMAT_UINT_R8                   = 0x101,
+   GX2_SURFACE_FORMAT_UINT_R8               = 0x101,
-   GX2_SURFACE_FORMAT_UINT_R8_G8                = 0x107,
+   GX2_SURFACE_FORMAT_UINT_R8_G8            = 0x107,
-   GX2_SURFACE_FORMAT_UINT_R8_G8_B8_A8          = 0x11a,
+   GX2_SURFACE_FORMAT_UINT_R8_G8_B8_A8      = 0x11a,
-   GX2_SURFACE_FORMAT_UINT_R16                  = 0x105,
+   GX2_SURFACE_FORMAT_UINT_R16              = 0x105,
-   GX2_SURFACE_FORMAT_UINT_R16_G16              = 0x10f,
+   GX2_SURFACE_FORMAT_UINT_R16_G16          = 0x10f,
-   GX2_SURFACE_FORMAT_UINT_R16_G16_B16_A16      = 0x11f,
+   GX2_SURFACE_FORMAT_UINT_R16_G16_B16_A16  = 0x11f,
-   GX2_SURFACE_FORMAT_UINT_R32                  = 0x10d,
+   GX2_SURFACE_FORMAT_UINT_R32              = 0x10d,
-   GX2_SURFACE_FORMAT_UINT_R32_G32              = 0x11d,
+   GX2_SURFACE_FORMAT_UINT_R32_G32          = 0x11d,
-   GX2_SURFACE_FORMAT_UINT_R32_G32_B32_A32      = 0x122,
+   GX2_SURFACE_FORMAT_UINT_R32_G32_B32_A32  = 0x122,
-   GX2_SURFACE_FORMAT_UINT_A2_B10_G10_R10       = 0x11b,
+   GX2_SURFACE_FORMAT_UINT_A2_B10_G10_R10   = 0x11b,
-   GX2_SURFACE_FORMAT_UINT_R10_G10_B10_A2       = 0x119,
+   GX2_SURFACE_FORMAT_UINT_R10_G10_B10_A2   = 0x119,
-   GX2_SURFACE_FORMAT_UINT_X24_G8               = 0x111,
+   GX2_SURFACE_FORMAT_UINT_X24_G8           = 0x111,
-   GX2_SURFACE_FORMAT_UINT_G8_X24               = 0x11c,
+   GX2_SURFACE_FORMAT_UINT_G8_X24           = 0x11c,
 
-   GX2_SURFACE_FORMAT_SNORM_R8                  = 0x201,
+   GX2_SURFACE_FORMAT_SNORM_R8              = 0x201,
-   GX2_SURFACE_FORMAT_SNORM_R8_G8               = 0x207,
+   GX2_SURFACE_FORMAT_SNORM_R8_G8           = 0x207,
-   GX2_SURFACE_FORMAT_SNORM_R8_G8_B8_A8         = 0x21a,
+   GX2_SURFACE_FORMAT_SNORM_R8_G8_B8_A8     = 0x21a,
-   GX2_SURFACE_FORMAT_SNORM_R16                 = 0x205,
+   GX2_SURFACE_FORMAT_SNORM_R16             = 0x205,
-   GX2_SURFACE_FORMAT_SNORM_R16_G16             = 0x20f,
+   GX2_SURFACE_FORMAT_SNORM_R16_G16         = 0x20f,
-   GX2_SURFACE_FORMAT_SNORM_R16_G16_B16_A16     = 0x21f,
+   GX2_SURFACE_FORMAT_SNORM_R16_G16_B16_A16 = 0x21f,
-   GX2_SURFACE_FORMAT_SNORM_R10_G10_B10_A2      = 0x219,
+   GX2_SURFACE_FORMAT_SNORM_R10_G10_B10_A2  = 0x219,
-   GX2_SURFACE_FORMAT_SNORM_BC4                 = 0x234,
+   GX2_SURFACE_FORMAT_SNORM_BC4             = 0x234,
-   GX2_SURFACE_FORMAT_SNORM_BC5                 = 0x235,
+   GX2_SURFACE_FORMAT_SNORM_BC5             = 0x235,
 
-   GX2_SURFACE_FORMAT_SINT_R8                   = 0x301,
+   GX2_SURFACE_FORMAT_SINT_R8               = 0x301,
-   GX2_SURFACE_FORMAT_SINT_R8_G8                = 0x307,
+   GX2_SURFACE_FORMAT_SINT_R8_G8            = 0x307,
-   GX2_SURFACE_FORMAT_SINT_R8_G8_B8_A8          = 0x31a,
+   GX2_SURFACE_FORMAT_SINT_R8_G8_B8_A8      = 0x31a,
-   GX2_SURFACE_FORMAT_SINT_R16                  = 0x305,
+   GX2_SURFACE_FORMAT_SINT_R16              = 0x305,
-   GX2_SURFACE_FORMAT_SINT_R16_G16              = 0x30f,
+   GX2_SURFACE_FORMAT_SINT_R16_G16          = 0x30f,
-   GX2_SURFACE_FORMAT_SINT_R16_G16_B16_A16      = 0x31f,
+   GX2_SURFACE_FORMAT_SINT_R16_G16_B16_A16  = 0x31f,
-   GX2_SURFACE_FORMAT_SINT_R32                  = 0x30d,
+   GX2_SURFACE_FORMAT_SINT_R32              = 0x30d,
-   GX2_SURFACE_FORMAT_SINT_R32_G32              = 0x31d,
+   GX2_SURFACE_FORMAT_SINT_R32_G32          = 0x31d,
-   GX2_SURFACE_FORMAT_SINT_R32_G32_B32_A32      = 0x322,
+   GX2_SURFACE_FORMAT_SINT_R32_G32_B32_A32  = 0x322,
-   GX2_SURFACE_FORMAT_SINT_R10_G10_B10_A2       = 0x319,
+   GX2_SURFACE_FORMAT_SINT_R10_G10_B10_A2   = 0x319,
 
-   GX2_SURFACE_FORMAT_SRGB_R8_G8_B8_A8          = 0x41a,
+   GX2_SURFACE_FORMAT_SRGB_R8_G8_B8_A8      = 0x41a,
-   GX2_SURFACE_FORMAT_SRGB_BC1                  = 0x431,
+   GX2_SURFACE_FORMAT_SRGB_BC1              = 0x431,
-   GX2_SURFACE_FORMAT_SRGB_BC2                  = 0x432,
+   GX2_SURFACE_FORMAT_SRGB_BC2              = 0x432,
-   GX2_SURFACE_FORMAT_SRGB_BC3                  = 0x433,
+   GX2_SURFACE_FORMAT_SRGB_BC3              = 0x433,
 
-   GX2_SURFACE_FORMAT_FLOAT_R32                 = 0x80e,
+   GX2_SURFACE_FORMAT_FLOAT_R32             = 0x80e,
-   GX2_SURFACE_FORMAT_FLOAT_R32_G32             = 0x81e,
+   GX2_SURFACE_FORMAT_FLOAT_R32_G32         = 0x81e,
-   GX2_SURFACE_FORMAT_FLOAT_R32_G32_B32_A32     = 0x823,
+   GX2_SURFACE_FORMAT_FLOAT_R32_G32_B32_A32 = 0x823,
-   GX2_SURFACE_FORMAT_FLOAT_R16                 = 0x806,
+   GX2_SURFACE_FORMAT_FLOAT_R16             = 0x806,
-   GX2_SURFACE_FORMAT_FLOAT_R16_G16             = 0x810,
+   GX2_SURFACE_FORMAT_FLOAT_R16_G16         = 0x810,
-   GX2_SURFACE_FORMAT_FLOAT_R16_G16_B16_A16     = 0x820,
+   GX2_SURFACE_FORMAT_FLOAT_R16_G16_B16_A16 = 0x820,
-   GX2_SURFACE_FORMAT_FLOAT_R11_G11_B10         = 0x816,
+   GX2_SURFACE_FORMAT_FLOAT_R11_G11_B10     = 0x816,
-   GX2_SURFACE_FORMAT_FLOAT_D24_S8              = 0x811,
+   GX2_SURFACE_FORMAT_FLOAT_D24_S8          = 0x811,
-   GX2_SURFACE_FORMAT_FLOAT_X8_X24              = 0x81c,
+   GX2_SURFACE_FORMAT_FLOAT_X8_X24          = 0x81c,
 } GX2SurfaceFormat;
 
 typedef enum GX2SurfaceUse
 {
-   GX2_SURFACE_USE_NONE                         = 0,
+   GX2_SURFACE_USE_NONE                    = 0,
-   GX2_SURFACE_USE_TEXTURE                      = 1 << 0,
+   GX2_SURFACE_USE_TEXTURE                 = 1 << 0,
-   GX2_SURFACE_USE_COLOR_BUFFER                 = 1 << 1,
+   GX2_SURFACE_USE_COLOR_BUFFER            = 1 << 1,
-   GX2_SURFACE_USE_DEPTH_BUFFER                 = 1 << 2,
+   GX2_SURFACE_USE_DEPTH_BUFFER            = 1 << 2,
-   GX2_SURFACE_USE_SCAN_BUFFER                  = 1 << 3,
+   GX2_SURFACE_USE_SCAN_BUFFER             = 1 << 3,
-   GX2_SURFACE_USE_TV                           = 1 << 31,
+   GX2_SURFACE_USE_TV                      = 1 << 31,
-   GX2_SURFACE_USE_TEXTURE_COLOR_BUFFER_TV      = (GX2_SURFACE_USE_TEXTURE | GX2_SURFACE_USE_COLOR_BUFFER | GX2_SURFACE_USE_TV)
+   GX2_SURFACE_USE_TEXTURE_COLOR_BUFFER_TV = (GX2_SURFACE_USE_TEXTURE | GX2_SURFACE_USE_COLOR_BUFFER | GX2_SURFACE_USE_TV)
 } GX2SurfaceUse;
 
 WUT_ENUM_BITMASK_TYPE(GX2SurfaceUse)
 
 typedef enum GX2TessellationMode
 {
-   GX2_TESSELLATION_MODE_DISCRETE         = 0,
+   GX2_TESSELLATION_MODE_DISCRETE   = 0,
-   GX2_TESSELLATION_MODE_CONTINUOUS       = 1,
+   GX2_TESSELLATION_MODE_CONTINUOUS = 1,
-   GX2_TESSELLATION_MODE_ADAPTIVE         = 2,
+   GX2_TESSELLATION_MODE_ADAPTIVE   = 2,
 } GX2TessellationMode;
 
 typedef enum GX2TexBorderType
 {
-   GX2_TEX_BORDER_TYPE_TRANSPARENT_BLACK  = 0,
+   GX2_TEX_BORDER_TYPE_TRANSPARENT_BLACK = 0,
-   GX2_TEX_BORDER_TYPE_BLACK              = 1,
+   GX2_TEX_BORDER_TYPE_BLACK             = 1,
-   GX2_TEX_BORDER_TYPE_WHITE              = 2,
+   GX2_TEX_BORDER_TYPE_WHITE             = 2,
-   GX2_TEX_BORDER_TYPE_VARIABLE           = 3,
+   GX2_TEX_BORDER_TYPE_VARIABLE          = 3,
 } GX2TexBorderType;
 
 typedef enum GX2TexClampMode
 {
-   GX2_TEX_CLAMP_MODE_WRAP                = 0,
+   GX2_TEX_CLAMP_MODE_WRAP                    = 0,
-   GX2_TEX_CLAMP_MODE_MIRROR              = 1,
+   GX2_TEX_CLAMP_MODE_MIRROR                  = 1,
-   GX2_TEX_CLAMP_MODE_CLAMP               = 2,
+   GX2_TEX_CLAMP_MODE_CLAMP                   = 2,
-   GX2_TEX_CLAMP_MODE_MIRROR_ONCE         = 3,
+   GX2_TEX_CLAMP_MODE_MIRROR_ONCE             = 3,
-   GX2_TEX_CLAMP_MODE_CLAMP_BORDER        = 6,
+   GX2_TEX_CLAMP_MODE_CLAMP_HALF_BORDER       = 4,
+   GX2_TEX_CLAMP_MODE_MIRROR_ONCE_HALF_BORDER = 5,
+   GX2_TEX_CLAMP_MODE_CLAMP_BORDER            = 6,
+   GX2_TEX_CLAMP_MODE_MIRROR_ONCE_BORDER      = 7,
 } GX2TexClampMode;
 
 typedef enum GX2TexMipFilterMode
 {
-   GX2_TEX_MIP_FILTER_MODE_NONE           = 0,
+   GX2_TEX_MIP_FILTER_MODE_NONE   = 0,
-   GX2_TEX_MIP_FILTER_MODE_POINT          = 1,
+   GX2_TEX_MIP_FILTER_MODE_POINT  = 1,
-   GX2_TEX_MIP_FILTER_MODE_LINEAR         = 2,
+   GX2_TEX_MIP_FILTER_MODE_LINEAR = 2,
 } GX2TexMipFilterMode;
 
 typedef enum GX2TexMipPerfMode
 {
-   GX2_TEX_MIP_PERF_MODE_DISABLE          = 0,
+   GX2_TEX_MIP_PERF_MODE_DISABLE = 0,
 } GX2TexMipPerfMode;
 
 typedef enum GX2TexXYFilterMode
 {
-   GX2_TEX_XY_FILTER_MODE_POINT          = 0,
+   GX2_TEX_XY_FILTER_MODE_POINT   = 0,
-   GX2_TEX_XY_FILTER_MODE_LINEAR         = 1,
+   GX2_TEX_XY_FILTER_MODE_LINEAR  = 1,
+   GX2_TEX_XY_FILTER_MODE_BICUBIC = 2,
 } GX2TexXYFilterMode;
 
 typedef enum GX2TexAnisoRatio
 {
-   GX2_TEX_ANISO_RATIO_NONE               = 0,
+   GX2_TEX_ANISO_RATIO_NONE    = 0,
+   GX2_TEX_ANISO_RATIO_2_TO_1  = 1,
+   GX2_TEX_ANISO_RATIO_4_TO_1  = 2,
+   GX2_TEX_ANISO_RATIO_8_TO_1  = 3,
+   GX2_TEX_ANISO_RATIO_16_TO_1 = 4,
 } GX2TexAnisoRatio;
 
 typedef enum GX2TexZFilterMode
 {
-   GX2_TEX_Z_FILTER_MODE_NONE             = 0,
+   GX2_TEX_Z_FILTER_MODE_NONE   = 0,
-   GX2_TEX_Z_FILTER_MODE_POINT            = 1,
+   GX2_TEX_Z_FILTER_MODE_POINT  = 1,
-   GX2_TEX_Z_FILTER_MODE_LINEAR           = 2,
+   GX2_TEX_Z_FILTER_MODE_LINEAR = 2,
 } GX2TexZFilterMode;
 
 typedef enum GX2TexZPerfMode
 {
-   GX2_TEX_Z_PERF_MODE_DISABLED           = 0,
+   GX2_TEX_Z_PERF_MODE_DISABLED = 0,
 } GX2TexZPerfMode;
 
 typedef enum GX2TileMode
 {
-   GX2_TILE_MODE_DEFAULT                  = 0,
+   GX2_TILE_MODE_DEFAULT        = 0,
-   GX2_TILE_MODE_LINEAR_ALIGNED           = 1,
+   GX2_TILE_MODE_LINEAR_ALIGNED = 1,
-   GX2_TILE_MODE_TILED_1D_THIN1           = 2,
+   GX2_TILE_MODE_TILED_1D_THIN1 = 2,
-   GX2_TILE_MODE_TILED_1D_THICK           = 3,
+   GX2_TILE_MODE_TILED_1D_THICK = 3,
-   GX2_TILE_MODE_TILED_2D_THIN1           = 4,
+   GX2_TILE_MODE_TILED_2D_THIN1 = 4,
-   GX2_TILE_MODE_TILED_2D_THIN2           = 5,
+   GX2_TILE_MODE_TILED_2D_THIN2 = 5,
-   GX2_TILE_MODE_TILED_2D_THIN4           = 6,
+   GX2_TILE_MODE_TILED_2D_THIN4 = 6,
-   GX2_TILE_MODE_TILED_2D_THICK           = 7,
+   GX2_TILE_MODE_TILED_2D_THICK = 7,
-   GX2_TILE_MODE_TILED_2B_THIN1           = 8,
+   GX2_TILE_MODE_TILED_2B_THIN1 = 8,
-   GX2_TILE_MODE_TILED_2B_THIN2           = 9,
+   GX2_TILE_MODE_TILED_2B_THIN2 = 9,
-   GX2_TILE_MODE_TILED_2B_THIN4           = 10,
+   GX2_TILE_MODE_TILED_2B_THIN4 = 10,
-   GX2_TILE_MODE_TILED_2B_THICK           = 11,
+   GX2_TILE_MODE_TILED_2B_THICK = 11,
-   GX2_TILE_MODE_TILED_3D_THIN1           = 12,
+   GX2_TILE_MODE_TILED_3D_THIN1 = 12,
-   GX2_TILE_MODE_TILED_3D_THICK           = 13,
+   GX2_TILE_MODE_TILED_3D_THICK = 13,
-   GX2_TILE_MODE_TILED_3B_THIN1           = 14,
+   GX2_TILE_MODE_TILED_3B_THIN1 = 14,
-   GX2_TILE_MODE_TILED_3B_THICK           = 15,
+   GX2_TILE_MODE_TILED_3B_THICK = 15,
-   GX2_TILE_MODE_LINEAR_SPECIAL           = 16,
+   GX2_TILE_MODE_LINEAR_SPECIAL = 16,
 } GX2TileMode;
 
 typedef enum GX2TVRenderMode
 {
-   GX2_TV_RENDER_MODE_DISABLED            = 0,
+   GX2_TV_RENDER_MODE_DISABLED      = 0,
-   GX2_TV_RENDER_MODE_STANDARD_480P       = 1,
+   GX2_TV_RENDER_MODE_STANDARD_480P = 1,
-   GX2_TV_RENDER_MODE_WIDE_480P           = 2,
+   GX2_TV_RENDER_MODE_WIDE_480P     = 2,
-   GX2_TV_RENDER_MODE_WIDE_720P           = 3,
+   GX2_TV_RENDER_MODE_WIDE_720P     = 3,
-   GX2_TV_RENDER_MODE_WIDE_1080P          = 5,
+   GX2_TV_RENDER_MODE_WIDE_1080P    = 5,
 } GX2TVRenderMode;
 
 typedef enum GX2TVScanMode
 {
-   GX2_TV_SCAN_MODE_NONE                  = 0,
+   GX2_TV_SCAN_MODE_NONE  = 0,
-   GX2_TV_SCAN_MODE_576I                  = 1,
+   GX2_TV_SCAN_MODE_576I  = 1,
-   GX2_TV_SCAN_MODE_480I                  = 2,
+   GX2_TV_SCAN_MODE_480I  = 2,
-   GX2_TV_SCAN_MODE_480P                  = 3,
+   GX2_TV_SCAN_MODE_480P  = 3,
-   GX2_TV_SCAN_MODE_720P                  = 4,
+   GX2_TV_SCAN_MODE_720P  = 4,
-   GX2_TV_SCAN_MODE_1080I                 = 6,
+   GX2_TV_SCAN_MODE_1080I = 6,
-   GX2_TV_SCAN_MODE_1080P                 = 7,
+   GX2_TV_SCAN_MODE_1080P = 7,
 } GX2TVScanMode;
 
 #ifdef __cplusplus

include/gx2/semaphore.h

@@ -0,0 +1,34 @@
+#pragma once
+#include <wut.h>
+#include "enum.h"
+
+/**
+ * \defgroup gx2_semaphore Semaphore
+ * \ingroup gx2
+ * @{
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef uint64_t GX2Semaphore;
+
+/**
+ * Inserts a semaphore into the command stream.
+ *
+ * \param semaphore
+ * Address of the semaphore. Must be aligned by \c 0x8.
+ * 
+ * \param action
+ * Semaphore operation to perform.
+ */
+void
+GX2SetSemaphore(GX2Semaphore *semaphore,
+                GX2SemaphoreAction action);
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */

include/gx2/shaders.h

@@ -1,9 +1,9 @@
 #pragma once
-#include <string.h>
 #include <wut.h>
+#include <string.h>
 #include "enum.h"
-#include "sampler.h"
 #include "gx2r/buffer.h"
+#include "sampler.h"
 
 /**
  * \defgroup gx2_shader Shaders
@@ -427,9 +427,12 @@ GX2SetGeometryUniformBlock(uint32_t location,
 
 void
 GX2SetShaderModeEx(GX2ShaderMode mode,
-                   uint32_t numVsGpr, uint32_t numVsStackEntries,
+                   uint32_t numVsGpr,
-                   uint32_t numGsGpr, uint32_t numGsStackEntries,
+                   uint32_t numVsStackEntries,
-                   uint32_t numPsGpr, uint32_t numPsStackEntries);
+                   uint32_t numGsGpr,
+                   uint32_t numGsStackEntries,
+                   uint32_t numPsGpr,
+                   uint32_t numPsStackEntries);
 
 void
 GX2SetStreamOutEnable(BOOL enable);

include/gx2/state.h

@@ -1,4 +1,5 @@
 #pragma once
+
 #include <wut.h>
 #include "enum.h"
 
@@ -24,6 +25,12 @@ GX2Flush();
 void
 GX2ResetGPU(uint32_t unknown);
 
+/**
+ * @return -1 if GX2 is not running, on success the core where GX2Init has been called is returned.
+ */
+int
+GX2GetMainCoreId();
+
 #ifdef __cplusplus
 }
 #endif

include/gx2/surface.h

@@ -1,6 +1,6 @@
 #pragma once
-#include <gx2r/resource.h>
 #include <wut.h>
+#include <gx2r/resource.h>
 #include "enum.h"
 
 /**
@@ -28,7 +28,8 @@ struct GX2Surface
    uint32_t mipLevels;
    GX2SurfaceFormat format;
    GX2AAMode aa;
-   union {
+   union
+   {
       GX2SurfaceUse use;
       GX2RResourceFlags resourceFlags;
    };
@@ -185,8 +186,8 @@ GX2CopySurfaceEx(const GX2Surface *src,
                  GX2Point *dstPoints);
 
 void
-GX2ResolveAAColorBuffer(const GX2ColorBuffer * srcColorBuffer,
+GX2ResolveAAColorBuffer(const GX2ColorBuffer *srcColorBuffer,
-                        GX2Surface * dstSurface,
+                        GX2Surface *dstSurface,
                         uint32_t dstMip,
                         uint32_t dstSlice);
 

include/gx2/utils.h

@@ -13,19 +13,19 @@ extern "C" {
 
 typedef enum GX2_SQ_SEL
 {
-   GX2_SQ_SEL_X       = 0,
+   GX2_SQ_SEL_X    = 0,
-   GX2_SQ_SEL_Y       = 1,
+   GX2_SQ_SEL_Y    = 1,
-   GX2_SQ_SEL_Z       = 2,
+   GX2_SQ_SEL_Z    = 2,
-   GX2_SQ_SEL_W       = 3,
+   GX2_SQ_SEL_W    = 3,
 
-   GX2_SQ_SEL_R       = 0,
+   GX2_SQ_SEL_R    = 0,
-   GX2_SQ_SEL_G       = 1,
+   GX2_SQ_SEL_G    = 1,
-   GX2_SQ_SEL_B       = 2,
+   GX2_SQ_SEL_B    = 2,
-   GX2_SQ_SEL_A       = 3,
+   GX2_SQ_SEL_A    = 3,
 
-   GX2_SQ_SEL_0       = 4,
+   GX2_SQ_SEL_0    = 4,
-   GX2_SQ_SEL_1       = 5,
+   GX2_SQ_SEL_1    = 5,
-   GX2_SQ_SEL_MASK    = 7,
+   GX2_SQ_SEL_MASK = 7,
 } GX2_SQ_SEL;
 
 #define GX2_SEL_MASK(x, y, z, w) (((x) << 24) | ((y) << 16) | ((z) << 8) | (w))

include/gx2r/mem.h

@@ -12,7 +12,7 @@
 extern "C" {
 #endif
 
-typedef void * (*GX2RAllocFunction)(GX2RResourceFlags, uint32_t, uint32_t);
+typedef void *(*GX2RAllocFunction)(GX2RResourceFlags, uint32_t, uint32_t);
 typedef void (*GX2RFreeFunction)(GX2RResourceFlags, void *);
 
 void

include/gx2r/resource.h

@@ -14,79 +14,79 @@ extern "C" {
 typedef enum GX2RResourceFlags
 {
    //! No resource flags specified
-   GX2R_RESOURCE_BIND_NONE                = 0,
+   GX2R_RESOURCE_BIND_NONE              = 0,
 
    //! This resource is to be used as a texture
-   GX2R_RESOURCE_BIND_TEXTURE             = 1 << 0,
+   GX2R_RESOURCE_BIND_TEXTURE           = 1 << 0,
 
    //! This resource is to be used as a colour buffer
-   GX2R_RESOURCE_BIND_COLOR_BUFFER        = 1 << 1,
+   GX2R_RESOURCE_BIND_COLOR_BUFFER      = 1 << 1,
 
    //! This resource is to be used as a depth buffer
-   GX2R_RESOURCE_BIND_DEPTH_BUFFER        = 1 << 2,
+   GX2R_RESOURCE_BIND_DEPTH_BUFFER      = 1 << 2,
 
    //! This resource is to be used as a scan buffer
-   GX2R_RESOURCE_BIND_SCAN_BUFFER         = 1 << 3,
+   GX2R_RESOURCE_BIND_SCAN_BUFFER       = 1 << 3,
 
    //! This resource is to be used as a vertex buffer
-   GX2R_RESOURCE_BIND_VERTEX_BUFFER       = 1 << 4,
+   GX2R_RESOURCE_BIND_VERTEX_BUFFER     = 1 << 4,
 
    //! This resource is to be used as a index buffer
-   GX2R_RESOURCE_BIND_INDEX_BUFFER        = 1 << 5,
+   GX2R_RESOURCE_BIND_INDEX_BUFFER      = 1 << 5,
 
    //! This resource is to be used as a uniform block
-   GX2R_RESOURCE_BIND_UNIFORM_BLOCK       = 1 << 6,
+   GX2R_RESOURCE_BIND_UNIFORM_BLOCK     = 1 << 6,
 
    //! This resource is to be used as a shader program
-   GX2R_RESOURCE_BIND_SHADER_PROGRAM      = 1 << 7,
+   GX2R_RESOURCE_BIND_SHADER_PROGRAM    = 1 << 7,
 
    //! This resource is to be used as a stream output
-   GX2R_RESOURCE_BIND_STREAM_OUTPUT       = 1 << 8,
+   GX2R_RESOURCE_BIND_STREAM_OUTPUT     = 1 << 8,
 
    //! This resource is to be used as a display list
-   GX2R_RESOURCE_BIND_DISPLAY_LIST        = 1 << 9,
+   GX2R_RESOURCE_BIND_DISPLAY_LIST      = 1 << 9,
 
    //! This resource is to be used as a geometry shader ring buffer
-   GX2R_RESOURCE_BIND_GS_RING_BUFFER      = 1 << 10,
+   GX2R_RESOURCE_BIND_GS_RING_BUFFER    = 1 << 10,
 
    //! Invalidate resource for a CPU read
-   GX2R_RESOURCE_USAGE_CPU_READ           = 1 << 11,
+   GX2R_RESOURCE_USAGE_CPU_READ         = 1 << 11,
 
    //! Invalidate resource for a CPU write
-   GX2R_RESOURCE_USAGE_CPU_WRITE          = 1 << 12,
+   GX2R_RESOURCE_USAGE_CPU_WRITE        = 1 << 12,
 
    //! Invalidate resource for a GPU read
-   GX2R_RESOURCE_USAGE_GPU_READ           = 1 << 13,
+   GX2R_RESOURCE_USAGE_GPU_READ         = 1 << 13,
 
    //! Invalidate resource for a GPU write
-   GX2R_RESOURCE_USAGE_GPU_WRITE          = 1 << 14,
+   GX2R_RESOURCE_USAGE_GPU_WRITE        = 1 << 14,
 
    //! Invalidate resource for a DMA read
-   GX2R_RESOURCE_USAGE_DMA_READ           = 1 << 15,
+   GX2R_RESOURCE_USAGE_DMA_READ         = 1 << 15,
 
    //! Invalidate resource for a DMA write
-   GX2R_RESOURCE_USAGE_DMA_WRITE          = 1 << 16,
+   GX2R_RESOURCE_USAGE_DMA_WRITE        = 1 << 16,
 
    //! Force resource allocation to be in MEM1
-   GX2R_RESOURCE_USAGE_FORCE_MEM1         = 1 << 17,
+   GX2R_RESOURCE_USAGE_FORCE_MEM1       = 1 << 17,
 
    //! Force resource allocation to be in MEM2
-   GX2R_RESOURCE_USAGE_FORCE_MEM2         = 1 << 18,
+   GX2R_RESOURCE_USAGE_FORCE_MEM2       = 1 << 18,
 
    //! Disable CPU invalidation
-   GX2R_RESOURCE_DISABLE_CPU_INVALIDATE   = 1 << 20,
+   GX2R_RESOURCE_DISABLE_CPU_INVALIDATE = 1 << 20,
 
    //! Disable GPU invalidation
-   GX2R_RESOURCE_DISABLE_GPU_INVALIDATE   = 1 << 21,
+   GX2R_RESOURCE_DISABLE_GPU_INVALIDATE = 1 << 21,
 
    //! Resource is locked for read-only access
-   GX2R_RESOURCE_LOCKED_READ_ONLY         = 1 << 22,
+   GX2R_RESOURCE_LOCKED_READ_ONLY       = 1 << 22,
 
    //! Resource was allocated by GX2R.
-   GX2R_RESOURCE_GX2R_ALLOCATED           = 1 << 29,
+   GX2R_RESOURCE_GX2R_ALLOCATED         = 1 << 29,
 
    //! Resource is locked for all access
-   GX2R_RESOURCE_LOCKED                   = 1 << 30,
+   GX2R_RESOURCE_LOCKED                 = 1 << 30,
 } GX2RResourceFlags;
 
 WUT_ENUM_BITMASK_TYPE(GX2RResourceFlags)

include/h264/decode.h

@@ -80,7 +80,7 @@ H264DECSetParam_OUTPUT_PER_FRAME(void *memory,
  */
 H264Error
 H264DECSetParam_USER_MEMORY(void *memory,
-                            void *value);
+                            void **value);
 
 
 /**

include/h264/stream.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <wut.h>
 
 /**
  * \defgroup h264_stream H264 Stream
@@ -20,30 +21,30 @@ typedef void (*H264DECFptrOutputFn)(H264DecodeOutput *output);
 typedef enum H264Error
 {
    //! No errors.
-   H264_ERROR_OK                       = 0,
+   H264_ERROR_OK                  = 0,
 
    //! Invalid picture parameter set.
-   H264_ERROR_INVALID_PPS              = 24,
+   H264_ERROR_INVALID_PPS         = 24,
 
    //! Invalid sequence parameter set.
-   H264_ERROR_INVALID_SPS              = 26,
+   H264_ERROR_INVALID_SPS         = 26,
 
    //! Invalid slice header.
-   H264_ERROR_INVALID_SLICEHEADER      = 61,
+   H264_ERROR_INVALID_SLICEHEADER = 61,
 
    //! Generic h264 error.
-   H264_ERROR_GENERIC                  = 0x1000000,
+   H264_ERROR_GENERIC             = 0x1000000,
 
    //! Invalid parameters passed.
-   H264_ERROR_INVALID_PARAMETER        = 0x1010000,
+   H264_ERROR_INVALID_PARAMETER   = 0x1010000,
 
    //! The amount of memory provided to the h264 library
    //! is insufficient.
-   H264_ERROR_OUT_OF_MEMORY            = 0x1020000,
+   H264_ERROR_OUT_OF_MEMORY       = 0x1020000,
 
    //! Invalid h264 stream profile. Only the baseline (66),
    //! main (77) and high (100) profiles are allowed.
-   H264_ERROR_INVALID_PROFILE          = 0x1080000,
+   H264_ERROR_INVALID_PROFILE     = 0x1080000,
 } H264Error;
 
 struct WUT_PACKED H264DecodedVuiParameters
@@ -167,10 +168,10 @@ struct WUT_PACKED H264DecodeOutput
 {
    //! Number of frames output
    int32_t frameCount;
-   
+
    //! Frames
    H264DecodeResult **decodeResults;
-   
+
    //! User memory pointer passed into SetParam
    void *userMemory;
 };

include/mic/mic.h

@@ -18,12 +18,12 @@ typedef struct MICStatus MICStatus;
 
 typedef enum MICError
 {
-   MIC_ERROR_OK                =  0,
+   MIC_ERROR_OK               = 0,
-   MIC_ERROR_NOT_OPENED        = -1,
+   MIC_ERROR_NOT_OPENED       = -1,
-   MIC_ERROR_INVALID_HANDLE    = -2,
+   MIC_ERROR_INVALID_HANDLE   = -2,
-   MIC_ERROR_INIT              = -5,
+   MIC_ERROR_INIT             = -5,
-   MIC_ERROR_ALREADY_CLOSED    = -7,
+   MIC_ERROR_ALREADY_CLOSED   = -7,
-   MIC_ERROR_INVALID_INSTANCE  = -8,
+   MIC_ERROR_INVALID_INSTANCE = -8,
 } MICError;
 
 typedef enum MICInstance
@@ -46,7 +46,7 @@ WUT_CHECK_SIZE(MICWorkMemory, 0x08);
 
 struct MICStatus
 {
-   int state;    // 1 << 1 = Open
+   int state; // 1 << 1 = Open
    int availableData;
    int bufferPos;
 };
@@ -59,23 +59,31 @@ WUT_CHECK_SIZE(MICStatus, 0x0C);
  * The second parameter to MICInit is unused, any value is valid.
  */
 MICHandle
-MICInit(MICInstance instance, int unused, MICWorkMemory *workMemory,
+MICInit(MICInstance instance,
+        int unused,
+        MICWorkMemory *workMemory,
         MICError *outError);
 
 MICError
 MICOpen(MICHandle handle);
 
 MICError
-MICGetState(MICHandle handle, int state, uint32_t *outStateVal);
+MICGetState(MICHandle handle,
+            int state,
+            uint32_t *outStateVal);
 
 MICError
-MICSetState(MICHandle handle, int state, uint32_t stateVal);
+MICSetState(MICHandle handle,
+            int state,
+            uint32_t stateVal);
 
 MICError
-MICGetStatus(MICHandle handle, MICStatus *outStatus);
+MICGetStatus(MICHandle handle,
+             MICStatus *outStatus);
 
 MICError
-MICSetDataConsumed(MICHandle handle, int dataAmountConsumed);
+MICSetDataConsumed(MICHandle handle,
+                   int dataAmountConsumed);
 
 MICError
 MICClose(MICHandle handle);

include/netdb.h

@@ -6,30 +6,30 @@ extern int h_errno;
 
 struct hostent
 {
-   char  *h_name;
+   char *h_name;
    char **h_aliases;
-   int    h_addrtype;
+   int h_addrtype;
-   int    h_length;
+   int h_length;
    char **h_addr_list;
-#define	h_addr h_addr_list[0]
+#define h_addr h_addr_list[0]
 };
 
 struct servent
 {
-   char  *s_name;
+   char *s_name;
    char **s_aliases;
-   int    s_port;
+   int s_port;
-   char  *s_proto;
+   char *s_proto;
 };
 
 struct addrinfo
 {
-   int              ai_flags;
+   int ai_flags;
-   int              ai_family;
+   int ai_family;
-   int              ai_socktype;
+   int ai_socktype;
-   int              ai_protocol;
+   int ai_protocol;
-   socklen_t        ai_addrlen;
+   socklen_t ai_addrlen;
-   char            *ai_canonname;
+   char *ai_canonname;
    struct sockaddr *ai_addr;
    struct addrinfo *ai_next;
 };
@@ -86,7 +86,7 @@ gethostbyname(const char *name);
 
 struct hostent *
 gethostbyaddr(const void *addr,
-              socklen_t len, 
+              socklen_t len,
               int type);
 
 struct hostent *

include/netinet/in.h

@@ -15,17 +15,31 @@
 
 #define IP_TOS             3
 #define IP_TTL             4
+#define IP_MULTICAST_IF    9
+#define IP_MULTICAST_TTL   10
+#define IP_MULTICAST_LOOP  11
+#define IP_ADD_MEMBERSHIP  12
+#define IP_DROP_MEMBERSHIP 13
+#define IP_UNKNOWN         14
 
 typedef uint16_t in_port_t;
 typedef uint32_t in_addr_t;
 
-struct in_addr {
+struct in_addr
-	in_addr_t       s_addr;
+{
+   in_addr_t s_addr;
 };
 
-struct sockaddr_in {
+struct sockaddr_in
-	sa_family_t     sin_family;
+{
-	in_port_t       sin_port;
+   sa_family_t sin_family;
-	struct in_addr  sin_addr;
+   in_port_t sin_port;
-	unsigned char   sin_zero[8];
+   struct in_addr sin_addr;
+   unsigned char sin_zero[8];
+};
+
+struct ip_mreq
+{
+   struct in_addr imr_multiaddr;
+   struct in_addr imr_interface;
 };

include/netinet/tcp.h

@@ -1,8 +1,9 @@
 #pragma once
 
-#define SOL_TCP            6
+#define SOL_TCP          6
 
-#define TCP_ACKDELAYTIME   0x2001
+#define TCP_ACKDELAYTIME 0x2001
-#define TCP_NOACKDELAY     0x2002
+#define TCP_NOACKDELAY   0x2002
-#define TCP_MAXSEG         0x2003
+#define TCP_MAXSEG       0x2003
-#define TCP_NODELAY        0x2004
+#define TCP_NODELAY      0x2004
+#define TCP_UNKNOWN      0x2005 // amount of mss received before sending an ack

include/nfc/nfc.dox

@@ -0,0 +1,4 @@
+/**
+ * \defgroup nfc nfc
+ * Near Field Communication (NFC).
+ */

include/nn/ac/ac_cpp.h

@@ -1,6 +1,7 @@
 #pragma once
 #include <wut.h>
 #include <nn/result.h>
+#include <nsysnet/netconfig.h>
 
 /**
  * \defgroup nn_ac_cpp Auto Connect C++ API
@@ -24,103 +25,55 @@ namespace ac
  * An ID number representing a network configuration. These are the same IDs as
  * shown in System Settings' Connection List.
  */
-typedef uint32_t ConfigIdNum;
+using ConfigIdNum = uint32_t;
 
 /**
- * C++ linkage for the autoconnect API, see \link nn::ac \endlink for use.
+ * The configuration for a given network profile (from 1 to 6).
- * Cafe provides mangled symbols for C++ APIs, so nn::ac is actually static
+ * \sa NetConfCfg
- * inline calls to the mangled symbols under nn::ac::detail.
  */
-namespace detail
+using Config      = NetConfCfg;
+
+using ErrorCode   = uint32_t;
+
+enum Status
 {
-extern "C"
+   STATUS_FAILED     = -1,
-{
+   STATUS_OK         = 0,
-
+   STATUS_PROCESSING = 1,
-nn::Result Initialize__Q2_2nn2acFv();
+};
-void Finalize__Q2_2nn2acFv();
-nn::Result Connect__Q2_2nn2acFv();
-nn::Result ConnectAsync__Q2_2nn2acFv();
-nn::Result Close__Q2_2nn2acFv();
-nn::Result GetCloseStatus__Q2_2nn2acFPQ3_2nn2ac6Status();
-nn::Result GetStartupId__Q2_2nn2acFPQ3_2nn2ac11ConfigIdNum(ConfigIdNum *id);
-nn::Result Connect__Q2_2nn2acFQ3_2nn2ac11ConfigIdNum(ConfigIdNum id);
-nn::Result GetAssignedAddress__Q2_2nn2acFPUl(uint32_t *ip);
-
-} // extern "C"
-} // namespace detail
-
-/**
- * Initialise the Auto Connect library. Call this function before any other nn::ac
- * functions.
- *
- * \return
- * A \link nn::Result Result\endlink - see \link nn::Result::IsSuccess \endlink
- * and \link nn::Result::IsFailure \endlink.
- *
- * \sa
- * - \link Finalize \endlink
- */
-static inline nn::Result
-Initialize()
-{
-   return detail::Initialize__Q2_2nn2acFv();
-}
-
-/**
- * Cleanup the Auto Connect library. Do not call any nn::ac functions (other
- * than \link Initialize \endlink) after calling this function.
- *
- * \sa
- * - \link Initialize \endlink
- */
-static inline void
-Finalize()
-{
-   return detail::Finalize__Q2_2nn2acFv();
-}
 
 
-/**
+nn::Result
- * Gets the default connection configuration id. This is the default as marked
+BeginLocalConnection(bool unknown)
- * in System Settings.
+   asm("BeginLocalConnection__Q2_2nn2acFb");
- *
- * \param id
- * A pointer to an \link ConfigIdNum \endlink to write the config ID to. Must
- * not be a \c nullptr.
- *
- * \return
- * A \link nn::Result Result\endlink - see \link nn::Result::IsSuccess \endlink
- * and \link nn::Result::IsFailure \endlink.
- */
-static inline nn::Result
-GetStartupId(ConfigIdNum *id)
-{
-   return detail::GetStartupId__Q2_2nn2acFPQ3_2nn2ac11ConfigIdNum(id);
-}
 
-static inline nn::Result
+void
-Connect()
+ClearConfig(Config *cfg)
-{
+   asm("ClearConfig__Q2_2nn2acFP16netconf_profile_");
-   return detail::Connect__Q2_2nn2acFv();
-}
 
-static inline nn::Result
+nn::Result
-ConnectAsync()
-{
-   return detail::ConnectAsync__Q2_2nn2acFv();
-}
-
-static inline nn::Result
 Close()
-{
+   asm("Close__Q2_2nn2acFv");
-   return detail::Close__Q2_2nn2acFv();
-}
 
-static inline nn::Result
+nn::Result
-GetCloseStatus()
+CloseAll()
-{
+   asm("CloseAll__Q2_2nn2acFv");
-   return detail::GetCloseStatus__Q2_2nn2acFPQ3_2nn2ac6Status();
+
-}
+nn::Result
+Connect(const Config *cfg)
+   asm("Connect__Q2_2nn2acFPC16netconf_profile_");
+
+nn::Result
+Connect(ConfigIdNum id)
+   asm("Connect__Q2_2nn2acFQ3_2nn2ac11ConfigIdNum");
+
+nn::Result
+Connect()
+   asm("Connect__Q2_2nn2acFv");
+
+nn::Result
+ConnectAsync(const Config *cfg)
+   asm("ConnectAsync__Q2_2nn2acFPC16netconf_profile_");
 
 /**
  * Connects to a network, using the configuration represented by the given
@@ -133,11 +86,36 @@ GetCloseStatus()
  * A \link nn::Result Result\endlink - see \link nn::Result::IsSuccess \endlink
  * and \link nn::Result::IsFailure \endlink.
  */
-static inline nn::Result
+nn::Result
-Connect(ConfigIdNum id)
+ConnectAsync(ConfigIdNum id)
-{
+   asm("ConnectAsync__Q2_2nn2acFQ3_2nn2ac11ConfigIdNum");
-   return detail::Connect__Q2_2nn2acFQ3_2nn2ac11ConfigIdNum(id);
+
-}
+nn::Result
+ConnectAsync()
+   asm("ConnectAsync__Q2_2nn2acFv");
+
+nn::Result
+ConnectWithRetry()
+   asm("ConnectWithRetry__Q2_2nn2acFv");
+
+nn::Result
+DeleteConfig(ConfigIdNum id)
+   asm("DeleteConfig__Q2_2nn2acFQ3_2nn2ac11ConfigIdNum");
+
+nn::Result
+EndLocalConnection()
+   asm("EndLocalConnection__Q2_2nn2acFv");
+
+/**
+ * Cleans up the Auto Connect library. Do not call any nn::ac functions (other
+ * than \link Initialize \endlink) after calling this function.
+ *
+ * \sa
+ * - \link Initialize \endlink
+ */
+void
+Finalize()
+   asm("Finalize__Q2_2nn2acFv");
 
 /**
  * Gets the IP address assosciated with the currently active connection.
@@ -151,11 +129,120 @@ Connect(ConfigIdNum id)
  * A \link nn::Result Result\endlink - see \link nn::Result::IsSuccess \endlink
  * and \link nn::Result::IsFailure \endlink.
  */
-static inline nn::Result
+nn::Result
 GetAssignedAddress(uint32_t *ip)
-{
+   asm("GetAssignedAddress__Q2_2nn2acFPUl");
-   return detail::GetAssignedAddress__Q2_2nn2acFPUl(ip);
+
-}
+nn::Result
+GetAssignedAlternativeDns(uint32_t *ip)
+   asm("GetAssignedAlternativeDns__Q2_2nn2acFPUl");
+
+nn::Result
+GetAssignedGateway(uint32_t *ip)
+   asm("GetAssignedGateway__Q2_2nn2acFPUl");
+
+nn::Result
+GetAssignedPreferedDns(uint32_t *ip)
+   asm("GetAssignedPreferedDns__Q2_2nn2acFPUl");
+
+nn::Result
+GetAssignedSubnet(uint32_t *ip)
+   asm("GetAssignedSubnet__Q2_2nn2acFPUl");
+
+nn::Result
+GetCloseStatus(Status *status)
+   asm("GetCloseStatus__Q2_2nn2acFPQ3_2nn2ac6Status");
+
+nn::Result
+GetCompatId(ConfigIdNum *id)
+   asm("GetCompatId__Q2_2nn2acFPQ3_2nn2ac11ConfigIdNum");
+
+nn::Result
+GetConnectResult(nn::Result *result)
+   asm("GetConnectResult__Q2_2nn2acFPQ2_2nn6Result");
+
+nn::Result
+GetConnectStatus(Status *status)
+   asm("GetConnectStatus__Q2_2nn2acFPQ3_2nn2ac6Status");
+
+nn::Result
+GetLastErrorCode(ErrorCode *error)
+   asm("GetLastErrorCode__Q2_2nn2acFPUi");
+
+nn::Result
+GetRunningConfig(Config *cfg)
+   asm("GetRunningConfig__Q2_2nn2acFP16netconf_profile_");
+
+/**
+ * Gets the default connection configuration id. This is the default as marked
+ * in System Settings.
+ *
+ * \param id
+ * A pointer to an \link ConfigIdNum \endlink to write the config ID to. Must
+ * not be a \c nullptr.
+ *
+ * \return
+ * A \link nn::Result Result\endlink - see \link nn::Result::IsSuccess \endlink
+ * and \link nn::Result::IsFailure \endlink.
+ */
+nn::Result
+GetStartupId(ConfigIdNum *id)
+   asm("GetStartupId__Q2_2nn2acFPQ3_2nn2ac11ConfigIdNum");
+
+/**
+ * Initializes the Auto Connect library. Call this function before any other nn::ac
+ * functions.
+ *
+ * \return
+ * A \link nn::Result Result\endlink - see \link nn::Result::IsSuccess \endlink
+ * and \link nn::Result::IsFailure \endlink.
+ *
+ * \sa
+ * - \link Finalize \endlink
+ */
+nn::Result
+Initialize()
+   asm("Initialize__Q2_2nn2acFv");
+
+nn::Result
+IsAnyKeepingConnect(bool keeping)
+   asm("IsAnyKeepingConnect__Q2_2nn2acFPb");
+
+nn::Result
+IsApplicationConnected(bool *connected)
+   asm("IsApplicationConnected__Q2_2nn2acFPb");
+
+nn::Result
+IsAutoConnectionFatallyFailed(nn::Result *failed)
+   asm("IsAutoConnectionFatallyFailed__Q2_2nn2acFQ2_2nn6Result");
+
+nn::Result
+IsConfigExisting(ConfigIdNum id, bool *existing)
+   asm("IsConfigExisting__Q2_2nn2acFQ3_2nn2ac11ConfigIdNumPb");
+
+nn::Result
+IsKeepingConnect(bool *keeping)
+   asm("IsKeepingConnect__Q2_2nn2acFPb");
+
+nn::Result
+IsReadyToConnect(bool *ready)
+   asm("IsReadyToConnect__Q2_2nn2acFPb");
+
+nn::Result
+ReadConfig(ConfigIdNum id, Config *cfg)
+   asm("ReadConfig__Q2_2nn2acFQ3_2nn2ac11ConfigIdNumP16netconf_profile_");
+
+nn::Result
+SetCompatId(ConfigIdNum id)
+   asm("SetCompatId__Q2_2nn2acFQ3_2nn2ac11ConfigIdNum");
+
+nn::Result
+SetStartupId(ConfigIdNum id)
+   asm("SetStartupId__Q2_2nn2acFQ3_2nn2ac11ConfigIdNum");
+
+nn::Result
+WriteConfig(ConfigIdNum id, const Config *cfg)
+   asm("WriteConfig__Q2_2nn2acFQ3_2nn2ac11ConfigIdNumPC16netconf_profile_");
 
 } // namespace ac
 } // namespace nn

include/nn/acp.h

@@ -7,8 +7,8 @@
 
 #include <nn/acp/client.h>
 #include <nn/acp/device.h>
+#include <nn/acp/drcled_c.h>
+#include <nn/acp/drcled_cpp.h>
 #include <nn/acp/result.h>
 #include <nn/acp/save.h>
 #include <nn/acp/title.h>
-#include <nn/acp/drcled_c.h>
-#include <nn/acp/drcled_cpp.h>

include/nn/acp/device.h

@@ -12,10 +12,18 @@
 extern "C" {
 #endif
 
-typedef int32_t ACPDeviceType;
+typedef enum ACPDeviceType
+{
+   ACP_DEVICE_TYPE_AUTO     = 1,
+   ACP_DEVICE_TYPE_ODD      = 2,
+   ACP_DEVICE_TYPE_HFIODISC = 2, /* when ApplicationDevice is emulated */
+   ACP_DEVICE_TYPE_MLC      = 3,
+   ACP_DEVICE_TYPE_HFIOMLC  = 3, /* when ApplicationDevice is emulated */
+   ACP_DEVICE_TYPE_USB      = 4,
+} ACPDeviceType;
 
 ACPResult
-ACPCheckApplicationDeviceEmulation(BOOL* emulation);
+ACPCheckApplicationDeviceEmulation(BOOL *emulation);
 
 #ifdef __cplusplus
 }

include/nn/acp/drcled_c.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include <wut.h>
-#include <nn/acp/result.h>
 #include <nn/acp/device.h>
+#include <nn/acp/result.h>
 
 #ifdef __cplusplus
 extern "C" {

include/nn/acp/drcled_cpp.h

@@ -1,14 +1,16 @@
 #pragma once
 
 #include <wut.h>
-#include <nn/acp/result.h>
 #include <nn/acp/device.h>
+#include <nn/acp/result.h>
 
 #ifdef __cplusplus
 
-namespace nn {
+namespace nn
+{
 
-namespace acp {
+namespace acp
+{
 
 typedef uint8_t DrcLedStatus;
 typedef uint32_t DrcLedPattern;
@@ -24,7 +26,7 @@ SetDrcLedDummyPowerStat(uint8_t unk1)
 
 void
 SetDrcLedTimerLength(uint64_t unk1,
-                        uint64_t unk2)
+                     uint64_t unk2)
    asm("SetDrcLedTimerLength__Q2_2nn3acpFULT1");
 
 void
@@ -41,13 +43,13 @@ TurnOffDrcLedTest(uint8_t unk1)
 
 void
 TurnOnDrcLed(uint32_t unk1,
-                DrcLedPattern pattern)
+             DrcLedPattern pattern)
    asm("TurnOnDrcLed__Q2_2nn3acpFUiQ3_2nn3acp13DrcLedPattern");
 
 void
 TurnOnDrcLedTest(uint8_t unk1,
-                uint32_t unk2,
+                 uint32_t unk2,
-                DrcLedPattern pattern)
+                 DrcLedPattern pattern)
    asm("TurnOnDrcLedTest__Q2_2nn3acpFUcUiQ3_2nn3acp13DrcLedPattern");
 
 } //namespace acp

include/nn/acp/result.h

@@ -8,89 +8,90 @@
  * @{
  */
 
-typedef enum ACPResult {
+typedef enum ACPResult
-    ACP_RESULT_SUCCESS                 = 0,
+{
+   ACP_RESULT_SUCCESS                 = 0,
 
-    ACP_RESULT_INVALID                 = -200,
+   ACP_RESULT_INVALID                 = -200,
-    ACP_RESULT_INVALID_PARAMETER       = -201,
+   ACP_RESULT_INVALID_PARAMETER       = -201,
-    ACP_RESULT_INVALID_FILE            = -202,
+   ACP_RESULT_INVALID_FILE            = -202,
-    ACP_RESULT_INVALID_XML_FILE        = -203,
+   ACP_RESULT_INVALID_XML_FILE        = -203,
-    ACP_RESULT_FILE_ACCESS_MODE        = -204,
+   ACP_RESULT_FILE_ACCESS_MODE        = -204,
-    ACP_RESULT_INVALID_NETWORK_TIME    = -205,
+   ACP_RESULT_INVALID_NETWORK_TIME    = -205,
 
-    ACP_RESULT_NOT_FOUND               = -500,
+   ACP_RESULT_NOT_FOUND               = -500,
-    ACP_RESULT_FILE_NOT_FOUND          = -501,
+   ACP_RESULT_FILE_NOT_FOUND          = -501,
-    ACP_RESULT_DIR_NOT_FOUND           = -502,
+   ACP_RESULT_DIR_NOT_FOUND           = -502,
-    ACP_RESULT_DEVICE_NOT_FOUND        = -503,
+   ACP_RESULT_DEVICE_NOT_FOUND        = -503,
-    ACP_RESULT_TITLE_NOT_FOUND         = -504,
+   ACP_RESULT_TITLE_NOT_FOUND         = -504,
-    ACP_RESULT_APPLICATION_NOT_FOUND   = -505,
+   ACP_RESULT_APPLICATION_NOT_FOUND   = -505,
-    ACP_RESULT_SYSTEM_CONFIG_NOT_FOUND = -506,
+   ACP_RESULT_SYSTEM_CONFIG_NOT_FOUND = -506,
-    ACP_RESULT_XML_ITEM_NOT_FOUND      = -507,
+   ACP_RESULT_XML_ITEM_NOT_FOUND      = -507,
 
-    ACP_RESULT_ALREADY_EXISTS          = -600,
+   ACP_RESULT_ALREADY_EXISTS          = -600,
-    ACP_RESULT_FILE_ALREADY_EXISTS     = -601,
+   ACP_RESULT_FILE_ALREADY_EXISTS     = -601,
-    ACP_RESULT_DIR_ALREADY_EXISTS      = -602,
+   ACP_RESULT_DIR_ALREADY_EXISTS      = -602,
 
-    ACP_RESULT_ALREADY_DONE            = -700,
+   ACP_RESULT_ALREADY_DONE            = -700,
 
-    ACP_RESULT_AUTHENTICATION          = -1000,
+   ACP_RESULT_AUTHENTICATION          = -1000,
-    ACP_RESULT_INVALID_REGION          = -1001,
+   ACP_RESULT_INVALID_REGION          = -1001,
-    ACP_RESULT_RESTRICTED_RATING       = -1002,
+   ACP_RESULT_RESTRICTED_RATING       = -1002,
-    ACP_RESULT_NOT_PRESENT_RATING      = -1003,
+   ACP_RESULT_NOT_PRESENT_RATING      = -1003,
-    ACP_RESULT_PENDING_RATING          = -1004,
+   ACP_RESULT_PENDING_RATING          = -1004,
-    ACP_RESULT_NET_SETTING_REQUIRED    = -1005,
+   ACP_RESULT_NET_SETTING_REQUIRED    = -1005,
-    ACP_RESULT_NET_ACCOUNT_REQUIRED    = -1006,
+   ACP_RESULT_NET_ACCOUNT_REQUIRED    = -1006,
-    ACP_RESULT_NET_ACCOUNT_ERROR       = -1007,
+   ACP_RESULT_NET_ACCOUNT_ERROR       = -1007,
-    ACP_RESULT_BROWSER_REQUIRED        = -1008,
+   ACP_RESULT_BROWSER_REQUIRED        = -1008,
-    ACP_RESULT_OLV_REQUIRED            = -1009,
+   ACP_RESULT_OLV_REQUIRED            = -1009,
-    ACP_RESULT_PINCODE_REQUIRED        = -1010,
+   ACP_RESULT_PINCODE_REQUIRED        = -1010,
-    ACP_RESULT_INCORRECT_PINCODE       = -1011,
+   ACP_RESULT_INCORRECT_PINCODE       = -1011,
-    ACP_RESULT_INVALID_LOGO            = -1012,
+   ACP_RESULT_INVALID_LOGO            = -1012,
-    ACP_RESULT_DEMO_EXPIRED_NUMBER     = -1013,
+   ACP_RESULT_DEMO_EXPIRED_NUMBER     = -1013,
-    ACP_RESULT_DRC_REQUIRED            = -1014,
+   ACP_RESULT_DRC_REQUIRED            = -1014,
 
-    ACP_RESULT_NO_PERMISSION           = -1100,
+   ACP_RESULT_NO_PERMISSION           = -1100,
-    ACP_RESULT_NO_FILE_PERMISSION      = -1101,
+   ACP_RESULT_NO_FILE_PERMISSION      = -1101,
-    ACP_RESULT_NO_DIR_PERMISSION       = -1102,
+   ACP_RESULT_NO_DIR_PERMISSION       = -1102,
 
-    ACP_RESULT_BUSY                    = -1300,
+   ACP_RESULT_BUSY                    = -1300,
-    ACP_RESULT_USB_STORAGE_NOT_READY   = -1301,
+   ACP_RESULT_USB_STORAGE_NOT_READY   = -1301,
 
-    ACP_RESULT_CANCELLED               = -1400,
+   ACP_RESULT_CANCELLED               = -1400,
 
-    ACP_RESULT_RESOURCE                = -1500,
+   ACP_RESULT_RESOURCE                = -1500,
-    ACP_RESULT_DEVICE_FULL             = -1501,
+   ACP_RESULT_DEVICE_FULL             = -1501,
-    ACP_RESULT_JOURNAL_FULL            = -1502,
+   ACP_RESULT_JOURNAL_FULL            = -1502,
-    ACP_RESULT_SYSTEM_MEMORY           = -1503,
+   ACP_RESULT_SYSTEM_MEMORY           = -1503,
-    ACP_RESULT_FS_RESOURCE             = -1504,
+   ACP_RESULT_FS_RESOURCE             = -1504,
-    ACP_RESULT_IPC_RESOURCE            = -1505,
+   ACP_RESULT_IPC_RESOURCE            = -1505,
 
-    ACP_RESULT_NOT_INITIALISED         = -1600,
+   ACP_RESULT_NOT_INITIALISED         = -1600,
 
-    ACP_RESULT_ACCOUNT_ERROR           = -1700,
+   ACP_RESULT_ACCOUNT_ERROR           = -1700,
 
-    ACP_RESULT_UNSUPPORTED             = -1800,
+   ACP_RESULT_UNSUPPORTED             = -1800,
 
-    ACP_RESULT_DATA_CORRUPTED          = -2000,
+   ACP_RESULT_DATA_CORRUPTED          = -2000,
-    ACP_RESULT_DEVICE                  = -2001,
+   ACP_RESULT_DEVICE                  = -2001,
-    ACP_RESULT_SLC_DATA_CORRUPTED      = -2002,
+   ACP_RESULT_SLC_DATA_CORRUPTED      = -2002,
-    ACP_RESULT_MLC_DATA_CORRUPTED      = -2003,
+   ACP_RESULT_MLC_DATA_CORRUPTED      = -2003,
-    ACP_RESULT_USB_DATA_CORRUPTED      = -2004,
+   ACP_RESULT_USB_DATA_CORRUPTED      = -2004,
 
-    ACP_RESULT_MEDIA                   = -2100,
+   ACP_RESULT_MEDIA                   = -2100,
-    ACP_RESULT_MEDIA_NOT_READY         = -2101,
+   ACP_RESULT_MEDIA_NOT_READY         = -2101,
-    ACP_RESULT_MEDIA_BROKEN            = -2102,
+   ACP_RESULT_MEDIA_BROKEN            = -2102,
-    ACP_RESULT_ODD_MEDIA_NOT_READY     = -2103,
+   ACP_RESULT_ODD_MEDIA_NOT_READY     = -2103,
-    ACP_RESULT_ODD_MEDIA_BROKEN        = -2104,
+   ACP_RESULT_ODD_MEDIA_BROKEN        = -2104,
-    ACP_RESULT_USB_MEDIA_NOT_READY     = -2105,
+   ACP_RESULT_USB_MEDIA_NOT_READY     = -2105,
-    ACP_RESULT_USB_MEDIA_BROKEN        = -2106,
+   ACP_RESULT_USB_MEDIA_BROKEN        = -2106,
-    ACP_RESULT_MEDIA_WRITE_PROTECTED   = -2107,
+   ACP_RESULT_MEDIA_WRITE_PROTECTED   = -2107,
-    ACP_RESULT_USB_WRITE_PROTECTED     = -2108,
+   ACP_RESULT_USB_WRITE_PROTECTED     = -2108,
 
-    ACP_RESULT_MII                     = -2200,
+   ACP_RESULT_MII                     = -2200,
-    ACP_RESULT_ENCRYPTION_ERROR        = -2201,
+   ACP_RESULT_ENCRYPTION_ERROR        = -2201,
 
-    ACP_RESULT_GENERIC_ERROR           = -4096,
+   ACP_RESULT_GENERIC_ERROR           = -4096,
 } ACPResult;
 WUT_CHECK_SIZE(ACPResult, 0x4);
 

include/nn/acp/save.h

@@ -1,7 +1,7 @@
 #pragma once
 #include <wut.h>
-#include <nn/acp/result.h>
 #include <nn/acp/device.h>
+#include <nn/acp/result.h>
 
 /**
  * \defgroup nn_acp_save Save
@@ -15,12 +15,27 @@
 extern "C" {
 #endif
 
+typedef uint64_t ACPTitleId;
+typedef struct ACPSaveDirInfo ACPSaveDirInfo;
+
+struct WUT_PACKED ACPSaveDirInfo
+{
+   WUT_UNKNOWN_BYTES(0x8);
+   uint32_t persistentId;
+   WUT_UNKNOWN_BYTES(0x14);
+   char path[0x40];
+   WUT_PADDING_BYTES(0x80 - 0x60);
+};
+WUT_CHECK_OFFSET(ACPSaveDirInfo, 0x08, persistentId);
+WUT_CHECK_OFFSET(ACPSaveDirInfo, 0x20, path);
+WUT_CHECK_SIZE(ACPSaveDirInfo, 0x80);
+
 ACPResult
 ACPCreateSaveDir(uint32_t persistentId,
                  ACPDeviceType deviceType);
 
 ACPResult
-ACPIsExternalStorageRequired(BOOL* required);
+ACPIsExternalStorageRequired(BOOL *required);
 
 ACPResult
 ACPMountExternalStorage();
@@ -28,6 +43,48 @@ ACPMountExternalStorage();
 ACPResult
 ACPMountSaveDir();
 
+/**
+ * Deletes the given user's save data directory for the given title.
+ * 
+ * \param persistentId
+ * The persistent ID of the user. Pass \c 0 to delete the 'common' directory.
+ * 
+ * \return
+ * ACP_RESULT_SUCCESS on success.
+ */
+ACPResult
+ACPRemoveSaveDir(uint32_t persistentId,
+                 uint64_t titleId,
+                 ACPDeviceType deviceType);
+
+/**
+ * Deletes the given user's save data directory for the given title.
+ * 
+ * \param persistentId
+ * The persistent ID of the user. Pass \c 0 to delete the 'common' directory.
+ * 
+ * \return
+ * ACP_RESULT_SUCCESS on success.
+ */
+ACPResult
+ACPRemoveSaveDirWithoutFlush(uint32_t persistentId,
+                             uint64_t titleId,
+                             ACPDeviceType deviceType);
+
+/**
+ * Deletes the given user's save data directory for the given title.
+ * 
+ * \param persistentId
+ * The persistent ID of the user. Pass \c 0 to delete the 'common' directory.
+ * 
+ * \return
+ * ACP_RESULT_SUCCESS on success.
+ */
+ACPResult
+ACPRemoveSaveDirWithoutMetaCheck(uint32_t persistentId,
+                                 uint64_t titleId,
+                                 ACPDeviceType deviceType);
+
 ACPResult
 ACPRepairSaveMetaDir();
 
@@ -37,6 +94,59 @@ ACPUnmountExternalStorage();
 ACPResult
 ACPUnmountSaveDir();
 
+/**
+ * Gets all titles id which have save data
+ *
+ * @param deviceType
+ * @param titlesOut needs to be aligned to 0x40
+ * @param maxCount needs to be a multiple of 8
+ * @param countOut
+ * @return ACP_RESULT_SUCCESS on success.
+ */
+ACPResult
+ACPGetSaveDataTitleIdList(ACPDeviceType deviceType,
+                          uint64_t *titlesOut,
+                          uint32_t maxCount,
+                          uint32_t *countOut);
+
+/**
+ * Gets a list of all saves dir for a given title id
+ *
+ * @param titleId
+ * @param deviceType
+ * @param u1 seems to be always 0
+ * @param saveDirInfo needs to be aligned to 0x40
+ * @param maxCount
+ * @param countOut
+ * @return ACP_RESULT_SUCCESS on success.
+ */
+ACPResult
+ACPGetTitleSaveDirEx(uint64_t titleId,
+                     ACPDeviceType deviceType,
+                     uint32_t u1,
+                     ACPSaveDirInfo *saveDirInfo,
+                     uint32_t maxCount,
+                     uint32_t *countOut);
+
+/**
+ * Gets a list of all saves dir for a given title id
+ *
+ * @param titleId
+ * @param deviceType
+ * @param u1 seems to be always 0
+ * @param saveDirInfo needs to be aligned to 0x40
+ * @param maxCount
+ * @param countOut
+ * @return ACP_RESULT_SUCCESS on success.
+ */
+ACPResult
+ACPGetTitleSaveDirExWithoutMetaCheck(uint64_t titleId,
+                                     ACPDeviceType deviceType,
+                                     uint32_t u1,
+                                     ACPSaveDirInfo *saveDirInfo,
+                                     uint32_t maxCount,
+                                     uint32_t *countOut);
+
 #ifdef __cplusplus
 }
 #endif

include/nn/acp/title.h

@@ -1,9 +1,9 @@
 #pragma once
 
 #include <wut.h>
-#include <nn/acp/result.h>
-#include <nn/acp/device.h>
 #include <coreinit/mcp.h>
+#include <nn/acp/device.h>
+#include <nn/acp/result.h>
 
 /**
  * \defgroup nn_acp_title Title
@@ -20,114 +20,115 @@ extern "C" {
 typedef uint64_t ACPTitleId;
 typedef struct ACPMetaXml ACPMetaXml;
 
-struct WUT_PACKED ACPMetaXml {
+struct WUT_PACKED ACPMetaXml
-    uint64_t title_id;
+{
-    uint64_t boss_id;
+   uint64_t title_id;
-    uint64_t os_version;
+   uint64_t boss_id;
-    uint64_t app_size;
+   uint64_t os_version;
-    uint64_t common_save_size;
+   uint64_t app_size;
-    uint64_t account_save_size;
+   uint64_t common_save_size;
-    uint64_t common_boss_size;
+   uint64_t account_save_size;
-    uint64_t account_boss_size;
+   uint64_t common_boss_size;
-    uint64_t join_game_mode_mask;
+   uint64_t account_boss_size;
-    uint32_t version;
+   uint64_t join_game_mode_mask;
-    char product_code[32];
+   uint32_t version;
-    char content_platform[32];
+   char product_code[32];
-    char company_code[8];
+   char content_platform[32];
-    char mastering_date[32];
+   char company_code[8];
-    uint32_t logo_type;
+   char mastering_date[32];
-    uint32_t app_launch_type;
+   uint32_t logo_type;
-    uint32_t invisible_flag;
+   uint32_t app_launch_type;
-    uint32_t no_managed_flag;
+   uint32_t invisible_flag;
-    uint32_t no_event_log;
+   uint32_t no_managed_flag;
-    uint32_t no_icon_database;
+   uint32_t no_event_log;
-    uint32_t launching_flag;
+   uint32_t no_icon_database;
-    uint32_t install_flag;
+   uint32_t launching_flag;
-    uint32_t closing_msg;
+   uint32_t install_flag;
-    uint32_t title_version;
+   uint32_t closing_msg;
-    uint32_t group_id;
+   uint32_t title_version;
-    uint32_t save_no_rollback;
+   uint32_t group_id;
-    uint32_t bg_daemon_enable;
+   uint32_t save_no_rollback;
-    uint32_t join_game_id;
+   uint32_t bg_daemon_enable;
-    uint32_t olv_accesskey;
+   uint32_t join_game_id;
-    uint32_t wood_tin;
+   uint32_t olv_accesskey;
-    uint32_t e_manual;
+   uint32_t wood_tin;
-    uint32_t e_manual_version;
+   uint32_t e_manual;
-    uint32_t region;
+   uint32_t e_manual_version;
-    uint32_t pc_cero;
+   uint32_t region;
-    uint32_t pc_esrb;
+   uint32_t pc_cero;
-    uint32_t pc_bbfc;
+   uint32_t pc_esrb;
-    uint32_t pc_usk;
+   uint32_t pc_bbfc;
-    uint32_t pc_pegi_gen;
+   uint32_t pc_usk;
-    uint32_t pc_pegi_fin;
+   uint32_t pc_pegi_gen;
-    uint32_t pc_pegi_prt;
+   uint32_t pc_pegi_fin;
-    uint32_t pc_pegi_bbfc;
+   uint32_t pc_pegi_prt;
-    uint32_t pc_cob;
+   uint32_t pc_pegi_bbfc;
-    uint32_t pc_grb;
+   uint32_t pc_cob;
-    uint32_t pc_cgsrr;
+   uint32_t pc_grb;
-    uint32_t pc_oflc;
+   uint32_t pc_cgsrr;
-    uint32_t pc_reserved0;
+   uint32_t pc_oflc;
-    uint32_t pc_reserved1;
+   uint32_t pc_reserved0;
-    uint32_t pc_reserved2;
+   uint32_t pc_reserved1;
-    uint32_t pc_reserved3;
+   uint32_t pc_reserved2;
-    uint32_t ext_dev_nunchaku;
+   uint32_t pc_reserved3;
-    uint32_t ext_dev_classic;
+   uint32_t ext_dev_nunchaku;
-    uint32_t ext_dev_urcc;
+   uint32_t ext_dev_classic;
-    uint32_t ext_dev_board;
+   uint32_t ext_dev_urcc;
-    uint32_t ext_dev_usb_keyboard;
+   uint32_t ext_dev_board;
-    uint32_t ext_dev_etc;
+   uint32_t ext_dev_usb_keyboard;
-    char ext_dev_etc_name[512];
+   uint32_t ext_dev_etc;
-    uint32_t eula_version;
+   char ext_dev_etc_name[512];
-    uint32_t drc_use;
+   uint32_t eula_version;
-    uint32_t network_use;
+   uint32_t drc_use;
-    uint32_t online_account_use;
+   uint32_t network_use;
-    uint32_t direct_boot;
+   uint32_t online_account_use;
-    uint32_t reserved_flag0;
+   uint32_t direct_boot;
-    uint32_t reserved_flag1;
+   uint32_t reserved_flag0;
-    uint32_t reserved_flag2;
+   uint32_t reserved_flag1;
-    uint32_t reserved_flag3;
+   uint32_t reserved_flag2;
-    uint32_t reserved_flag4;
+   uint32_t reserved_flag3;
-    uint32_t reserved_flag5;
+   uint32_t reserved_flag4;
-    uint32_t reserved_flag6;
+   uint32_t reserved_flag5;
-    uint32_t reserved_flag7;
+   uint32_t reserved_flag6;
-    char longname_ja[512];
+   uint32_t reserved_flag7;
-    char longname_en[512];
+   char longname_ja[512];
-    char longname_fr[512];
+   char longname_en[512];
-    char longname_de[512];
+   char longname_fr[512];
-    char longname_it[512];
+   char longname_de[512];
-    char longname_es[512];
+   char longname_it[512];
-    char longname_zhs[512];
+   char longname_es[512];
-    char longname_ko[512];
+   char longname_zhs[512];
-    char longname_nl[512];
+   char longname_ko[512];
-    char longname_pt[512];
+   char longname_nl[512];
-    char longname_ru[512];
+   char longname_pt[512];
-    char longname_zht[512];
+   char longname_ru[512];
-    char shortname_ja[256];
+   char longname_zht[512];
-    char shortname_en[256];
+   char shortname_ja[256];
-    char shortname_fr[256];
+   char shortname_en[256];
-    char shortname_de[256];
+   char shortname_fr[256];
-    char shortname_it[256];
+   char shortname_de[256];
-    char shortname_es[256];
+   char shortname_it[256];
-    char shortname_zhs[256];
+   char shortname_es[256];
-    char shortname_ko[256];
+   char shortname_zhs[256];
-    char shortname_nl[256];
+   char shortname_ko[256];
-    char shortname_pt[256];
+   char shortname_nl[256];
-    char shortname_ru[256];
+   char shortname_pt[256];
-    char shortname_zht[256];
+   char shortname_ru[256];
-    char publisher_ja[256];
+   char shortname_zht[256];
-    char publisher_en[256];
+   char publisher_ja[256];
-    char publisher_fr[256];
+   char publisher_en[256];
-    char publisher_de[256];
+   char publisher_fr[256];
-    char publisher_it[256];
+   char publisher_de[256];
-    char publisher_es[256];
+   char publisher_it[256];
-    char publisher_zhs[256];
+   char publisher_es[256];
-    char publisher_ko[256];
+   char publisher_zhs[256];
-    char publisher_nl[256];
+   char publisher_ko[256];
-    char publisher_pt[256];
+   char publisher_nl[256];
-    char publisher_ru[256];
+   char publisher_pt[256];
-    char publisher_zht[256];
+   char publisher_ru[256];
-    uint32_t add_on_unique_id[32];
+   char publisher_zht[256];
-    WUT_UNKNOWN_BYTES(52);
+   uint32_t add_on_unique_id[32];
+   WUT_UNKNOWN_BYTES(52);
 };
 WUT_CHECK_OFFSET(ACPMetaXml, 0x00, title_id);
 WUT_CHECK_OFFSET(ACPMetaXml, 0x08, boss_id);
@@ -235,13 +236,13 @@ WUT_CHECK_OFFSET(ACPMetaXml, 0x308C, publisher_pt);
 WUT_CHECK_OFFSET(ACPMetaXml, 0x318C, publisher_ru);
 WUT_CHECK_OFFSET(ACPMetaXml, 0x328C, publisher_zht);
 WUT_CHECK_OFFSET(ACPMetaXml, 0x338C, add_on_unique_id);
-WUT_CHECK_SIZE(ACPMetaXml,0x3440);
+WUT_CHECK_SIZE(ACPMetaXml, 0x3440);
 
 ACPResult
-ACPAssignTitlePatch(MCPTitleListType* titleInfo);
+ACPAssignTitlePatch(MCPTitleListType *titleInfo);
 
 ACPResult
-ACPGetTitleIdOfMainApplication(ACPTitleId* titleId);
+ACPGetTitleIdOfMainApplication(ACPTitleId *titleId);
 
 /**
  * Gets the MetaXML for a given title id
@@ -249,9 +250,11 @@ ACPGetTitleIdOfMainApplication(ACPTitleId* titleId);
  * @param metaXml must be aligned to 0x40
  * @return ACP_RESULT_SUCCESS on success
  */
+// clang-format off
 ACPResult
 RPLWRAP(ACPGetTitleMetaXml)(ACPTitleId titleId,
                             ACPMetaXml *metaXml);
+// clang-format on
 
 /**
  * Gets the MetaXML for a given title id
@@ -262,19 +265,56 @@ RPLWRAP(ACPGetTitleMetaXml)(ACPTitleId titleId,
  */
 static inline ACPResult
 ACPGetTitleMetaXml(ACPTitleId titleId,
-                   ACPMetaXml *metaXml) {
+                   ACPMetaXml *metaXml)
-   if ((uintptr_t) metaXml & 0x3F) {
+{
+   if ((uintptr_t)metaXml & 0x3F) {
       return ACP_RESULT_INVALID_PARAMETER;
    }
    return RPLWRAP(ACPGetTitleMetaXml)(titleId, metaXml);
 }
 
+// clang-format off
+ACPResult
+RPLWRAP(ACPGetTitleSaveMetaXml)(uint64_t titleId,
+                                ACPMetaXml* metaXml,
+                                ACPDeviceType deviceType);
+// clang-format on
+
+/**
+ * Gets the save dir MetaXML for a given title id
+ * @param titleId
+ * @param metaXml must be aligned to 0x40
+ * @param deviceType
+ * @return ACP_RESULT_SUCCESS on success,
+ *         ACP_RESULT_INVALID_PARAMETER if metaXml is not aligned properly
+ */
+static inline ACPResult
+ACPGetTitleSaveMetaXml(ACPTitleId titleId,
+                       ACPMetaXml *metaXml,
+                       ACPDeviceType deviceType)
+{
+   if ((uintptr_t)metaXml & 0x3F) {
+      return ACP_RESULT_INVALID_PARAMETER;
+   }
+   return RPLWRAP(ACPGetTitleSaveMetaXml)(titleId, metaXml, deviceType);
+}
+
+ACPResult
+ACPGetTitleMetaDir(ACPTitleId titleId,
+                   char *directory,
+                   size_t directoryLen);
+
 ACPResult
 ACPGetTitleMetaDirByDevice(ACPTitleId titleId,
-                           char* directory,
+                           char *directory,
                            size_t directoryLen,
                            ACPDeviceType deviceType);
 
+ACPResult
+ACPGetTitleMetaDirByTitleListType(MCPTitleListType titleListType,
+                                  char *directory,
+                                  size_t directoryLen);
+
 #ifdef __cplusplus
 }
 #endif

include/nn/act/client_cpp.h

@@ -1,7 +1,7 @@
 #pragma once
 #include <wut.h>
-#include <nn/result.h>
 #include <nn/ffl/miidata.h>
+#include <nn/result.h>
 
 /**
  * \defgroup nn_act_client Accounts Client API
@@ -12,25 +12,27 @@
 
 #ifdef __cplusplus
 
-namespace nn {
+namespace nn
+{
 
-namespace act {
+namespace act
+{
 
 //https://github.com/decaf-emu/decaf-emu/blob/master/src/libdecaf/src/nn/act/nn_act_types.h
 
-using ACTLoadOption = uint32_t;
+using ACTLoadOption                     = uint32_t;
-using SlotNo = uint8_t;
+using SlotNo                            = uint8_t;
-using LocalFriendCode = uint64_t;
+using LocalFriendCode                   = uint64_t;
-using PersistentId = uint32_t;
+using PersistentId                      = uint32_t;
-using PrincipalId = uint32_t;
+using PrincipalId                       = uint32_t;
-using SimpleAddressId = uint32_t;
+using SimpleAddressId                   = uint32_t;
-using TransferrableId = uint64_t;
+using TransferrableId                   = uint64_t;
 
-static constexpr size_t AccountIdSize = 17;
+static constexpr size_t AccountIdSize   = 17;
-static constexpr size_t DeviceHashSize = 8;
+static constexpr size_t DeviceHashSize  = 8;
 static constexpr size_t NfsPasswordSize = 17;
-static constexpr size_t MiiNameSize = 11;
+static constexpr size_t MiiNameSize     = 11;
-static constexpr size_t UuidSize = 16;
+static constexpr size_t UuidSize        = 16;
 
 //https://github.com/decaf-emu/decaf-emu/blob/master/src/libdecaf/src/cafe/libraries/nn_act/nn_act_client.cpp
 
@@ -53,11 +55,11 @@ GetAccountIdEx(char outAccountId[AccountIdSize], SlotNo slot)
    asm("GetAccountIdEx__Q2_2nn3actFPcUc");
 
 nn::Result
-GetBirthday(uint16_t* outYear, uint8_t* outMonth, uint8_t* outDay)
+GetBirthday(uint16_t *outYear, uint8_t *outMonth, uint8_t *outDay)
    asm("GetBirthday__Q2_2nn3actFPUsPUcT2");
 
 nn::Result
-GetBirthdayEx(uint16_t* outYear, uint8_t* outMonth, uint8_t* outDay, SlotNo slot)
+GetBirthdayEx(uint16_t *outYear, uint8_t *outMonth, uint8_t *outDay, SlotNo slot)
    asm("GetBirthdayEx__Q2_2nn3actFPUsPUcT2Uc");
 
 SlotNo
@@ -69,19 +71,19 @@ GetDeviceHash(char outHash[DeviceHashSize])
    asm("GetDeviceHash__Q2_2nn3actFPUL");
 
 nn::Result
-LoadConsoleAccount(SlotNo slot, ACTLoadOption unk1, char const * unk2, bool unk3)
+LoadConsoleAccount(SlotNo slot, ACTLoadOption unk1, char const *unk2, bool unk3)
    asm("LoadConsoleAccount__Q2_2nn3actFUc13ACTLoadOptionPCcb");
 
 nn::Result
-GetMii(FFLStoreData* mii)
+GetMii(FFLStoreData *mii)
    asm("GetMii__Q2_2nn3actFP12FFLStoreData");
 
 nn::Result
-GetMiiEx(FFLStoreData* mii, SlotNo slot)
+GetMiiEx(FFLStoreData *mii, SlotNo slot)
    asm("GetMiiEx__Q2_2nn3actFP12FFLStoreDataUc");
 
 nn::Result
-GetMiiImageEx(size_t* outImageSize, void* buffer, size_t bufferSize, int unk, SlotNo slot)
+GetMiiImageEx(size_t *outImageSize, void *buffer, size_t bufferSize, int unk, SlotNo slot)
    asm("GetMiiImageEx__Q2_2nn3actFPUiPvUi15ACTMiiImageTypeUc");
 
 nn::Result
@@ -125,7 +127,7 @@ GetPrincipalId(void)
    asm("GetPrincipalId__Q2_2nn3actFv");
 
 nn::Result
-GetPrincipalIdEx(PrincipalId* outId, SlotNo slot)
+GetPrincipalIdEx(PrincipalId *outId, SlotNo slot)
    asm("GetPrincipalIdEx__Q2_2nn3actFPUiUc");
 
 SimpleAddressId
@@ -133,7 +135,7 @@ GetSimpleAddressId(void)
    asm("GetSimpleAddressId__Q2_2nn3actFv");
 
 nn::Result
-GetSimpleAddressId(SimpleAddressId* outId, SlotNo slot)
+GetSimpleAddressId(SimpleAddressId *outId, SlotNo slot)
    asm("GetSimpleAddressIdEx__Q2_2nn3actFPUiUc");
 
 SlotNo
@@ -145,7 +147,7 @@ GetTransferableId(uint32_t unk1)
    asm("GetTransferableId__Q2_2nn3actFUi");
 
 nn::Result
-GetTransferableIdEx(TransferrableId* outId, uint32_t unk1, SlotNo slot)
+GetTransferableIdEx(TransferrableId *outId, uint32_t unk1, SlotNo slot)
    asm("GetTransferableIdEx__Q2_2nn3actFPULUiUc");
 
 nn::Result

include/nn/ccr/sys.h

@@ -1,5 +1,6 @@
 #pragma once
 #include <wut.h>
+#include <coreinit/time.h>
 
 /**
  * \defgroup nn_ccr_sys
@@ -12,16 +13,41 @@
 extern "C" {
 #endif
 
+typedef struct CCRSysUpdateState CCRSysUpdateState;
+
 typedef enum CCRSysPairingState
 {
-    //! Pairing is complete / hasn't started yet
+   //! Pairing is complete / hasn't started yet
-    CCR_SYS_PAIRING_FINISHED        = 0,
+   CCR_SYS_PAIRING_FINISHED    = 0,
-    //! Pairing is in progress
+   //! Pairing is in progress
-    CCR_SYS_PAIRING_IN_PROGRESS     = 1,
+   CCR_SYS_PAIRING_IN_PROGRESS = 1,
-    //! Pairing timed out
+   //! Pairing timed out
-    CCR_SYS_PAIRING_TIMED_OUT       = 2,
+   CCR_SYS_PAIRING_TIMED_OUT   = 2,
 } CCRSysPairingState;
 
+typedef enum CCRSysInitBootFlag
+{
+   CCR_SYS_BOOT_FLAG_NONE       = 0,
+   //! Shows "Turn on the TV and Wii U Console.." text on next DRC boot
+   CCR_SYS_BOOT_FLAG_FIRST_BOOT = 1,
+} CCRSysInitBootFlag;
+
+typedef enum CCRSysLCDMode
+{
+   CCR_SYS_LCD_MODE_BRIGHTNESS_1 = 1,
+   CCR_SYS_LCD_MODE_BRIGHTNESS_2 = 2,
+   CCR_SYS_LCD_MODE_BRIGHTNESS_3 = 3,
+   CCR_SYS_LCD_MODE_BRIGHTNESS_4 = 4,
+   CCR_SYS_LCD_MODE_BRIGHTNESS_5 = 5,
+} CCRSysLCDMode;
+
+struct CCRSysUpdateState
+{
+   uint32_t state;
+   //! Progress from 0-100
+   uint32_t progress;
+};
+
 void
 CCRSysInit(void);
 
@@ -105,6 +131,184 @@ CCRSysGetPairingState(void);
 int32_t
 CCRSysGetPincode(uint32_t *pin);
 
+/**
+ * Sets the DRH system time.
+ * 
+ * \param time
+ * The system time in ticks.
+ * 
+ * \return
+ * 0 on success.
+ */
+int32_t
+CCRSysSetSystemTime(OSTime time);
+
+/**
+ * Check if a DRC firmware update is needed.
+ * This function additionally verifies the DRC area compared to \link __CCRSysNeedsDRCFWUpdate \endlink.
+ * 
+ * \param drcSlot
+ * Slot from 0 to 1.
+ * 
+ * \param outNeedsUpdate
+ * Pointer to store the result to.
+ * 
+ * \return
+ * 0 on success.
+ */
+int32_t
+CCRSysNeedsDRCFWUpdate(uint32_t drcSlot,
+                       BOOL *outNeedsUpdate);
+
+/**
+ * Check if a DRC firmware update is needed.
+ * 
+ * \param drcSlot
+ * Slot from 0 to 1.
+ * 
+ * \param outNeedsUpdate
+ * Pointer to store the result to.
+ * 
+ * \param allowDowngrade
+ * Only check if the installed version doesn't match the running version,
+ * instead of checking that it's greater.
+ * 
+ * \return
+ * 0 on success.
+ */
+int32_t
+__CCRSysNeedsDRCFWUpdate(uint32_t drcSlot,
+                         BOOL *outNeedsUpdate,
+                         BOOL allowDowngrade);
+
+/**
+ * Starts a DRC firmware update if necessary and region matches.
+ * 
+ * \note
+ * This function will wait for \link CCRSysDRCFWUpdateForward \endlink to be called once done.
+ * See \link CCRSysGetUpdateState \endlink for status and progress.
+ * 
+ * \param drcSlot
+ * Slot from 0 to 1.
+ * 
+ * \return
+ * 0 on success.
+ */
+int32_t
+CCRSysDRCFWUpdate(uint32_t drcSlot);
+
+/**
+ * Starts a DRC firmware update if necessary.
+ * 
+ * \note
+ * This function will wait for \link CCRSysDRCFWUpdateForward \endlink to be called once done.
+ * See \link CCRSysGetUpdateState \endlink for status and progress.
+ * 
+ * \param drcSlot
+ * Slot from 0 to 1.
+ * 
+ * \param allowDowngrade
+ * Only check if the installed version doesn't match the running version,
+ * instead of checking that it's greater.
+ * There are additional checks on the IOS side and this doesn't actually allow downgrading the firmware.
+ * 
+ * \return
+ * 0 on success.
+ */
+int32_t
+__CCRSysDRCFWUpdate(uint32_t drcSlot,
+                    BOOL allowDowngrade);
+
+
+/**
+ * Finish a pending DRC firmware update.
+ */
+void
+CCRSysDRCFWUpdateForward(void);
+
+/**
+ * Get the update state during a pending DRC firmware update.
+ * 
+ * \param outUpdateState
+ * Pointer to store the state to.
+ */
+void
+CCRSysGetUpdateState(CCRSysUpdateState *outUpdateState);
+
+/**
+ * Initialize a DRC reattach.
+ * 
+ * \param drcSlot
+ * Slot from 0 to 1.
+ */
+void
+__CCRSysInitReattach(uint32_t drcSlot);
+
+/**
+ * Wait for the DRC to reattach.
+ * This returns once the DRC disconnects and reconnects or a timeout is reached.
+ * 
+ * \param drcSlot
+ * Slot from 0 to 1.
+ * 
+ * \return
+ * 0 on success.
+ */
+int32_t
+__CCRSysWaitReattach(uint32_t drcSlot,
+                     BOOL unknown);
+
+/**
+ * Get the version check flag.
+ * 
+ * \param outFlag
+ * Pointer to write the flag to.
+ * 
+ * \return
+ * 0 on success.
+ */
+int32_t
+CCRSysGetVersionCheckFlag(uint32_t *outFlag);
+
+/**
+ * Set the version check flag.
+ * 
+ * \param outFlag
+ * The flag to set.
+ * 
+ * \return
+ * 0 on success.
+ */
+int32_t
+CCRSysSetVersionCheckFlag(uint32_t flag);
+
+int32_t
+CCRSysCaffeineSetCaffeineSlot(uint32_t slot);
+
+int32_t
+CCRSysSetInitBootFlag(CCRSysInitBootFlag flag);
+
+/**
+ * Resets the DRC (It'll show "Turn on the TV and Wii U console" until paired)
+ * @return 0 on success, -1 on error.
+ */
+int32_t
+CCRSysInitializeSettings();
+
+/**
+ * Sets the brightness of the DRC.
+ * @return 0 on success, -1 on error.
+ */
+int32_t
+CCRSysSetCurrentLCDMode(CCRSysLCDMode mode);
+
+/**
+ * Gets the brightness of the DRC.
+ * @return 0 on success, -1 on error.
+ */
+int32_t
+CCRSysGetCurrentLCDMode(CCRSysLCDMode *mode);
+
 #ifdef __cplusplus
 }
 #endif

include/nn/ccr/sys_caffeine.h

@@ -16,20 +16,35 @@ typedef struct CCRAppLaunchParam CCRAppLaunchParam;
 
 struct WUT_PACKED CCRAppLaunchParam
 {
-    uint64_t titleId;
+   uint64_t launchInfoDatabaseEntryId; // id used in the \link nn::sl::LaunchInfoDatabase
-    char uuid[16];
+   char uuid[16];                      // account uuid
-    WUT_UNKNOWN_BYTES(0xE7);
+   WUT_UNKNOWN_BYTES(0xE7);
 };
-WUT_CHECK_OFFSET(CCRAppLaunchParam, 0x00, titleId);
+WUT_CHECK_OFFSET(CCRAppLaunchParam, 0x00, launchInfoDatabaseEntryId);
 WUT_CHECK_OFFSET(CCRAppLaunchParam, 0x08, uuid);
 WUT_CHECK_SIZE(CCRAppLaunchParam, 0xFF);
 
 void
-CCRSysCaffeineGetAppLaunchParam(CCRAppLaunchParam * data);
+CCRSysCaffeineGetAppLaunchParam(CCRAppLaunchParam *data);
 
 uint32_t
 CCRSysCaffeineBootCheck();
 
+void
+CCRSysCaffeineBootCheckAbort();
+
+/**
+ * @return 0 on success, -1 on error
+ */
+int32_t
+CCRSysCaffeineSetDRCEnableFlag(int32_t enabled);
+
+/**
+ * @return 0 on success, -1 on error
+ */
+int32_t
+CCRSysCaffeineSetEnableFlag(int32_t enabled);
+
 #ifdef __cplusplus
 }
 #endif

include/nn/cfg/CTR.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <wut.h>
+
+#ifdef __cplusplus
+
+namespace nn
+{
+
+namespace cfg
+{
+
+namespace CTR
+{
+
+//! Represents a console username, used in UDS and DLP
+struct UserName
+{
+   char16_t name[12];
+};
+WUT_CHECK_SIZE(UserName, 0x18);
+
+} // namespace CTR
+
+} // namespace cfg
+
+} // namespace nn
+
+#endif

include/nn/cmpt/cmpt.h

@@ -12,10 +12,11 @@
 extern "C" {
 #endif
 
-typedef enum CmptScreenType {
+typedef enum CmptScreenType
-    CMPT_SCREEN_TYPE_TV = 1,
+{
-    CMPT_SCREEN_TYPE_DRC,
+   CMPT_SCREEN_TYPE_TV = 1,
-    CMPT_SCREEN_TYPE_BOTH,
+   CMPT_SCREEN_TYPE_DRC,
+   CMPT_SCREEN_TYPE_BOTH,
 } CmptScreenType;
 
 /**
@@ -26,7 +27,7 @@ typedef enum CmptScreenType {
  * 0 on success.
  */
 int32_t
-CMPTGetDataSize(uint32_t* outSize);
+CMPTGetDataSize(uint32_t *outSize);
 
 /**
  * Launches the specified vWii title.
@@ -35,7 +36,7 @@ CMPTGetDataSize(uint32_t* outSize);
  * 0 on success.
  */
 int32_t
-CMPTLaunchTitle(void* dataBuffer, uint32_t bufferSize, uint64_t titleId);
+CMPTLaunchTitle(void *dataBuffer, uint32_t bufferSize, uint64_t titleId);
 
 /**
  * Launches vWii System Menu.
@@ -44,7 +45,7 @@ CMPTLaunchTitle(void* dataBuffer, uint32_t bufferSize, uint64_t titleId);
  * 0 on success.
  */
 int32_t
-CMPTLaunchMenu(void* dataBuffer, uint32_t bufferSize);
+CMPTLaunchMenu(void *dataBuffer, uint32_t bufferSize);
 
 /**
  * Launches vWii Data Management.
@@ -53,7 +54,7 @@ CMPTLaunchMenu(void* dataBuffer, uint32_t bufferSize);
  * 0 on success.
  */
 int32_t
-CMPTLaunchDataManager(void* dataBuffer, uint32_t bufferSize);
+CMPTLaunchDataManager(void *dataBuffer, uint32_t bufferSize);
 
 /**
  * Sets the screen type.

include/nn/dlp.h

@@ -0,0 +1,8 @@
+#pragma once
+
+/**
+ * \defgroup nn_dlp nn_dlp
+ * Download Play functions
+ */
+
+#include <nn/dlp/Cafe.h>

include/nn/dlp/Cafe.h

@@ -0,0 +1,359 @@
+#pragma once
+
+#include <wut.h>
+#include <nn/cfg/CTR.h>
+#include <nn/result.h>
+#include <nn/uds/NodeInformation.h>
+
+/**
+ * \defgroup nn_dlp nn_dlp
+ * \ingroup nn_dlp
+ * Download Play functions (see \link nn::dlp \endlink)
+ * @{
+ */
+
+#ifdef __cplusplus
+
+namespace nn
+{
+
+namespace dlp
+{
+
+namespace Cafe
+{
+enum PollStateChangeFlags : uint8_t
+{
+   //! Prevents \c PollStateChange from blocking if no new data is available
+   DLP_POLL_NONBLOCK = 1 << 0,
+};
+WUT_CHECK_SIZE(PollStateChangeFlags, 0x1);
+
+//! Represents the client state
+enum class ClientState : uint32_t
+{
+   //! The client is accepted for the DLP child distribution
+   Accepted   = 5,
+   //! The client is receiving the distributed DLP child
+   Receiving  = 6,
+   //! The client has received the distribution and is ready to boot the DLP child
+   Ready      = 7,
+   //! The client is connected to the session and pending to be accepted
+   Connecting = 64
+};
+WUT_CHECK_SIZE(ClientState, 0x4);
+
+//! Represents the server state. All values between 3 and 7 are considered internal state
+enum class ServerState : uint32_t
+{
+   //! The server is not initialized
+   Uninitialized        = 0,
+   //! The server is initialized but there is no active network
+   Idle                 = 1,
+   //! The server is open to new connections
+   Open                 = 2,
+   //! The server is distributing the DLP child to the clients
+   DistributingInternal = 7,
+   //! The server has distributed the DLP child
+   Distributed          = 8,
+   //! The server has finished distribution and clients are booted into the DLP child
+   Finished             = 9,
+   //! The server failed to distribute the DLP child to the clients
+   Failed               = 10,
+   //! Public value for internal states
+   Distributing         = 11
+};
+WUT_CHECK_SIZE(ServerState, 0x4);
+
+class Server
+{
+public:
+   /**
+     * Accepts a client into the DLP child distribution.
+     *
+     * \param nodeId
+     * The node ID of the client.
+     */
+   static nn::Result
+   AcceptClient(uint16_t nodeId)
+      asm("AcceptClient__Q4_2nn3dlp4Cafe6ServerSFUs");
+
+   /**
+     * Closes the DLP session.
+     */
+   static nn::Result
+   CloseSessions()
+      asm("CloseSessions__Q4_2nn3dlp4Cafe6ServerSFv");
+
+   /**
+     * Disconnects a client from the DLP session. This cannot be done after starting distribution.
+     *
+     * \param nodeId
+     * The node ID of the client.
+     */
+   static nn::Result
+   DisconnectClient(uint16_t nodeId)
+      asm("DisconnectClient__Q4_2nn3dlp4Cafe6ServerSFUs");
+
+   /**
+     * Finalizes DLP.
+     */
+   static nn::Result
+   Finalize()
+      asm("Finalize__Q4_2nn3dlp4Cafe6ServerSFv");
+
+   /**
+     * Gets information about a client.
+     *
+     * \param clientInfo
+     * Pointer where the client information is written.
+     *
+     * \param nodeId
+     * Node ID of the client.
+     */
+   static nn::Result
+   GetClientInfo(nn::uds::Cafe::NodeInformation *clientInfo, uint16_t nodeId)
+      asm("GetClientInfo__Q4_2nn3dlp4Cafe6ServerSFPQ4_2nn3uds4Cafe15NodeInformationUs");
+
+   /**
+     * Gets a client state.
+     *
+     * \param state
+     * Pointer where the client state is filled in.
+     *
+     * \param nodeId
+     * Node ID of the client.
+     */
+   static nn::Result
+   GetClientState(ClientState *state, uint16_t nodeId)
+      asm("GetClientState__Q4_2nn3dlp4Cafe6ServerSFPQ4_2nn3dlp4Cafe11ClientStateUs");
+
+   /**
+     * Gets a client state.
+     *
+     * \param state
+     * Pointer where the client state is filled in.
+     *
+     * \param unitsTotal
+     * Pointer filled with the total number of units being distributed.
+     * Only filled when starting distribution and the DLP child isn't cached.
+     *
+     * \param unitsReceived
+     * Pointer filled with the number of units that the client has received.
+     * Only filled when starting distribution and the DLP child isn't cached.
+     *
+     * \param nodeId
+     * Node ID of the client.
+     */
+   static nn::Result
+   GetClientState(ClientState *state,
+                  uint32_t *unitsTotal,
+                  uint32_t *unitsReceived,
+                  uint16_t nodeId)
+      asm("GetClientState__Q4_2nn3dlp4Cafe6ServerSFPQ4_2nn3dlp4Cafe11ClientStatePUiT2Us");
+
+   /**
+     * Gets the clients that are connected to the DLP session.
+     *
+     * \param receivedLength
+     * Pointer where the number of clients written to the array is stored.
+     *
+     * \param connectingClients
+     * Array where the node IDs of the clients are written.
+     *
+     * \param length
+     * Number of nodes that the \c connectingClients array can hold.
+     */
+   static nn::Result
+   GetConnectingClients(uint16_t *receivedLength,
+                        uint16_t *connectingClients,
+                        uint16_t length)
+      asm("GetConnectingClients__Q4_2nn3dlp4Cafe6ServerSFPUsT1Us");
+
+   /**
+     * Gets the server state. Internal states are filtered as \link Distributing \endlink .
+     *
+     * \param state
+     * Pointer where the server state is written.
+     */
+   static nn::Result
+   GetState(ServerState *state)
+      asm("GetState__Q4_2nn3dlp4Cafe6ServerSFPQ4_2nn3dlp4Cafe11ServerState");
+
+   /**
+     * Initializes DLP.
+     *
+     * \param maxClientNum
+     * Maximum number of clients allowed for distribution. Must be between 1 and 8 inclusively.
+     *
+     * \param uniqueId
+     * Unique ID of the DLP child to be distributed.
+     *
+     * \param childIndex
+     * Index of the DLP child to be distributed.
+     *
+     * \param userName
+     * Username that will be displayed to the clients. If \c NULL, the Mii name will be used.
+     */
+   static nn::Result
+   Initialize(uint8_t maxClientNum,
+              uint32_t uniqueId,
+              uint8_t childIndex,
+              nn::cfg::CTR::UserName *userName)
+      asm("Initialize__Q4_2nn3dlp4Cafe6ServerSFUcUiT1PQ4_2nn3cfg3CTR8UserName");
+
+   /**
+     * Initializes DLP.
+     *
+     * \param dupNoticeNeed
+     * Unknown output bool, always false on the Wii U.
+     *
+     * \param maxClientNum
+     * Maximum number of clients allowed for distribution. Must be between 1 and 8 inclusively.
+     *
+     * \param uniqueId
+     * Unique ID of the DLP child to be distributed.
+     *
+     * \param childIndex
+     * Index of the DLP child to be distributed.
+     *
+     * \param userName
+     * Username that will be displayed to the clients. If \c NULL, the Mii name will be used.
+     */
+   static nn::Result
+   Initialize(bool *dupNoticeNeed,
+              uint8_t maxClientNum,
+              uint32_t uniqueId,
+              uint8_t childIndex,
+              nn::cfg::CTR::UserName *userName)
+      asm("Initialize__Q4_2nn3dlp4Cafe6ServerSFPbUcUiT2PQ4_2nn3cfg3CTR8UserName");
+
+   /**
+     * Opens the DLP session.
+     *
+     * \param isManualAccept
+     * If set, all clients must be accepted to allow them to join the session.
+     *
+     * \param channel
+     * The channel to be used for hosting the session. Use 0 to choose a channel automatically.
+     * Must be either 0, 1, 6 or 11.
+     */
+   static nn::Result
+   OpenSessions(bool isManualAccept, uint8_t channel)
+      asm("OpenSessions__Q4_2nn3dlp4Cafe6ServerSFbUc");
+
+   /**
+     * Checks if the server state chas changed, and waits until it changes if specified.
+     *
+     * \param flags
+     * Flags, see \link PollStateChangeFlags \endlink for all flags.
+     */
+   static nn::Result
+   PollStateChange(uint8_t flags)
+      asm("PollStateChange__Q4_2nn3dlp4Cafe6ServerSFUc");
+
+   /**
+     * Reboots all clients into the Download Play child.
+     *
+     * \param passPhrase
+     * Passphrase to be used by the client when connecting to the main UDS network.
+     * If \c NULL, it will be set to an empty string.
+     */
+   static nn::Result
+   RebootAllClients(const char *passPhrase)
+      asm("RebootAllClients__Q4_2nn3dlp4Cafe6ServerSFPCc");
+
+   /**
+     * Starts distribution of the Download Play child.
+     */
+   static nn::Result
+   StartDistribution()
+      asm("StartDistribute__Q4_2nn3dlp4Cafe6ServerSFv");
+};
+
+class ServerPrivate
+{
+public:
+   /**
+     * Gets the server state. Internal states are not filtered.
+     *
+     * \param state
+     * Pointer where the server state is written.
+     */
+   static nn::Result
+   GetInternalState(ServerState *state)
+      asm("GetInternalState__Q4_2nn3dlp4Cafe13ServerPrivateSFPQ4_2nn3dlp4Cafe11ServerState");
+
+   /**
+     * Initializes DLP.
+     *
+     * \param maxClientNum
+     * Maximum number of clients allowed for distribution. Must be between 1 and 8 inclusively.
+     *
+     * \param uniqueId
+     * Unique ID of the DLP child to be distributed.
+     *
+     * \param childIndex
+     * Index of the DLP child to be distributed.
+     *
+     * \param blockBufferSize
+     * Unknown parameter (default: 0xC000). Must be bigger than 0x4000 and smaller than 0x80000 inclusively.
+     *
+     * \param blockBufferNum
+     * Unknown parameter (default: 2). Must be a number between 2 and 4 inclusively.
+     *
+     * \param userName
+     * Username that will be displayed to the clients. If \c NULL, the Mii name will be used.
+     */
+   static nn::Result
+   Initialize(uint8_t maxClientNum,
+              uint32_t uniqueId,
+              uint8_t childIndex,
+              uint32_t blockBufferSize,
+              uint32_t blockBufferNum,
+              nn::cfg::CTR::UserName *userName)
+      asm("Initialize__Q4_2nn3dlp4Cafe13ServerPrivateSFUcUiT1N22PQ4_2nn3cfg3CTR8UserName");
+
+   /**
+     * Initializes DLP.
+     *
+     * \param dupNoticeNeed
+     * Unknown output bool, always false on the Wii U.
+     *
+     * \param maxClientNum
+     * Maximum number of clients allowed for distribution. Must be between 1 and 8 inclusively.
+     *
+     * \param uniqueId
+     * Unique ID of the DLP child to be distributed.
+     *
+     * \param childIndex
+     * Index of the DLP child to be distributed.
+     *
+     * \param blockBufferSize
+     * Unknown parameter (default: 0xC000). Must be bigger than 0x4000 and smaller than 0x80000 inclusively.
+     *
+     * \param blockBufferNum
+     * Unknown parameter (default: 2). Must be a number between 2 and 4 inclusively.
+     *
+     * \param userName
+     * Username that will be displayed to the clients. If \c NULL, the Mii name will be used.
+     */
+   static nn::Result
+   Initialize(bool *dupNoticeNeed,
+              uint8_t maxClientNum,
+              uint32_t uniqueId,
+              uint8_t childIndex,
+              uint32_t blockBufferSize,
+              uint32_t blockBufferNum,
+              nn::cfg::CTR::UserName *userName)
+      asm("Initialize__Q4_2nn3dlp4Cafe13ServerPrivateSFPbUcUiT2N23PQ4_2nn3cfg3CTR8UserName");
+};
+} // namespace Cafe
+
+} // namespace dlp
+
+} // namespace nn
+
+/** @} */
+
+#endif

include/nn/erreula/erreula_cpp.h

@@ -3,8 +3,8 @@
 #include <coreinit/filesystem.h>
 #include <nn/result.h>
 #include <padscore/kpad.h>
-#include <vpad/input.h>
 #include <string.h>
+#include <vpad/input.h>
 
 /**
  * \defgroup nn_erreula_erreula Error Viewer
@@ -24,44 +24,54 @@ namespace erreula
 
 enum class ControllerType
 {
-   WiiRemote0        = 0,
+   WiiRemote0 = 0,
-   WiiRemote1        = 1,
+   WiiRemote1 = 1,
-   WiiRemote2        = 2,
+   WiiRemote2 = 2,
-   WiiRemote3        = 3,
+   WiiRemote3 = 3,
-   DrcGamepad        = 4,
+   DrcGamepad = 4,
 };
 
 enum class ErrorType
 {
-   Code              = 0,
+   Code           = 0,
-   Message           = 1,
+   Message        = 1,
-   Message1Button    = 2,
+   Message1Button = 2,
-   Message2Button    = 3,
+   Message2Button = 3,
 };
 
 enum class LangType
 {
-   Japanese          = 0,
+   Japanese           = 0,
-   English           = 1,
+   English            = 1,
-   // TODO: More languages
+   French             = 2,
+   German             = 3,
+   Italian            = 4,
+   Spanish            = 5,
+   SimplifiedChinese  = 6,
+   Korean             = 7,
+   Dutch              = 8,
+   Portuguese         = 9,
+   Russian            = 10,
+   TraditionalChinese = 11,
+   Invalid            = 12,
 };
 
 enum class RegionType
 {
-   Japan             = 0,
+   Japan  = 0,
-   USA               = 1,
+   USA    = 1,
-   Europe            = 2,
+   Europe = 2,
-   China             = 3,
+   China  = 3,
-   Korea             = 4,
+   Korea  = 4,
-   Taiwan            = 5,
+   Taiwan = 5,
 };
 
 enum class ResultType
 {
-   None              = 0,
+   None   = 0,
 
    //! The user exited the error viewer
-   Exited            = 1,
+   Exited = 1,
 
    // TODO: More result types
 };
@@ -69,28 +79,28 @@ enum class ResultType
 enum class RenderTarget
 {
    //! Render only to TV
-   Tv                = 0,
+   Tv   = 0,
 
    //! Render only to DRC gamepad
-   Drc               = 1,
+   Drc  = 1,
 
    //! Render to both TV and Gamepad
-   Both              = 2,
+   Both = 2,
 };
 
 enum class State
 {
    //! The error viewer is completely hidden.
-   Hidden            = 0,
+   Hidden  = 0,
 
    //! The error viewer is drawing the fade-in animation.
-   FadeIn            = 1,
+   FadeIn  = 1,
 
    //! The error viewer is done drawing the fade in animation and completely visible.
-   Visible           = 2,
+   Visible = 2,
 
    //! The error viewer is drawing the fade-out animation.
-   FadeOut           = 3,
+   FadeOut = 3,
 };
 
 struct ErrorArg

include/nn/ffl/miidata.h

@@ -14,13 +14,15 @@ extern "C" {
 
 // https://github.com/decaf-emu/decaf-emu/blob/master/src/libdecaf/src/nn/ffl/nn_ffl_miidata.h
 
-typedef enum FFLCreateIDFlags {
+typedef enum FFLCreateIDFlags
-   FFL_CREATE_ID_FLAG_WII_U    = 0x1 | 0x4,
+{
+   FFL_CREATE_ID_FLAG_WII_U     = 0x1 | 0x4,
    FFL_CREATE_ID_FLAG_TEMPORARY = 0x2,
-   FFL_CREATE_ID_FLAG_NORMAL   = 0x8,
+   FFL_CREATE_ID_FLAG_NORMAL    = 0x8,
 } FFLCreateIDFlags;
 
-typedef struct WUT_PACKED FFLCreateID {
+typedef struct WUT_PACKED FFLCreateID
+{
    FFLCreateIDFlags flags : 4;
 
    uint32_t timestamp : 28;
@@ -31,7 +33,8 @@ WUT_CHECK_OFFSET(FFLCreateID, 4, deviceHash);
 WUT_CHECK_SIZE(FFLCreateID, 10);
 
 //Note: the endian may be wrong here
-typedef struct WUT_PACKED FFLiMiiDataCore {
+typedef struct WUT_PACKED FFLiMiiDataCore
+{
    // 0x00
    uint8_t birth_platform : 4;
    uint8_t unk_0x00_b4 : 4;
@@ -150,14 +153,16 @@ WUT_CHECK_OFFSET(FFLiMiiDataCore, 0x2F, fatness);
 WUT_CHECK_OFFSET(FFLiMiiDataCore, 0x33, hair_type);
 WUT_CHECK_SIZE(FFLiMiiDataCore, 0x48);
 
-typedef struct WUT_PACKED FFLiMiiDataOfficial {
+typedef struct WUT_PACKED FFLiMiiDataOfficial
+{
    FFLiMiiDataCore core;
    uint16_t creator_name[10];
 } FFLiMiiDataOfficial;
 WUT_CHECK_OFFSET(FFLiMiiDataOfficial, 0x48, creator_name);
 WUT_CHECK_SIZE(FFLiMiiDataOfficial, 0x5C);
 
-typedef struct WUT_PACKED FFLStoreData {
+typedef struct WUT_PACKED FFLStoreData
+{
    FFLiMiiDataOfficial data;
    uint16_t unk_0x5C;
    uint16_t checksum;