i2c: correct missing destruction

* sdmmc: begin skeletoning sdmmc driver

* sdmmc: add most of SdHostStandardController

* sdmmc: implement most of SdmmcController

* sdmmc: Sdmmc2Controller

* sdmmc: skeleton implementation of Sdmmc1Controller

* sdmmc: complete abstract logic for Sdmmc1 power controller

* sdmmc: implement gpio handling for sdmmc1-register-control

* sdmmc: implement pinmux handling for sdmmc1-register-control

* sdmmc: fix building for arm32 and in stratosphere context

* sdmmc: implement voltage enable/set for sdmmc1-register-control

* util: move T(V)SNPrintf from kernel to util

* sdmmc: implement BaseDeviceAccessor

* sdmmc: implement MmcDeviceAccessor

* sdmmc: implement clock reset controller for register api

* sdmmc: fix bug in WaitWhileCommandInhibit, add mmc accessors

* exo: add sdmmc test program

* sdmmc: fix speed mode extension, add CheckMmcConnection for debug

* sdmmc: add DeviceDetector, gpio: implement client api

* gpio: modernize client api instead of doing it the lazy way

* sdmmc: SdCardDeviceAccessor impl

* sdmmc: update test program to read first two sectors of sd card

* sdmmc: fix vref sel

* sdmmc: finish outward-facing api (untested)

* ams: changes for libvapours including tegra register defs

* sdmmc: remove hwinit

Makefile

@@ -70,8 +70,8 @@ dist-no-debug: all
 	mkdir -p atmosphere-$(AMSVER)/atmosphere/config
 	cp fusee/fusee-primary/fusee-primary.bin atmosphere-$(AMSVER)/atmosphere/reboot_payload.bin
 	cp fusee/fusee-mtc/fusee-mtc.bin atmosphere-$(AMSVER)/atmosphere/fusee-mtc.bin
-	cp fusee/fusee-secondary/fusee-secondary.bin atmosphere-$(AMSVER)/atmosphere/fusee-secondary.bin
-	cp fusee/fusee-secondary/fusee-secondary.bin atmosphere-$(AMSVER)/sept/payload.bin
+	cp fusee/fusee-secondary/fusee-secondary-experimental.bin atmosphere-$(AMSVER)/atmosphere/fusee-secondary.bin
+	cp fusee/fusee-secondary/fusee-secondary-experimental.bin atmosphere-$(AMSVER)/sept/payload.bin
 	cp sept/sept-primary/sept-primary.bin atmosphere-$(AMSVER)/sept/sept-primary.bin
 	cp sept/sept-secondary/sept-secondary.bin atmosphere-$(AMSVER)/sept/sept-secondary.bin
 	cp sept/sept-secondary/sept-secondary_00.enc atmosphere-$(AMSVER)/sept/sept-secondary_00.enc
@@ -99,9 +99,13 @@ dist-no-debug: all
 	touch atmosphere-$(AMSVER)/atmosphere/contents/0100000000000037/flags/boot2.flag
 	cp troposphere/reboot_to_payload/reboot_to_payload.nro atmosphere-$(AMSVER)/switch/reboot_to_payload.nro
 	cp troposphere/daybreak/daybreak.nro atmosphere-$(AMSVER)/switch/daybreak.nro
+	cd atmosphere-$(AMSVER); zip -r ../atmosphere-EXPERIMENTAL-$(AMSVER).zip ./*; cd ../;
+	cp fusee/fusee-secondary/fusee-secondary.bin atmosphere-$(AMSVER)/atmosphere/fusee-secondary.bin
+	cp fusee/fusee-secondary/fusee-secondary.bin atmosphere-$(AMSVER)/sept/payload.bin
 	cd atmosphere-$(AMSVER); zip -r ../atmosphere-$(AMSVER).zip ./*; cd ../;
 	rm -r atmosphere-$(AMSVER)
 	mkdir out
+	mv atmosphere-EXPERIMENTAL-$(AMSVER).zip out/atmosphere-EXPERIMENTAL-$(AMSVER).zip
 	mv atmosphere-$(AMSVER).zip out/atmosphere-$(AMSVER).zip
 	cp fusee/fusee-primary/fusee-primary.bin out/fusee-primary.bin
 
@@ -120,7 +124,7 @@ dist: dist-no-debug
 	mkdir atmosphere-$(AMSVER)-debug
 	cp fusee/fusee-primary/fusee-primary.elf atmosphere-$(AMSVER)-debug/fusee-primary.elf
 	cp fusee/fusee-mtc/fusee-mtc.elf atmosphere-$(AMSVER)-debug/fusee-mtc.elf
-	cp fusee/fusee-secondary/fusee-secondary.elf atmosphere-$(AMSVER)-debug/fusee-secondary.elf
+	cp fusee/fusee-secondary/fusee-secondary-experimental.elf atmosphere-$(AMSVER)-debug/fusee-secondary.elf
 	cp sept/sept-primary/sept-primary.elf atmosphere-$(AMSVER)-debug/sept-primary.elf
 	cp sept/sept-secondary/sept-secondary.elf atmosphere-$(AMSVER)-debug/sept-secondary.elf
 	cp sept/sept-secondary/key_derivation/key_derivation.elf atmosphere-$(AMSVER)-debug/sept-secondary-key-derivation.elf

config_templates/BCT.ini

@@ -9,4 +9,4 @@ stage2_entrypoint = 0xF0000000
 ; To force-enable nogc, add nogc = 1
 ; To force-disable nogc, add nogc = 0
 
-; To opt in to using Atmosphere's NCM reimplementation, add enable_ncm = 1
+; To opt out of using Atmosphere's NCM reimplementation, add disable_ncm = 1

docs/building.md

@@ -4,7 +4,7 @@ Building Atmosphère is a very straightforward process that relies almost exclus
 ## Dependencies
 + [devkitA64](https://devkitpro.org)
 + [devkitARM](https://devkitpro.org)
-+ [Python 2 or 3](https://www.python.org) (optional)
++ [Python 2](https://www.python.org) (Python 3 may work as well, but this is not guaranteed)
 + [PyCryptodome](https://pypi.org/project/pycryptodome) (optional)
 
 ## Instructions

docs/changelog.md

@@ -1,4 +1,31 @@
 # Changelog
+## 0.15.0
++ fusee-primary's panic display was updated to automatically identify and give suggestions to resolve many of the most common errors users encounter.
++ Having been tested as well as I can alone, `mesosphere` (atmosphère's reimplementation of the Nintendo Switch kernel) is now available for users interested in trying it.
+  + Beginning in this release and until it is stable and well-tested, atmosphère will distribute two zips.
+    + Users who wish to opt-in to mesosphere should download and extract the "cool kids" zip ("atmosphere-EXPERIMENTAL-").
+    + Users who do not wish to use mesosphere should continue using the normal zip ("atmosphere-").
+  + Users may detect whether mesosphere is active in system settings.
+    + When mesosphere is active, the system version string will display "M.15.0" rather than "0.15.0", and so on for future releases.
+    + Crash reports and the like will contain information on whether or not the user is using mesosphere, as well.
+  + There are "probably" no material user-facing benefits to using mesosphere at this time.
+    + Developers may be interested in the fact that mesosphere provides many newer SVC APIs even when on lower firmware versions.
+    + The primary benefit to using mesosphere is that any issues you may encounter and report to me will be fixed.
+      + All users who choose to opt in to using mesosphere have my deepest gratitude.
+  + **Note:** If using hekate instead of fusee-primary, you will have to wait for the next hekate release for mesosphere to function, as hekate's support has not yet been included in an official release build.
+    + This will be updated in the release notes when hekate provides a new release.
+  + As mentioned in previous release notes, when mesosphere is stable and well-tested, it will be enabled by default and atmosphère's version will transition to 1.0.0.
++ Having been tested sufficiently over the last half-year, Atmosphere's NCM implementation is now opt-out, rather than opt in.
+  + In the unlikely event that any issues are encountered, please report them to @SciresM.
+  + Users interested in opting out of using our implementation should set `stratosphere!disable_ncm = 1` in BCT.ini.
+  + The NCM implementation will stop being opt-out in a future update, probably around the same time that mesosphere becomes opt-out instead of opt-in.
++ Several bugs were fixed, including:
+  + Loader now sets HBL's thread priority to a higher value when loading it in applet mode.
+    + This fixes an extremely-slow launch ("hang") when using applet-HBL with certain games that do not suspend while inactive (e.g. Super Mario Sunshine).
+  + set.mitm now caches user language configuration much more heavily.
+    + This severely reduces lag in certain games which misuse the "nn::oe::GetDesiredLanguage()" API.
+  + A bug was fixed that could cause erpt to fatal when loading an official save file that had error report attachments in it.
++ General system stability improvements to enhance the user's experience.
 ## 0.14.4
 + Several bugs were fixed involving the official jit sysmodule added in 10.0.0.
   + A Process handle leak was fixed when JitPlugin NRRs were registered with the `ro` sysmodule.

docs/features/configurations.md

@@ -9,7 +9,7 @@ This file is located under the `/atmosphere/config/` folder on your SD card and
 Atmosphère provides its own default splashscreen which is displayed at boot time. However, this can be replaced at will.
 
 The boot splashscreen must be a BMP file, it must be 720x1280 (1280x720 rotated 90 degrees left/counterclockwise/anti-clockwise) resolution, and be in 32-bit ARGB format. You can use image editing software such as GIMP or Photoshop to export the image in this format.
- 
+
 Add the following lines to BCT.ini and change the value of `custom_splash` to the actual path and filename of your boot splashscreen:
 ```
 [stage2]
@@ -29,11 +29,11 @@ nogc = X
 0 = force-disable nogc, so Atmosphère will always enable the Game Card reader.
 ```
 
-### NCM opt-in
-Atmosphère provides a reimplementation of the [ncm](../components/modules/ncm.md) system module, but currently this is not enabled by default. If you wish to enable this reimplementation add the following line to the `stratosphere` section:
+### NCM opt-out
+Atmosphère provides a reimplementation of the [ncm](../components/modules/ncm.md) system module. If you wish to disable this reimplementation add the following line to the `stratosphere` section:
 ```
 [stratosphere]
-enable_ncm = 1
+disable_ncm = 1
 ```
 
 ### Logging

exosphere/program/source/secmon_map.cpp

@@ -96,10 +96,6 @@ namespace ams::secmon {
             util::ClearMemory(reinterpret_cast<void *>(address + size / 2), size / 2);
         }
 
-        bool IsPhysicalMemoryAddress(uintptr_t address) {
-            return (address - MemoryRegionDram.GetAddress()) < GetPhysicalMemorySize();
-        }
-
     }
 
     void ClearBootCodeHigh() {
@@ -130,6 +126,10 @@ namespace ams::secmon {
         }
     }
 
+    bool IsPhysicalMemoryAddress(uintptr_t address) {
+        return (address - MemoryRegionDram.GetAddress()) < GetPhysicalMemorySize();
+    }
+
     void UnmapTzram() {
         /* Get the tables. */
         u64 * const l1    = MemoryRegionVirtualTzramL1PageTable.GetPointer<u64>();

exosphere/program/source/secmon_map.hpp

@@ -18,6 +18,7 @@
 
 namespace ams::secmon {
 
+    bool IsPhysicalMemoryAddress(uintptr_t address);
     size_t GetPhysicalMemorySize();
 
     void UnmapTzram();

exosphere/program/source/secmon_setup.cpp

@@ -648,7 +648,7 @@ namespace ams::secmon {
             reg::Read (MC + MC_SMMU_TLB_CONFIG);
 
             /* Flush the entire page table cache, and read TLB_CONFIG to ensure the flush takes. */
-            reg::Write(MC + MC_SMMU_PTC_FLUSH, 0);
+            reg::Write(MC + MC_SMMU_PTC_FLUSH_0, 0);
             reg::Read (MC + MC_SMMU_TLB_CONFIG);
 
             /* Flush the entire translation lookaside buffer, and read TLB_CONFIG to ensure the flush takes. */
@@ -907,7 +907,7 @@ namespace ams::secmon {
             reg::Write(MC + MC_SMMU_PPCS1_ASID, MC_REG_BITS_ENUM(SMMU_PPCS1_ASID_PPCS1_SMMU_ENABLE, ENABLE), MC_REG_BITS_VALUE(SMMU_PPCS1_ASID_PPCS1_ASID, BpmpAsid));
 
             /* Flush the entire page table cache, and read TLB_CONFIG to ensure the flush takes. */
-            reg::Write(MC + MC_SMMU_PTC_FLUSH, 0);
+            reg::Write(MC + MC_SMMU_PTC_FLUSH_0, 0);
             reg::Read (MC + MC_SMMU_TLB_CONFIG);
 
             /* Flush the entire translation lookaside buffer, and read TLB_CONFIG to ensure the flush takes. */

exosphere/program/source/smc/secmon_mc_access_table_data.inc

@@ -22,7 +22,7 @@ SetRegisterAllowed(MC_SMMU_CONFIG);                           /* 0x010 */
 SetRegisterAllowed(MC_SMMU_PTB_ASID);                         /* 0x01C */
 SetRegisterAllowed(MC_SMMU_PTB_DATA);                         /* 0x020 */
 SetRegisterAllowed(MC_SMMU_TLB_FLUSH);                        /* 0x030 */
-SetRegisterAllowed(MC_SMMU_PTC_FLUSH);                        /* 0x034 */
+SetRegisterAllowed(MC_SMMU_PTC_FLUSH_0);                      /* 0x034 */
 SetRegisterAllowed(MC_EMEM_CFG);                              /* 0x050 */
 SetRegisterAllowed(MC_EMEM_ADR_CFG);                          /* 0x054 */
 SetRegisterAllowed(MC_EMEM_ARB_CFG);                          /* 0x090 */
@@ -53,7 +53,7 @@ SetRegisterAllowed(MC_SMMU_DCB_ASID);                         /* 0x244 */
 SetRegisterAllowed(MC_SMMU_HC_ASID);                          /* 0x250 */
 SetRegisterAllowed(MC_SMMU_HDA_ASID);                         /* 0x254 */
 SetRegisterAllowed(MC_SMMU_ISP2_ASID);                        /* 0x258 */
-SetRegisterAllowed(MC_SMMU_NVENC_ASID);                       /* 0x264 */
+SetRegisterAllowed(MC_SMMU_MSENC_NVENC_ASID);                 /* 0x264 */
 SetRegisterAllowed(MC_SMMU_NV_ASID);                          /* 0x268 */
 SetRegisterAllowed(MC_SMMU_NV2_ASID);                         /* 0x26C */
 SetRegisterAllowed(MC_SMMU_PPCS_ASID);                        /* 0x270 */

exosphere/program/source/smc/secmon_smc_handler.cpp

@@ -141,6 +141,9 @@ namespace ams::secmon::smc {
             { 0xC3000006, Restriction_Normal,             SmcShowError                      },
             { 0xC3000007, Restriction_Normal,             SmcSetKernelCarveoutRegion        },
             { 0xC3000008, Restriction_Normal,             SmcReadWriteRegister              },
+
+            /* NOTE: Atmosphere extension for mesosphere. This ID is subject to change at any time. */
+            { 0xC3000409, Restriction_Normal,             SmcSetConfig                      },
         };
 
         constinit HandlerInfo g_ams_handlers[] = {

exosphere/program/source/smc/secmon_smc_info.cpp

@@ -15,6 +15,7 @@
  */
 #include <exosphere.hpp>
 #include "../secmon_error.hpp"
+#include "../secmon_map.hpp"
 #include "../secmon_misc.hpp"
 #include "../secmon_page_mapper.hpp"
 #include "../secmon_user_power_management.hpp"
@@ -157,6 +158,8 @@ namespace ams::secmon::smc {
             return value.value;
         }
 
+        constinit u64 g_payload_address = 0;
+
         SmcResult GetConfig(SmcArguments &args, bool kern) {
             switch (static_cast<ConfigItem>(args.r[1])) {
                 case ConfigItem::DisableProgramVerification:
@@ -267,6 +270,14 @@ namespace ams::secmon::smc {
                     /* NOTE: This may return values other than 1 in the future. */
                     args.r[1] = (GetEmummcConfiguration().IsEmummcActive() ? 1 : 0);
                     break;
+                case ConfigItem::ExospherePayloadAddress:
+                    /* Gets the physical address of the reboot payload buffer, if one exists. */
+                    if (g_payload_address != 0) {
+                        args.r[1] = g_payload_address;
+                    } else {
+                        return SmcResult::NotInitialized;
+                    }
+                    break;
                 default:
                     return SmcResult::InvalidArgument;
             }
@@ -309,6 +320,17 @@ namespace ams::secmon::smc {
                         return SmcResult::NotImplemented;
                     }
                     break;
+                case ConfigItem::ExospherePayloadAddress:
+                    if (g_payload_address == 0) {
+                        if (secmon::IsPhysicalMemoryAddress(args.r[2])) {
+                            g_payload_address = args.r[2];
+                        } else {
+                            return SmcResult::InvalidArgument;
+                        }
+                    } else {
+                        return SmcResult::Busy;
+                    }
+                    break;
                 default:
                     return SmcResult::InvalidArgument;
             }

exosphere/program/source/smc/secmon_smc_info.hpp

@@ -48,6 +48,7 @@ namespace ams::secmon::smc {
         ExosphereBlankProdInfo  = 65005,
         ExosphereAllowCalWrites = 65006,
         ExosphereEmummcType     = 65007,
+        ExospherePayloadAddress = 65008,
     };
 
     SmcResult SmcGetConfigUser(SmcArguments &args);

exosphere/sdmmc_test/Makefile

@@ -0,0 +1,108 @@
+#---------------------------------------------------------------------------------
+# Define the atmosphere board and cpu
+#---------------------------------------------------------------------------------
+export ATMOSPHERE_BOARD := nx-hac-001
+export ATMOSPHERE_CPU   := arm7tdmi
+
+#---------------------------------------------------------------------------------
+# pull in common atmosphere configuration
+#---------------------------------------------------------------------------------
+include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../../libraries/config/templates/exosphere.mk
+
+#---------------------------------------------------------------------------------
+# no real need to edit anything past this point unless you need to add additional
+# rules for different file extensions
+#---------------------------------------------------------------------------------
+ifneq ($(BUILD),$(notdir $(CURDIR)))
+#---------------------------------------------------------------------------------
+
+export OUTPUT	:=	$(CURDIR)/$(TARGET)
+export TOPDIR	:=	$(CURDIR)
+export DEPSDIR  :=  $(CURDIR)/$(BUILD)
+
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
+			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
+
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
+
+#---------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#---------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CC)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CXX)
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
+export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
+export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(subst -,_,$(BINFILES))))
+
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+			-I.
+
+export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/lib -L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
+
+.PHONY: $(BUILD) clean all
+
+#---------------------------------------------------------------------------------
+all: $(BUILD) check_libexo
+
+$(BUILD): check_libexo
+	@[ -d $@ ] || mkdir -p $@
+	@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
+
+check_libexo:
+	@$(MAKE) --no-print-directory -C ../../libraries/libexosphere arm
+
+#---------------------------------------------------------------------------------
+clean:
+	@echo clean ...
+	@rm -fr $(BUILD) $(OUTPUT).bin $(OUTPUT).elf *.lz4
+
+#---------------------------------------------------------------------------------
+else
+.PHONY:	all
+
+DEPENDS	:=	$(OFILES:.o=.d)
+
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+all	:	$(OUTPUT).bin
+
+$(OUTPUT).bin	:	$(OUTPUT).elf
+	$(OBJCOPY) -S -O binary --set-section-flags .bss=alloc,load,contents $< $@
+	@echo built ... $(notdir $@)
+
+$(OUTPUT).elf	:	$(OFILES) ../../../libraries/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a
+
+%.elf:
+	@echo linking $(notdir $@)
+	$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
+	@$(NM) -CSn $@ > $(notdir $*.lst)
+
+$(OFILES_SRC)	: $(HFILES_BIN)
+
+#---------------------------------------------------------------------------------
+# you need a rule like this for each extension you use as binary data
+#---------------------------------------------------------------------------------
+%.bin.o	%_bin.h:	%.bin
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+-include $(DEPENDS)
+
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------

exosphere/sdmmc_test/sdmmc_test.ld

@@ -0,0 +1,194 @@
+OUTPUT_ARCH(arm)
+ENTRY(_ZN3ams10sdmmc_test5StartEv)
+
+MEMORY
+{
+    NULL     : ORIGIN = 0,          LENGTH = 4K
+    test_fw  : ORIGIN = 0x40010000, LENGTH = 32K
+}
+
+
+SECTIONS
+{
+	/* =========== CODE section =========== */
+	PROVIDE(__start__ = ORIGIN(test_fw));
+	. = __start__;
+	__code_start = . ;
+
+	.crt0 :
+	{
+		KEEP (*(.crt0 .crt0.*))
+		. = ALIGN(8);
+	} >test_fw
+
+	.vectors :
+	{
+		KEEP (*(.vectors .vectors.*))
+		. = ALIGN(8);
+	} >test_fw
+
+	.text :
+	{
+		*(.text.unlikely .text.*_unlikely .text.unlikely.*)
+		*(.text.exit .text.exit.*)
+		*(.text.startup .text.startup.*)
+		*(.text.hot .text.hot.*)
+		*(.text .stub .text.* .gnu.linkonce.t.*)
+		. = ALIGN(8);
+	} >test_fw
+
+	.init :
+	{
+		KEEP( *(.init) )
+		. = ALIGN(8);
+	} >test_fw
+
+	.plt :
+	{
+		*(.plt)
+		*(.iplt)
+		. = ALIGN(8);
+	} >test_fw
+
+	.fini :
+	{
+		KEEP( *(.fini) )
+		. = ALIGN(8);
+	} >test_fw
+
+
+	/* =========== RODATA section =========== */
+	. = ALIGN(8);
+	__rodata_start = . ;
+
+	.rodata :
+	{
+		*(.rodata .rodata.* .gnu.linkonce.r.*)
+		. = ALIGN(8);
+	} >test_fw
+
+	.eh_frame_hdr     : { __eh_frame_hdr_start = .; *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) __eh_frame_hdr_end = .; } >test_fw
+	.eh_frame         : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) } >test_fw
+	.gcc_except_table : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) } >test_fw
+	.gnu_extab        : ONLY_IF_RO { *(.gnu_extab*) } >test_fw
+
+	.hash              : { *(.hash) } >test_fw
+
+	/* =========== DATA section =========== */
+	. = ALIGN(8);
+	__data_start = . ;
+
+	.eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) } >test_fw
+	.gcc_except_table : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) } >test_fw
+	.gnu_extab : ONLY_IF_RW { *(.gnu_extab*) } >test_fw
+	.exception_ranges : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) } >test_fw
+
+	.preinit_array ALIGN(8) :
+	{
+		PROVIDE (__preinit_array_start = .);
+		KEEP (*(.preinit_array))
+		PROVIDE (__preinit_array_end = .);
+	} >test_fw
+
+	.init_array ALIGN(8) :
+	{
+		PROVIDE (__init_array_start = .);
+		KEEP (*(SORT(.init_array.*)))
+		KEEP (*(.init_array))
+		PROVIDE (__init_array_end = .);
+	} >test_fw
+
+	.fini_array ALIGN(8) :
+	{
+		PROVIDE (__fini_array_start = .);
+		KEEP (*(.fini_array))
+		KEEP (*(SORT(.fini_array.*)))
+		PROVIDE (__fini_array_end = .);
+	} >test_fw
+
+	.ctors ALIGN(8) :
+	{
+		KEEP (*crtbegin.o(.ctors)) /* MUST be first -- GCC requires it */
+		KEEP (*(EXCLUDE_FILE (*crtend.o) .ctors))
+		KEEP (*(SORT(.ctors.*)))
+		KEEP (*(.ctors))
+	} >test_fw
+
+	.dtors ALIGN(8) :
+	{
+		KEEP (*crtbegin.o(.dtors))
+		KEEP (*(EXCLUDE_FILE (*crtend.o) .dtors))
+		KEEP (*(SORT(.dtors.*)))
+		KEEP (*(.dtors))
+	} >test_fw
+
+	__got_start__ = .;
+
+	.got            : { *(.got) *(.igot) } >test_fw
+	.got.plt        : { *(.got.plt)  *(.igot.plt) } >test_fw
+
+	__got_end__ = .;
+
+	.data ALIGN(8) :
+	{
+		*(.data .data.* .gnu.linkonce.d.*)
+		SORT(CONSTRUCTORS)
+	} >test_fw
+
+	__bss_start__ = .;
+	.bss ALIGN(8) :
+	{
+		*(.dynbss)
+		*(.bss .bss.* .gnu.linkonce.b.*)
+		*(COMMON)
+		. = ALIGN(16);
+	} >test_fw
+	__bss_end__ = .;
+
+	__end__ = ABSOLUTE(.) ;
+
+    __total_size__ = (__end__ - __start__);
+
+    __stack_top__    = 0x40031000;
+    __stack_bottom__ = 0x40030000;
+
+	/* ==================
+	   ==== Metadata ====
+	   ================== */
+
+	/* Discard sections that difficult post-processing */
+	/DISCARD/ : { *(.group .comment .note .interp) }
+
+	/* Stabs debugging sections. */
+	.stab          0 : { *(.stab) }
+	.stabstr       0 : { *(.stabstr) }
+	.stab.excl     0 : { *(.stab.excl) }
+	.stab.exclstr  0 : { *(.stab.exclstr) }
+	.stab.index    0 : { *(.stab.index) }
+	.stab.indexstr 0 : { *(.stab.indexstr) }
+
+	/* DWARF debug sections.
+	   Symbols in the DWARF debugging sections are relative to the beginning
+	   of the section so we begin them at 0. */
+
+	/* DWARF 1 */
+	.debug          0 : { *(.debug) }
+	.line           0 : { *(.line) }
+
+	/* GNU DWARF 1 extensions */
+	.debug_srcinfo  0 : { *(.debug_srcinfo) }
+	.debug_sfnames  0 : { *(.debug_sfnames) }
+
+	/* DWARF 1.1 and DWARF 2 */
+	.debug_aranges  0 : { *(.debug_aranges) }
+	.debug_pubnames 0 : { *(.debug_pubnames) }
+
+	/* DWARF 2 */
+	.debug_info     0 : { *(.debug_info) }
+	.debug_abbrev   0 : { *(.debug_abbrev) }
+	.debug_line     0 : { *(.debug_line) }
+	.debug_frame    0 : { *(.debug_frame) }
+	.debug_str      0 : { *(.debug_str) }
+	.debug_loc      0 : { *(.debug_loc) }
+	.debug_macinfo  0 : { *(.debug_macinfo) }
+}

exosphere/sdmmc_test/sdmmc_test.specs

@@ -0,0 +1,7 @@
+%rename link old_link
+
+*link:
+%(old_link) -T %:getenv(TOPDIR /sdmmc_test.ld) --gc-sections --nmagic -nostdlib -nostartfiles
+
+*startfile:
+crti%O%s crtbegin%O%s

exosphere/sdmmc_test/source/sdmmc_test_main.cpp

@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <exosphere.hpp>
+
+namespace ams::sdmmc_test {
+
+    namespace {
+
+        constexpr inline const uintptr_t PMC = secmon::MemoryRegionPhysicalDevicePmc.GetAddress();
+
+        constexpr inline auto Port = sdmmc::Port_SdCard0;
+        alignas(8) constinit u8 g_sd_work_buffer[sdmmc::SdCardWorkBufferSize];
+
+        constexpr inline u32 SectorIndex = 0;
+        constexpr inline u32 SectorCount = 2;
+
+        NORETURN void PmcMainReboot() {
+            /* Write enable to MAIN_RESET. */
+            reg::Write(PMC + APBDEV_PMC_CNTRL, PMC_REG_BITS_ENUM(CNTRL_MAIN_RESET, ENABLE));
+
+            /* Wait forever until we're reset. */
+            AMS_INFINITE_LOOP();
+        }
+
+        void CheckResult(const Result result) {
+            volatile u32 * const DEBUG = reinterpret_cast<volatile u32 *>(0x4003C000);
+            if (R_FAILED(result)) {
+                DEBUG[1] = result.GetValue();
+                PmcMainReboot();
+            }
+        }
+
+    }
+
+    void Main() {
+        /* Perform butchered hwinit. */
+        /* TODO: replace with simpler, non-C logic. */
+        /* nx_hwinit(); */
+
+        /* Clear output buffer for debug. */
+        std::memset((void *)0x40038000, 0xAA, 0x400);
+
+        /* Normally, these pins get configured by boot sysmodule during initial pinmux config. */
+        /* However, they're required to access the SD card. */
+        {
+            const uintptr_t apb_misc = dd::QueryIoMapping(0x70000000, 0x4000);
+
+            reg::ReadWrite(apb_misc + PINMUX_AUX_SDMMC1_CLK,  PINMUX_REG_BITS_ENUM(AUX_E_INPUT,             ENABLE),
+                                                              PINMUX_REG_BITS_ENUM(AUX_TRISTATE,       PASSTHROUGH),
+                                                              PINMUX_REG_BITS_ENUM(AUX_PUPD,             PULL_DOWN),
+                                                              PINMUX_REG_BITS_ENUM(AUX_SDMMC1_CLK_PM,       SDMMC1));
+
+            reg::ReadWrite(apb_misc + PINMUX_AUX_SDMMC1_CMD,  PINMUX_REG_BITS_ENUM(AUX_E_INPUT,             ENABLE),
+                                                              PINMUX_REG_BITS_ENUM(AUX_TRISTATE,       PASSTHROUGH),
+                                                              PINMUX_REG_BITS_ENUM(AUX_PUPD,               PULL_UP),
+                                                              PINMUX_REG_BITS_ENUM(AUX_SDMMC1_CMD_PM,       SDMMC1));
+
+            reg::ReadWrite(apb_misc + PINMUX_AUX_SDMMC1_DAT3, PINMUX_REG_BITS_ENUM(AUX_E_INPUT,             ENABLE),
+                                                              PINMUX_REG_BITS_ENUM(AUX_TRISTATE,       PASSTHROUGH),
+                                                              PINMUX_REG_BITS_ENUM(AUX_PUPD,               PULL_UP),
+                                                              PINMUX_REG_BITS_ENUM(AUX_SDMMC1_DAT3_PM,      SDMMC1));
+
+            reg::ReadWrite(apb_misc + PINMUX_AUX_SDMMC1_DAT2, PINMUX_REG_BITS_ENUM(AUX_E_INPUT,             ENABLE),
+                                                              PINMUX_REG_BITS_ENUM(AUX_TRISTATE,       PASSTHROUGH),
+                                                              PINMUX_REG_BITS_ENUM(AUX_PUPD,               PULL_UP),
+                                                              PINMUX_REG_BITS_ENUM(AUX_SDMMC1_DAT2_PM,      SDMMC1));
+
+            reg::ReadWrite(apb_misc + PINMUX_AUX_SDMMC1_DAT1, PINMUX_REG_BITS_ENUM(AUX_E_INPUT,             ENABLE),
+                                                              PINMUX_REG_BITS_ENUM(AUX_TRISTATE,       PASSTHROUGH),
+                                                              PINMUX_REG_BITS_ENUM(AUX_PUPD,               PULL_UP),
+                                                              PINMUX_REG_BITS_ENUM(AUX_SDMMC1_DAT1_PM,      SDMMC1));
+
+            reg::ReadWrite(apb_misc + PINMUX_AUX_SDMMC1_DAT0, PINMUX_REG_BITS_ENUM(AUX_E_INPUT,             ENABLE),
+                                                              PINMUX_REG_BITS_ENUM(AUX_TRISTATE,       PASSTHROUGH),
+                                                              PINMUX_REG_BITS_ENUM(AUX_PUPD,               PULL_UP),
+                                                              PINMUX_REG_BITS_ENUM(AUX_SDMMC1_DAT0_PM,      SDMMC1));
+
+            reg::ReadWrite(apb_misc + PINMUX_AUX_DMIC3_CLK,   PINMUX_REG_BITS_ENUM(AUX_E_OD,               DISABLE),
+                                                              PINMUX_REG_BITS_ENUM(AUX_E_INPUT,            DISABLE),
+                                                              PINMUX_REG_BITS_ENUM(AUX_TRISTATE,       PASSTHROUGH),
+                                                              PINMUX_REG_BITS_ENUM(AUX_SDMMC1_DAT0_PM,       RSVD2));
+        }
+
+        /* Debug signaler. */
+        volatile u32 * const DEBUG = reinterpret_cast<volatile u32 *>(0x4003C000);
+        DEBUG[0] = 0;
+        DEBUG[1] = 0xAAAAAAAA;
+
+        /* Initialize sdmmc library. */
+        sdmmc::Initialize(Port);
+        DEBUG[0] = 1;
+
+        sdmmc::SetSdCardWorkBuffer(Port, g_sd_work_buffer, sizeof(g_sd_work_buffer));
+        DEBUG[0] = 2;
+
+        Result result = sdmmc::Activate(Port);
+        DEBUG[0] = 3;
+        CheckResult(result);
+
+        /* Read the first two sectors from disk. */
+        void * const sector_dst = reinterpret_cast<void *>(0x40038000);
+        result = sdmmc::Read(sector_dst, SectorCount * sdmmc::SectorSize, Port, SectorIndex, SectorCount);
+        DEBUG[0] = 4;
+        CheckResult(result);
+
+        /* Get the connection status. */
+        sdmmc::SpeedMode speed_mode;
+        sdmmc::BusWidth bus_width;
+        result = sdmmc::CheckSdCardConnection(std::addressof(speed_mode), std::addressof(bus_width), Port);
+
+        /* Save status for debug. */
+        DEBUG[0] = 5;
+        DEBUG[1] = result.GetValue();
+        DEBUG[2] = static_cast<u32>(speed_mode);
+        DEBUG[3] = static_cast<u32>(bus_width);
+
+        /* Perform a reboot. */
+        PmcMainReboot();
+    }
+
+    NORETURN void ExceptionHandler() {
+        PmcMainReboot();
+    }
+
+}
+
+namespace ams::diag {
+
+    void AbortImpl() {
+        sdmmc_test::ExceptionHandler();
+    }
+
+}

exosphere/sdmmc_test/source/sdmmc_test_start.s

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+.section    .crt0.text._ZN3ams10sdmmc_test5StartEv, "ax", %progbits
+.align      3
+.global     _ZN3ams10sdmmc_test5StartEv
+_ZN3ams10sdmmc_test5StartEv:
+    /* Switch to system mode, mask all interrupts, clear all flags */
+    msr cpsr_cxsf, #0xDF
+
+    /* Set the stack pointer. */
+    ldr sp, =__stack_top__
+
+    /* Set our link register to the exception handler. */
+    ldr lr, =_ZN3ams10sdmmc_test16ExceptionHandlerEv
+
+    /* Call init array functions. */
+    bl __libc_init_array
+
+    /* Invoke main. */
+    b _ZN3ams10sdmmc_test4MainEv
+
+    /* Infinite loop. */
+    2: b 2b

exosphere/warmboot/source/warmboot_start.s

@@ -30,7 +30,7 @@ _ZN3ams8warmboot5StartEv:
 
     /* Invoke main. */
     ldr r0, =_metadata
-    bl _ZN3ams8warmboot4MainEPKNS0_8MetadataE
+    b _ZN3ams8warmboot4MainEPKNS0_8MetadataE
 
     /* Infinite loop. */
     1: b 1b

fusee/fusee-primary/src/panic.c

@@ -24,6 +24,9 @@
 #include "lib/log.h"
 #include "display/video_fb.h"
 
+#define PROGRAM_ID_AMS_MITM 0x010041544D530000ull
+#define PROGRAM_ID_BOOT     0x0100000000000005ull
+
 static uint32_t g_panic_code = 0;
 
 static const char *get_error_desc_str(uint32_t error_desc) {
@@ -53,6 +56,61 @@ static const char *get_error_desc_str(uint32_t error_desc) {
     }
 }
 
+static void _try_suggest_fix(const atmosphere_fatal_error_ctx *ctx) {
+    /* Try to recognize certain errors automatically, and suggest fixes for them. */
+    const char *suggestion = NULL;
+
+    if (ctx->error_desc == 0xFFE) {
+        if (ctx->program_id == PROGRAM_ID_AMS_MITM) {
+            /* When a user has archive bits set improperly, attempting to create an automatic backup will fail */
+            /* to create the file path with error 0x202 (fs::ResultPathNotFound()) */
+            if (ctx->gprs[0] == 0x202) {
+                /* When the archive bit error is occurring, it manifests as failure to create automatic backup. */
+                /* Thus, we can search the stack for the automatic backups path. */
+                const char * const automatic_backups_prefix = "automatic_backups/X" /* ..... */;
+                const int prefix_len = strlen(automatic_backups_prefix);
+
+                for (size_t i = 0; i + prefix_len < ctx->stack_dump_size; ++i) {
+                    if (memcmp(&ctx->stack_dump[i], automatic_backups_prefix, prefix_len) == 0) {
+                        suggestion = "The atmosphere directory may improperly have archive\n"
+                                     "bits set. Please try running an archive bit fixer tool\n"
+                                     "(for example, the one in Hekate).\n";
+                        break;
+                    }
+                }
+            } else if (ctx->gprs[0] == 0x249A02) { /* fs::ResultResultExFatUnavailable() */
+                /* When a user installs non-exFAT firm but has an exFAT formatted SD card, this error will */
+                /* be returned on attempt to access the SD card. */
+                suggestion = "Your console has non-exFAT firmware installed, but your SD card\n"
+                             "is formatted as exFAT. Format your SD card as FAT32, or manually\n"
+                             "flash exFAT firmware to package2.\n";
+            }
+        } else if (ctx->program_id == PROGRAM_ID_BOOT) {
+            /* 9.x -> 10.x updated the API for SvcQueryIoMapping. */
+            /* This can cause the kernel to reject incorrect-ABI calls by boot when a partial update is applied */
+            /* (older kernel in package2, for some reason). */
+            for (size_t i = 0; i < 8; ++i) {
+                if (ctx->gprs[i] == 0xF201) {
+                    suggestion = "A partial update may have been improperly performed.\n"
+                                 "To fix, try manually flashing latest package2 to MMC.\n"
+                                 "\n"
+                                 "For help doing this, seek support in the ReSwitched or\n"
+                                 "Nintendo Homebrew discord servers.\n";
+                    break;
+                }
+            }
+        }
+    } else if (ctx->error_desc == 0xF00) { /* Kernel Panic */
+        suggestion = "Please contact SciresM#0524 on Discord, or create an issue\n"
+                     "on the Atmosphere GitHub issue tracker. Thank you very much\n"
+                     "for helping to test mesosphere.\n";
+    }
+
+    if (suggestion != NULL) {
+        print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "\n%s", suggestion);
+    }
+}
+
 static void _check_and_display_atmosphere_fatal_error(void) {
     /* Check for valid magic. */
     if (ATMOSPHERE_FATAL_ERROR_CONTEXT->magic != ATMOSPHERE_REBOOT_TO_FATAL_MAGIC   &&
@@ -86,7 +144,7 @@ static void _check_and_display_atmosphere_fatal_error(void) {
         ATMOSPHERE_FATAL_ERROR_CONTEXT->magic = 0xCCCCCCCC;
 
         print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "A fatal error occurred when running Atmosph\xe8re.\n");
-        print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "Title ID:   %016llx\n", ctx.title_id);
+        print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "Program ID: %016llx\n", ctx.program_id);
         print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "Error Desc: %s (0x%x)\n", get_error_desc_str(ctx.error_desc), ctx.error_desc);
 
         /* Save context to the SD card. */
@@ -101,6 +159,9 @@ static void _check_and_display_atmosphere_fatal_error(void) {
             }
         }
 
+        /* Try to print a fix suggestion via automatic error detection. */
+        _try_suggest_fix(&ctx);
+
         /* Display error. */
         print(SCREEN_LOG_LEVEL_ERROR | SCREEN_LOG_LEVEL_NO_PREFIX, "\nPress POWER to reboot\n");
     }

fusee/fusee-primary/src/panic.h

@@ -36,7 +36,7 @@
 typedef struct {
     uint32_t magic;
     uint32_t error_desc;
-    uint64_t title_id;
+    uint64_t program_id;
     union {
         uint64_t gprs[32];
         struct {

fusee/fusee-secondary/Makefile

@@ -186,11 +186,15 @@ DEPENDS	:=	$(OFILES:.o=.d)
 #---------------------------------------------------------------------------------
 all	:	$(OUTPUT).bin
 
-$(OUTPUT).bin	:	$(OUTPUT).elf
+$(OUTPUT).bin	:	$(OUTPUT)-experimental.bin
+	@python $(TOPDIR)/fusee_make_standard.py $(OUTPUT)-experimental.bin $(OUTPUT).bin
+	@echo built ... $(notdir $@)
+
+$(OUTPUT)-experimental.bin	:	$(OUTPUT)-experimental.elf
 	$(OBJCOPY) -S -O binary $< $@
 	@echo built ... $(notdir $@)
 
-$(OUTPUT).elf	:	$(OFILES)
+$(OUTPUT)-experimental.elf	:	$(OFILES)
 
 %.elf: $(OFILES)
 	@echo linking $(notdir $@)

fusee/fusee-secondary/fusee_make_standard.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+import sys, os
+from struct import pack as pk, unpack as up
+
+def make_standard(exp):
+    std = exp[:]
+    _, metadata_offset, is_exp = up('<III', exp[:12])
+    assert is_exp == 1
+
+    # Patch the experimental flag to zero.
+    std = std[:8] + pk('<I', 0) + std[12:]
+
+    # Locate the mesosphere content header, patch to be experimental.
+    magic, size, code_ofs, content_ofs, num_contents, ver, sup_ver, rev = up('<IIIIIIII', exp[metadata_offset:metadata_offset + 0x20])
+    for i in range(num_contents):
+        start, size, cnt_type, flag0, flag1, flag2, pad = up('<IIBBBBI', exp[content_ofs + 0x20 * i:content_ofs + 0x20 * i + 0x10])
+        if cnt_type == 10: # CONTENT_TYPE_KRN
+            assert exp[content_ofs + 0x20 * i + 0x10:content_ofs + 0x20 * i + 0x10 + len(b'mesosphere') + 1] == (b'mesosphere\x00')
+            assert flag0 == 0 and flag1 == 0 and flag2 == 0
+            std = std[:content_ofs + 0x20 * i] + pk('<IIBBBBI', start, size, cnt_type, flag0 | 0x1, flag1, flag2, pad) + std[content_ofs + 0x20 * i + 0x10:]
+
+    return std
+
+
+def main(argc, argv):
+    if argc != 3:
+        print('Usage: %s input output' % argv[0])
+        return 1
+    with open(argv[1], 'rb') as f:
+        experimental = f.read()
+    with open(argv[2], 'wb') as f:
+        f.write(make_standard(experimental))
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main(len(sys.argv), sys.argv))

fusee/fusee-secondary/linker.ld

@@ -254,4 +254,6 @@ SECTIONS
     PROVIDE(__emummc_kip_size__ = emummc_kip_end - emummc_kip);
     PROVIDE(__kernel_ldr_bin_start__ = kernel_ldr_bin - __start__);
     PROVIDE(__kernel_ldr_bin_size__ = kernel_ldr_bin_end - kernel_ldr_bin);
+    PROVIDE(__mesosphere_bin_start__ = mesosphere_bin - __start__);
+    PROVIDE(__mesosphere_bin_size__ = mesosphere_bin_end - mesosphere_bin);
 }

fusee/fusee-secondary/src/nxboot.c

@@ -55,6 +55,7 @@
 #define u8 uint8_t
 #define u32 uint32_t
 #include "exosphere_bin.h"
+#include "mesosphere_bin.h"
 #include "sept_secondary_00_enc.h"
 #include "sept_secondary_01_enc.h"
 #include "sept_secondary_dev_00_enc.h"
@@ -66,6 +67,8 @@
 
 extern const uint8_t warmboot_bin[];
 
+extern int fusee_is_experimental(void);
+
 static const uint8_t retail_pkc_modulus[0x100] = {
     0xF7, 0x86, 0x47, 0xAB, 0x71, 0x89, 0x81, 0xB5, 0xCF, 0x0C, 0xB0, 0xE8, 0x48, 0xA7, 0xFD, 0xAD,
     0xCB, 0x4E, 0x4A, 0x52, 0x0B, 0x1A, 0x8E, 0xDE, 0x41, 0x87, 0x6F, 0xB7, 0x31, 0x05, 0x5F, 0xAA,
@@ -209,11 +212,11 @@ static int stratosphere_ini_handler(void *user, const char *section, const char
             strat_cfg->has_nogc_config = true;
             sscanf(value, "%d", &tmp);
             strat_cfg->enable_nogc = tmp != 0;
-        } else if (strcmp(name, STRATOSPHERE_ENABLE_NCM_KEY) == 0) {
+        } else if (strcmp(name, STRATOSPHERE_DISABLE_NCM_KEY) == 0) {
             sscanf(value, "%d", &tmp);
-            strat_cfg->ncm_enabled = tmp != 0;
-            if (strat_cfg->ncm_enabled) {
-                stratosphere_enable_ncm();
+            strat_cfg->ncm_disabled = tmp != 0;
+            if (strat_cfg->ncm_disabled) {
+                stratosphere_disable_ncm();
             }
         } else {
             return 0;
@@ -624,6 +627,7 @@ static nx_keyblob_t __attribute__((aligned(16))) g_keyblobs[32];
 uint32_t nxboot_main(void) {
     volatile tegra_pmc_t *pmc = pmc_get_regs();
     loader_ctx_t *loader_ctx = get_loader_ctx();
+    const bool is_experimental = fusee_is_experimental();
     package2_header_t *package2;
     size_t package2_size;
     void *tsec_fw;
@@ -933,7 +937,6 @@ uint32_t nxboot_main(void) {
     }
 
     /* Configure mesosphere. */
-    /* TODO: Support non-SD/embedded mesosphere. */
     {
         size_t sd_meso_size = get_file_size("atmosphere/mesosphere.bin");
         if (sd_meso_size != 0) {
@@ -948,6 +951,20 @@ uint32_t nxboot_main(void) {
                 fatal_error("Error: failed to read atmosphere/mesosphere.bin!\n");
             }
             mesosphere_size = sd_meso_size;
+        } else if (is_experimental) {
+            mesosphere_size = mesosphere_bin_size;
+
+            mesosphere      = malloc(mesosphere_size);
+
+            if (mesosphere == NULL) {
+                fatal_error("[NXBOOT] Out of memory!\n");
+            }
+
+            memcpy(mesosphere, mesosphere_bin, mesosphere_size);
+
+            if (mesosphere_size == 0) {
+                fatal_error("[NXBOOT] Could not read embedded mesosphere!\n");
+            }
         } else {
             mesosphere = NULL;
             mesosphere_size = 0;

fusee/fusee-secondary/src/start.s

@@ -30,6 +30,9 @@ _start:
 
 .word (_metadata - _start)
 
+_is_experimental:
+.word 0x00000001 /* is experimental */
+
 _crt0:
     /* Switch to system mode, mask all interrupts, clear all flags */
     msr cpsr_cxsf, #0xDF
@@ -68,6 +71,14 @@ _crt0:
     ldr r1, [r1]
     b   main
 
+.arm
+.global fusee_is_experimental
+.type   fusee_is_experimental, %function
+fusee_is_experimental:
+    ldr r0, =_is_experimental
+    ldr r0, [r0]
+    bx lr
+
 /* Fusee-secondary header. */
 .align 5
 _metadata:
@@ -135,6 +146,17 @@ _content_headers:
 .asciz "exosphere"
 .align 5
 
+/* mesosphere content header */
+.word __mesosphere_bin_start__
+.word __mesosphere_bin_size__
+.byte CONTENT_TYPE_KRN
+.byte CONTENT_FLAG_NONE
+.byte CONTENT_FLAG_NONE
+.byte CONTENT_FLAG_NONE
+.word 0xCCCCCCCC
+.asciz "mesosphere"
+.align 5
+
 /* fusee_primary content header */
 .word __fusee_primary_bin_start__
 .word __fusee_primary_bin_size__
@@ -249,7 +271,7 @@ _content_headers:
 .word __ncm_kip_start__
 .word __ncm_kip_size__
 .byte CONTENT_TYPE_KIP
-.byte CONTENT_FLAG0_EXPERIMENTAL
+.byte CONTENT_FLAG_NONE
 .byte CONTENT_FLAG_NONE
 .byte CONTENT_FLAG_NONE
 .word 0xCCCCCCCC
@@ -267,17 +289,6 @@ _content_headers:
 .asciz "emummc"
 .align 5
 
-/* kernel_ldr content header */
-.word __kernel_ldr_bin_start__
-.word __kernel_ldr_bin_size__
-.byte CONTENT_TYPE_KLD
-.byte CONTENT_FLAG_NONE
-.byte CONTENT_FLAG_NONE
-.byte CONTENT_FLAG_NONE
-.word 0xCCCCCCCC
-.asciz "kernel_ldr"
-.align 5
-
 /* splash_screen content header */
 .word __splash_screen_bmp_start__
 .word __splash_screen_bmp_size__

fusee/fusee-secondary/src/stratosphere.c

@@ -48,7 +48,7 @@ static bool g_stratosphere_pm_enabled = true;
 static bool g_stratosphere_ams_mitm_enabled = true;
 static bool g_stratosphere_spl_enabled = true;
 static bool g_stratosphere_boot_enabled = true;
-static bool g_stratosphere_ncm_enabled = false;
+static bool g_stratosphere_ncm_enabled = true;
 
 extern const uint8_t loader_kip[], pm_kip[], sm_kip[], spl_kip[], boot_kip[], ncm_kip[], ams_mitm_kip[];
 
@@ -58,17 +58,17 @@ emummc_fs_ver_t stratosphere_get_fs_version(void) {
     return g_fs_ver;
 }
 
-void stratosphere_enable_ncm(void) {
+void stratosphere_disable_ncm(void) {
     /* The Atmosphere team believes our implementation of NCM to be extremely accurate, */
     /* and does not think it likely there is any possibility of undesirable behavior */
     /* when using the NCM reimplementation. However, because NCM manages critical save games */
-    /* the implementation will default to off for some time, until the code has been thoroughly */
-    /* tested in practice. */
+    /* the implementation may be optionally disabled for those not comfortable using it. */
 
-    /* PLEASE NOTE: The default behavior will be NCM on in a future atmosphere release, */
-    /* and this opt-in functionality will be removed at that time. */
 
-    g_stratosphere_ncm_enabled = true;
+    /* PLEASE NOTE: The NCM reimplementation has been well-tested, and correspondingly opt-out */
+    /*              functionality will be removed in Atmosphere 1.0.0. */
+
+    g_stratosphere_ncm_enabled = false;
 }
 
 /* GCC doesn't consider the size as const... we have to write it ourselves. */

fusee/fusee-secondary/src/stratosphere.h

@@ -30,7 +30,7 @@ ini1_header_t *stratosphere_get_ini1(uint32_t target_firmware);
 ini1_header_t *stratosphere_get_sd_files_ini1(void);
 void stratosphere_free_ini1(void);
 
-void stratosphere_enable_ncm(void);
+void stratosphere_disable_ncm(void);
 
 emummc_fs_ver_t stratosphere_get_fs_version(void);
 
@@ -39,10 +39,10 @@ ini1_header_t *stratosphere_merge_inis(ini1_header_t **inis, unsigned int num_in
 typedef struct {
     bool has_nogc_config;
     bool enable_nogc;
-    bool ncm_enabled;
+    bool ncm_disabled;
 } stratosphere_cfg_t;
 
 #define STRATOSPHERE_NOGC_KEY "nogc"
-#define STRATOSPHERE_ENABLE_NCM_KEY "enable_ncm"
+#define STRATOSPHERE_DISABLE_NCM_KEY "disable_ncm"
 
 #endif

libraries/.gitrepo

@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/Atmosphere-NX/Atmosphere-libs
 	branch = master
-	commit = f6dac1e67793233cc916f317cf517244dd348a5e
-	parent = 909a1767a6080bab7ea6032c00e1ff4cec993af0
+	commit = 10e9e0e8f926b11c2c7de16ffe15bea7d7ec2cdf
+	parent = 2ee2a4f1ac04bc7f15de8be8d57ad04d7e73f735
 	method = merge
 	cmdver = 0.4.1

libraries/config/common.mk

@@ -15,8 +15,10 @@ endif
 
 endif
 
+ATMOSPHERE_BUILD_SETTINGS ?=
+
 export ATMOSPHERE_DEFINES  := -DATMOSPHERE
-export ATMOSPHERE_SETTINGS := -fPIE -g
+export ATMOSPHERE_SETTINGS := -fPIE -g $(ATMOSPHERE_BUILD_SETTINGS)
 export ATMOSPHERE_CFLAGS   := -Wall -ffunction-sections -fdata-sections -fno-strict-aliasing -fwrapv  \
                               -fno-asynchronous-unwind-tables -fno-unwind-tables -fno-stack-protector \
                               -Wno-format-truncation -Wno-format-zero-length -Wno-stringop-truncation
@@ -132,10 +134,15 @@ FIND_SOURCE_FILES=$(foreach dir,$1,$(filter-out $(notdir $(wildcard $(dir)/*.arc
                   $(foreach dir,$1,$(call FIND_SPECIFIC_SOURCE_FILES,$(dir),os,$(ATMOSPHERE_OS_NAME),$2)) \
                   $(foreach dir,$1,$(call FIND_SPECIFIC_SOURCE_FILES_EX,$(dir),cpu,$(ATMOSPHERE_CPU_NAME) $(ATMOSPHERE_CPU_EXTENSIONS),$2))
 
+ATMOSPHERE_GCH_IDENTIFIER ?= ams_placeholder_gch_identifier
+
 #---------------------------------------------------------------------------------
 # Rules for compiling pre-compiled headers
 #---------------------------------------------------------------------------------
-%.gch: %.hpp
-	@echo $<
-	$(CXX) -w -x c++-header -MMD -MP -MF $(DEPSDIR)/$*.d $(CXXFLAGS) -c $< -o $@ $(ERROR_FILTER)
-	@cp $@ $(<).gch
+%.hpp.gch/$(ATMOSPHERE_GCH_IDENTIFIER): %.hpp | %.hpp.gch
+	@echo Precompiling $(notdir $<) for $(ATMOSPHERE_GCH_IDENTIFIER)
+	$(SILENTCMD)$(CXX) -w -x c++-header -MMD -MP -MQ$@ -MF $(DEPSDIR)/$(notdir $*).d $(CXXFLAGS) -c $< -o $@ $(ERROR_FILTER)
+
+%.hpp.gch: %.hpp
+	@echo Precompiling $(notdir $<)
+	$(SILENTCMD)$(CXX) -w -x c++-header -MMD -MP -MQ$@ -MF $(DEPSDIR)/$(notdir $*).d $(CXXFLAGS) -c $< -o $@ $(ERROR_FILTER)

libraries/config/templates/mesosphere.mk

@@ -29,7 +29,7 @@ export CXXWRAPS := -Wl,--wrap,__cxa_pure_virtual \
 			-Wl,--wrap,_ZSt20__throw_length_errorPKc \
 			-Wl,--wrap,_ZNSt11logic_errorC2EPKc
 
-export LIBS := -lmesosphere
+export LIBS := -l$(LIBMESOSPHERE_NAME)
 
 #---------------------------------------------------------------------------------
 # list of directories containing libraries, this must be the top level containing

libraries/libexosphere/arm.mk

@@ -112,6 +112,7 @@ $(OFILES)	:	$(GCH_FILES)
 $(OFILES_SRC)	: $(HFILES_BIN)
 
 libc.o: CFLAGS += -fno-builtin -fno-lto
+libgcc_division.arch.arm.o: CFLAGS += -fno-builtin -fno-lto
 
 #---------------------------------------------------------------------------------
 %_bin.h %.bin.o	:	%.bin

libraries/libexosphere/include/exosphere.hpp

@@ -17,7 +17,6 @@
 #include <vapours.hpp>
 
 #include <exosphere/common.hpp>
-#include <exosphere/reg.hpp>
 #include <exosphere/hw.hpp>
 #include <exosphere/util.hpp>
 #include <exosphere/mmu.hpp>
@@ -41,4 +40,3 @@
 #include <exosphere/actmon.hpp>
 #include <exosphere/pmc.hpp>
 #include <exosphere/secmon.hpp>
-#include <exosphere/tegra.hpp>

libraries/libexosphere/include/exosphere/tegra.hpp

@@ -1,34 +0,0 @@
-/*
- * Copyright (c) 2018-2020 Atmosphère-NX
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-#pragma once
-#include <vapours.hpp>
-
-#include <exosphere/tegra/tegra_ahb_arbc.hpp>
-#include <exosphere/tegra/tegra_apb_misc.hpp>
-#include <exosphere/tegra/tegra_avp_cache.hpp>
-#include <exosphere/tegra/tegra_clkrst.hpp>
-#include <exosphere/tegra/tegra_emc.hpp>
-#include <exosphere/tegra/tegra_evp.hpp>
-#include <exosphere/tegra/tegra_flow_ctlr.hpp>
-#include <exosphere/tegra/tegra_ictlr.hpp>
-#include <exosphere/tegra/tegra_mc.hpp>
-#include <exosphere/tegra/tegra_mselect.hpp>
-#include <exosphere/tegra/tegra_pinmux.hpp>
-#include <exosphere/tegra/tegra_pg_up.hpp>
-#include <exosphere/tegra/tegra_pmc.hpp>
-#include <exosphere/tegra/tegra_sb.hpp>
-#include <exosphere/tegra/tegra_sysctr0.hpp>
-#include <exosphere/tegra/tegra_timer.hpp>

libraries/libexosphere/include/exosphere/util.hpp

@@ -20,14 +20,6 @@ namespace ams::util {
 
     void SetRegisterAddress(uintptr_t address);
 
-    u32 GetMicroSeconds();
-    void WaitMicroSeconds(int us);
-
     void ClearMemory(void *ptr, size_t size);
 
-    template<typename T, typename U> requires std::integral<T> && std::integral<U>
-    constexpr T DivideUp(T x, U y) {
-        return (x + (y - 1)) / y;
-    }
-
 }

libraries/libexosphere/source/i2c/i2c_api.cpp

@@ -14,7 +14,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include <exosphere.hpp>
-#include "i2c_registers.hpp"
 
 namespace ams::i2c {
 

libraries/libexosphere/source/i2c/i2c_registers.hpp

@@ -1,77 +0,0 @@
-/*
- * Copyright (c) 2018-2020 Atmosphère-NX
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-#include <exosphere.hpp>
-
-namespace ams::i2c {
-
-    #define I2C_I2C_CNFG                  (0x000)
-    #define I2C_I2C_CMD_ADDR0             (0x004)
-    #define I2C_I2C_CMD_DATA1             (0x00C)
-    #define I2C_I2C_STATUS                (0x01C)
-    #define I2C_INTERRUPT_STATUS_REGISTER (0x068)
-    #define I2C_CLK_DIVISOR_REGISTER      (0x06C)
-    #define I2C_BUS_CLEAR_CONFIG          (0x084)
-    #define I2C_BUS_CLEAR_STATUS          (0x088)
-    #define I2C_CONFIG_LOAD               (0x08C)
-
-    #define I2C_REG_BITS_MASK(NAME)                                      REG_NAMED_BITS_MASK    (I2C, NAME)
-    #define I2C_REG_BITS_VALUE(NAME, VALUE)                              REG_NAMED_BITS_VALUE   (I2C, NAME, VALUE)
-    #define I2C_REG_BITS_ENUM(NAME, ENUM)                                REG_NAMED_BITS_ENUM    (I2C, NAME, ENUM)
-    #define I2C_REG_BITS_ENUM_SEL(NAME, __COND__, TRUE_ENUM, FALSE_ENUM) REG_NAMED_BITS_ENUM_SEL(I2C, NAME, __COND__, TRUE_ENUM, FALSE_ENUM)
-
-    #define DEFINE_I2C_REG(NAME, __OFFSET__, __WIDTH__)                                                                                                                  REG_DEFINE_NAMED_REG           (I2C, NAME, __OFFSET__, __WIDTH__)
-    #define DEFINE_I2C_REG_BIT_ENUM(NAME, __OFFSET__, ZERO, ONE)                                                                                                         REG_DEFINE_NAMED_BIT_ENUM      (I2C, NAME, __OFFSET__, ZERO, ONE)
-    #define DEFINE_I2C_REG_TWO_BIT_ENUM(NAME, __OFFSET__, ZERO, ONE, TWO, THREE)                                                                                         REG_DEFINE_NAMED_TWO_BIT_ENUM  (I2C, NAME, __OFFSET__, ZERO, ONE, TWO, THREE)
-    #define DEFINE_I2C_REG_THREE_BIT_ENUM(NAME, __OFFSET__, ZERO, ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN)                                                               REG_DEFINE_NAMED_THREE_BIT_ENUM(I2C, NAME, __OFFSET__, ZERO, ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN)
-    #define DEFINE_I2C_REG_FOUR_BIT_ENUM(NAME, __OFFSET__, ZERO, ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, ELEVEN, TWELVE, THIRTEEN, FOURTEEN, FIFTEEN) REG_DEFINE_NAMED_FOUR_BIT_ENUM (I2C, NAME, __OFFSET__, ZERO, ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, ELEVEN, TWELVE, THIRTEEN, FOURTEEN, FIFTEEN)
-
-    /* I2C_CNFG */
-    DEFINE_I2C_REG(I2C_CNFG_LENGTH, 1, 3);
-    DEFINE_I2C_REG_BIT_ENUM(I2C_CNFG_CMD1, 6, WRITE, READ);
-    DEFINE_I2C_REG_BIT_ENUM(I2C_CNFG_SEND, 9, NOP, GO);
-    DEFINE_I2C_REG_BIT_ENUM(I2C_CNFG_NEW_MASTER_FSM, 11, DISABLE, ENABLE);
-    DEFINE_I2C_REG_THREE_BIT_ENUM(I2C_CNFG_DEBOUNCE_CNT, 12, NO_DEBOUNCE, DEBOUNCE_2T, DEBOUNCE_4T, DEBOUNCE_6T, DEBOUNCE_8T, DEBOUNCE_10T, DEBOUNCE_12T, DEBOUNCE_14T);
-
-    /* I2C_CMD_ADDR0 */
-    DEFINE_I2C_REG_BIT_ENUM(I2C_CMD_ADDR0_7BIT_RW, 0, WRITE, READ);
-    DEFINE_I2C_REG(I2C_CMD_ADDR0_7BIT_ADDR, 1, 7);
-
-    /* I2C_STATUS */
-    DEFINE_I2C_REG_FOUR_BIT_ENUM(I2C_STATUS_CMD1_STAT, 0, SL1_XFER_SUCCESSFUL, SL1_NOACK_FOR_BYTE1, SL1_NOACK_FOR_BYTE2, SL1_NOACK_FOR_BYTE3, SL1_NOACK_FOR_BYTE4, SL1_NOACK_FOR_BYTE5, SL1_NOACK_FOR_BYTE6, SL1_NOACK_FOR_BYTE7, SL1_NOACK_FOR_BYTE8, SL1_NOACK_FOR_BYTE9, SL1_NOACK_FOR_BYTE10, RESERVED11, RESERVED12, RESERVED13, RESERVED14, RESERVED15);
-    DEFINE_I2C_REG_FOUR_BIT_ENUM(I2C_STATUS_CMD2_STAT, 4, SL2_XFER_SUCCESSFUL, SL2_NOACK_FOR_BYTE1, SL2_NOACK_FOR_BYTE2, SL2_NOACK_FOR_BYTE3, SL2_NOACK_FOR_BYTE4, SL2_NOACK_FOR_BYTE5, SL2_NOACK_FOR_BYTE6, SL2_NOACK_FOR_BYTE7, SL2_NOACK_FOR_BYTE8, SL2_NOACK_FOR_BYTE9, SL2_NOACK_FOR_BYTE10, RESERVED11, RESERVED12, RESERVED13, RESERVED14, RESERVED15);
-    DEFINE_I2C_REG_BIT_ENUM(I2C_STATUS_BUSY, 8, NOT_BUSY, BUSY);
-
-    /* INTERRUPT_STATUS_REGISTER */
-    DEFINE_I2C_REG_BIT_ENUM(INTERRUPT_STATUS_REGISTER_BUS_CLEAR_DONE, 11, UNSET, SET);
-
-    /* CLK_DIVISOR_REGISTER */
-    DEFINE_I2C_REG(CLK_DIVISOR_REGISTER_HSMODE, 0, 16);
-    DEFINE_I2C_REG(CLK_DIVISOR_REGISTER_STD_FAST_MODE, 16, 16);
-
-    /* BUS_CLEAR_CONFIG */
-    DEFINE_I2C_REG_BIT_ENUM(BUS_CLEAR_CONFIG_BC_ENABLE,    0, DISABLE, ENABLE);
-    DEFINE_I2C_REG_BIT_ENUM(BUS_CLEAR_CONFIG_BC_TERMINATE, 1, THRESHOLD, IMMEDIATE);
-    DEFINE_I2C_REG_BIT_ENUM(BUS_CLEAR_CONFIG_BC_STOP_COND, 2, NO_STOP, STOP);
-    DEFINE_I2C_REG(BUS_CLEAR_CONFIG_BC_SCLK_THRESHOLD, 16, 8);
-
-    /* CONFIG_LOAD */
-    DEFINE_I2C_REG_BIT_ENUM(CONFIG_LOAD_MSTR_CONFIG_LOAD,    0, DISABLE, ENABLE);
-    DEFINE_I2C_REG_BIT_ENUM(CONFIG_LOAD_SLV_CONFIG_LOAD,     1, DISABLE, ENABLE);
-    DEFINE_I2C_REG_BIT_ENUM(CONFIG_LOAD_TIMEOUT_CONFIG_LOAD, 2, DISABLE, ENABLE);
-    DEFINE_I2C_REG(CONFIG_LOAD_RESERVED_BIT_5, 5, 1);
-
-
-}

libraries/libexosphere/source/libc/libexo_cxx.cpp

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <exosphere.hpp>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* cxx implementation details to be stubbed here, as needed. */
+void __cxa_pure_virtual() { AMS_ABORT("pure virtual function call"); }
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif

libraries/libexosphere/source/libc/libgcc_division.arch.arm.c

@@ -0,0 +1,160 @@
+// SPDX-License-Identifier: BSD-2-Clause
+/*
+ * Copyright (c) 2014, STMicroelectronics International N.V.
+ */
+
+/*
+ * Form ABI specifications:
+ *      int __aeabi_idiv(int numerator, int denominator);
+ *     unsigned __aeabi_uidiv(unsigned numerator, unsigned denominator);
+ *
+ *     typedef struct { int quot; int rem; } idiv_return;
+ *     typedef struct { unsigned quot; unsigned rem; } uidiv_return;
+ *
+ *     __value_in_regs idiv_return __aeabi_idivmod(int numerator,
+ *     int *denominator);
+ *     __value_in_regs uidiv_return __aeabi_uidivmod(unsigned *numerator,
+ *     unsigned denominator);
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* struct qr - stores qutient/remainder to handle divmod EABI interfaces. */
+struct qr {
+	unsigned q;		/* computed quotient */
+	unsigned r;		/* computed remainder */
+	unsigned q_n;		/* specficies if quotient shall be negative */
+	unsigned r_n;		/* specficies if remainder shall be negative */
+};
+
+static void uint_div_qr(unsigned numerator, unsigned denominator,
+			struct qr *qr);
+
+/* returns in R0 and R1 by tail calling an asm function */
+unsigned __aeabi_uidivmod(unsigned numerator, unsigned denominator);
+
+unsigned __aeabi_uidiv(unsigned numerator, unsigned denominator);
+
+/* returns in R0 and R1 by tail calling an asm function */
+signed __aeabi_idivmod(signed numerator, signed denominator);
+
+signed __aeabi_idiv(signed numerator, signed denominator);
+
+/*
+ * __ste_idivmod_ret_t __aeabi_idivmod(signed numerator, signed denominator)
+ * Numerator and Denominator are received in R0 and R1.
+ * Where __ste_idivmod_ret_t is returned in R0 and R1.
+ *
+ * __ste_uidivmod_ret_t __aeabi_uidivmod(unsigned numerator,
+ *                                       unsigned denominator)
+ * Numerator and Denominator are received in R0 and R1.
+ * Where __ste_uidivmod_ret_t is returned in R0 and R1.
+ */
+#ifdef __GNUC__
+signed ret_idivmod_values(signed quotient, signed remainder);
+unsigned ret_uidivmod_values(unsigned quotient, unsigned remainder);
+#else
+#error "Compiler not supported"
+#endif
+
+static void division_qr(unsigned n, unsigned p, struct qr *qr)
+{
+	unsigned i = 1, q = 0;
+	if (p == 0) {
+		qr->r = 0xFFFFFFFF;	/* division by 0 */
+		return;
+	}
+
+	while ((p >> 31) == 0) {
+		i = i << 1;	/* count the max division steps */
+		p = p << 1;     /* increase p until it has maximum size*/
+	}
+
+	while (i > 0) {
+		q = q << 1;	/* write bit in q at index (size-1) */
+		if (n >= p)
+		{
+			n -= p;
+			q++;
+		}
+		p = p >> 1; 	/* decrease p */
+		i = i >> 1; 	/* decrease remaining size in q */
+	}
+	qr->r = n;
+	qr->q = q;
+}
+
+static void uint_div_qr(unsigned numerator, unsigned denominator, struct qr *qr)
+{
+
+	division_qr(numerator, denominator, qr);
+
+	/* negate quotient and/or remainder according to requester */
+	if (qr->q_n)
+		qr->q = -qr->q;
+	if (qr->r_n)
+		qr->r = -qr->r;
+}
+
+unsigned __aeabi_uidiv(unsigned numerator, unsigned denominator)
+{
+	struct qr qr = { .q_n = 0, .r_n = 0 };
+
+	uint_div_qr(numerator, denominator, &qr);
+
+	return qr.q;
+}
+
+unsigned __aeabi_uidivmod(unsigned numerator, unsigned denominator)
+{
+	struct qr qr = { .q_n = 0, .r_n = 0 };
+
+	uint_div_qr(numerator, denominator, &qr);
+
+	return ret_uidivmod_values(qr.q, qr.r);
+}
+
+signed __aeabi_idiv(signed numerator, signed denominator)
+{
+	struct qr qr = { .q_n = 0, .r_n = 0 };
+
+	if (((numerator < 0) && (denominator > 0)) ||
+	    ((numerator > 0) && (denominator < 0)))
+		qr.q_n = 1;	/* quotient shall be negate */
+	if (numerator < 0) {
+		numerator = -numerator;
+		qr.r_n = 1;	/* remainder shall be negate */
+	}
+	if (denominator < 0)
+		denominator = -denominator;
+
+	uint_div_qr(numerator, denominator, &qr);
+
+	return qr.q;
+}
+
+signed __aeabi_idivmod(signed numerator, signed denominator)
+{
+	struct qr qr = { .q_n = 0, .r_n = 0 };
+
+	if (((numerator < 0) && (denominator > 0)) ||
+	    ((numerator > 0) && (denominator < 0)))
+		qr.q_n = 1;	/* quotient shall be negate */
+	if (numerator < 0) {
+		numerator = -numerator;
+		qr.r_n = 1;	/* remainder shall be negate */
+	}
+	if (denominator < 0)
+		denominator = -denominator;
+
+	uint_div_qr(numerator, denominator, &qr);
+
+	return ret_idivmod_values(qr.q, qr.r);
+}
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif

libraries/libexosphere/source/libc/libgcc_division_asm.arch.arm.s

@@ -0,0 +1,30 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+/*
+ * Copyright (c) 2014, STMicroelectronics International N.V.
+ */
+
+/*
+ * signed ret_idivmod_values(signed quot, signed rem);
+ * return quotient and remaining the EABI way (regs r0,r1)
+ */
+.section    .text.ret_idivmod_values, "ax", %progbits
+.globl ret_idivmod_values
+.align      0
+.syntax unified
+ret_idivmod_values:
+    bx lr
+.type ret_idivmod_values, %function
+.size ret_idivmod_values, .-ret_idivmod_values
+
+/*
+ * unsigned ret_uidivmod_values(unsigned quot, unsigned rem);
+ * return quotient and remaining the EABI way (regs r0,r1)
+ */
+.section    .text.ret_uidivmod_values, "ax", %progbits
+.globl ret_uidivmod_values
+.align      0
+.syntax unified
+ret_uidivmod_values:
+    bx lr
+.type ret_uidivmod_values, %function
+.size ret_uidivmod_values, .-ret_uidivmod_values

libraries/libexosphere/source/libc/libgcc_thumb_case.arch.arm.s

@@ -0,0 +1,35 @@
+/* Copyright (C) 1995-2018 Free Software Foundation, Inc.
+This file is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 3, or (at your option) any
+later version.
+This file is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+
+.section    .text.__gnu_thumb1_case_uqi, "ax", %progbits
+.globl __gnu_thumb1_case_uqi
+.align      0
+.thumb_func
+.syntax unified
+__gnu_thumb1_case_uqi:
+    push    {r1}
+    mov     r1, lr
+    lsrs    r1, r1, #1
+    lsls    r1, r1, #1
+    ldrb    r1, [r1, r0]
+    lsls    r1, r1, #1
+    add     lr, lr, r1
+    pop     {r1}
+    bx      lr
+.type __gnu_thumb1_case_uqi, %function
+.size __gnu_thumb1_case_uqi, .-__gnu_thumb1_case_uqi

libraries/libmesosphere/Makefile

@@ -1,12 +1,14 @@
 #---------------------------------------------------------------------------------
 # pull in common atmosphere configuration
 #---------------------------------------------------------------------------------
-include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../config/common.mk
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
+include $(CURRENT_DIRECTORY)/../config/common.mk
 
 #---------------------------------------------------------------------------------
 # options for code generation
 #---------------------------------------------------------------------------------
-PRECOMPILED_HEADERS := $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/include/mesosphere.hpp
+PRECOMPILED_HEADERS := include/mesosphere.hpp
 
 DEFINES     := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_MESOSPHERE
 SETTINGS    := $(ATMOSPHERE_SETTINGS) -O2 -mgeneral-regs-only -ffixed-x18 -Wextra -Werror -fno-non-call-exceptions
@@ -28,7 +30,7 @@ LIBDIRS	:= $(ATMOSPHERE_LIBRARIES_DIR)/libvapours
 # no real need to edit anything past this point unless you need to add additional
 # rules for different file extensions
 #---------------------------------------------------------------------------------
-ifneq ($(BUILD),$(notdir $(CURDIR)))
+ifneq ($(__RECURSIVE__),1)
 #---------------------------------------------------------------------------------
 
 export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
@@ -54,7 +56,7 @@ endif
 
 export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
 export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
-export GCH_FILES    :=	$(foreach hdr,$(PRECOMPILED_HEADERS:.hpp=.gch),$(notdir $(hdr)))
+export GCH_DIRS     :=  $(PRECOMPILED_HEADERS:.hpp=.hpp.gch)
 export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
 export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(BINFILES)))
 
@@ -62,41 +64,70 @@ export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
 			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
 			-I.
 
-.PHONY: clean all
+#---------------------------------------------------------------------------------
+
+ATMOSPHERE_BUILD_CONFIGS :=
+all: release
+
+define ATMOSPHERE_ADD_TARGET
+
+ATMOSPHERE_BUILD_CONFIGS += $(strip $1)
+
+$(strip $1): $$(ATMOSPHERE_LIBRARY_DIR)/$(strip $2)
+
+$$(ATMOSPHERE_LIBRARY_DIR)/$(strip $2) : $$(ATMOSPHERE_LIBRARY_DIR) $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) $$(SOURCES) $$(INCLUDES) $$(GCH_DIRS)
+	@$$(MAKE) __RECURSIVE__=1 OUTPUT=$$(CURDIR)/$$@ $(3) \
+	ATMOSPHERE_GCH_IDENTIFIER="$$(ATMOSPHERE_BOARD_NAME)_$$(ATMOSPHERE_ARCH_NAME)_$(strip $1)" \
+	DEPSDIR=$$(CURDIR)/$$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
+	--no-print-directory -C $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
+	-f $$(THIS_MAKEFILE)
+
+clean-$(strip $1):
+	@echo clean $(strip $1) ...
+	@rm -fr $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) $$(ATMOSPHERE_LIBRARY_DIR)/$(strip $2)
+	@rm -fr $$(foreach hdr,$$(GCH_DIRS),$$(hdr)/$$(ATMOSPHERE_BOARD_NAME)_$$(ATMOSPHERE_ARCH_NAME)_$(strip $1))
+	@for i in $$(GCH_DIRS) $$(ATMOSPHERE_BUILD_DIR) $$(ATMOSPHERE_LIBRARY_DIR); do [ -d $$$$i ] && rmdir --ignore-fail-on-non-empty $$$$i || true; done
+
+endef
+
+$(eval $(call ATMOSPHERE_ADD_TARGET, release, $(TARGET).a, \
+	ATMOSPHERE_BUILD_SETTINGS="" \
+))
+
+$(eval $(call ATMOSPHERE_ADD_TARGET, debug, $(TARGET)_debug.a, \
+	ATMOSPHERE_BUILD_SETTINGS="-DMESOSPHERE_BUILD_FOR_DEBUGGING" \
+))
+
+$(eval $(call ATMOSPHERE_ADD_TARGET, audit, $(TARGET)_audit.a, \
+	ATMOSPHERE_BUILD_SETTINGS="-DMESOSPHERE_BUILD_FOR_AUDITING" \
+))
 
 #---------------------------------------------------------------------------------
-all: lib/$(TARGET).a
 
-lib:
+-include $(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME).mk
+
+ALL_GCH_IDENTIFIERS := $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),$(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME)_$(config))
+ALL_GCH_FILES       := $(foreach hdr,$(PRECOMPILED_HEADERS:.hpp=.hpp.gch),$(foreach id,$(ALL_GCH_IDENTIFIERS),$(hdr)/$(id)))
+
+.PHONY: clean all $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),$(config) clean-$(config))
+
+$(ATMOSPHERE_LIBRARY_DIR) $(GCH_DIRS):
 	@[ -d $@ ] || mkdir -p $@
 
-release:
+$(ATMOSPHERE_BUILD_DIR)/%:
 	@[ -d $@ ] || mkdir -p $@
 
-lib/$(TARGET).a : lib release $(SOURCES) $(INCLUDES)
-	@$(MAKE) BUILD=release OUTPUT=$(CURDIR)/$@ \
-	BUILD_CFLAGS="-DNDEBUG=1 -O2" \
-	DEPSDIR=$(CURDIR)/release \
-	--no-print-directory -C release \
-	-f $(CURDIR)/Makefile
-
-dist-bin: all
-	@tar --exclude=*~ -cjf $(TARGET).tar.bz2 include lib
-
-dist-src:
-	@tar --exclude=*~ -cjf $(TARGET)-src.tar.bz2 include source Makefile
-
-dist: dist-src dist-bin
-
 #---------------------------------------------------------------------------------
 clean:
 	@echo clean ...
-	@rm -fr release lib *.bz2
+	@rm -fr $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_LIBRARY_DIR) *.bz2 $(ALL_GCH_FILES)
+	@for i in $(GCH_DIRS); do [ -d $$i ] && rmdir --ignore-fail-on-non-empty $$i || true; done
 
 #---------------------------------------------------------------------------------
 else
 
-DEPENDS	:=	$(OFILES:.o=.d) $(GCH_FILES:.gch=.d)
+GCH_FILES :=	$(foreach hdr,$(PRECOMPILED_HEADERS:.hpp=.hpp.gch),$(CURRENT_DIRECTORY)/$(hdr)/$(ATMOSPHERE_GCH_IDENTIFIER))
+DEPENDS	:=	$(OFILES:.o=.d) $(foreach hdr,$(GCH_FILES),$(notdir $(patsubst %.hpp.gch/,%.d,$(dir $(hdr)))))
 
 #---------------------------------------------------------------------------------
 # main targets

libraries/libmesosphere/include/mesosphere/kern_k_scheduler.hpp

@@ -48,6 +48,7 @@ namespace ams::kern {
         private:
             friend class KScopedSchedulerLock;
             friend class KScopedSchedulerLockAndSleep;
+            friend class KScopedDisableDispatch;
         private:
             SchedulingState state;
             bool is_active;
@@ -161,8 +162,9 @@ namespace ams::kern {
             }
 
             ALWAYS_INLINE void ScheduleOnInterrupt() {
-                KScopedDisableDispatch dd;
+                GetCurrentThread().DisableDispatch();
                 this->Schedule();
+                GetCurrentThread().EnableDispatch();
             }
 
             void RescheduleOtherCores(u64 cores_needing_scheduling);

libraries/libmesosphere/include/mesosphere/kern_k_thread.hpp

@@ -559,20 +559,7 @@ namespace ams::kern {
                 GetCurrentThread().DisableDispatch();
             }
 
-            ALWAYS_INLINE ~KScopedDisableDispatch() {
-                GetCurrentThread().EnableDispatch();
-            }
-    };
-
-    class KScopedEnableDispatch {
-        public:
-            explicit ALWAYS_INLINE KScopedEnableDispatch() {
-                GetCurrentThread().EnableDispatch();
-            }
-
-            ALWAYS_INLINE ~KScopedEnableDispatch() {
-                GetCurrentThread().DisableDispatch();
-            }
+            ~KScopedDisableDispatch();
     };
 
     ALWAYS_INLINE KExceptionContext *GetExceptionContext(KThread *thread) {

libraries/libmesosphere/source/board/nintendo/nx/kern_clkrst_registers.hpp

@@ -1,20 +0,0 @@
-/*
- * Copyright (c) 2018-2020 Atmosphère-NX
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-#pragma once
-
-#define CLK_RST_CONTROLLER_CLK_SOURCE_CSITE 0x1D4
-#define CLK_RST_CONTROLLER_RST_DEV_L_SET    0x300
-#define CLK_RST_CONTROLLER_RST_DEV_L_CLR    0x304

libraries/libmesosphere/source/board/nintendo/nx/kern_flow_registers.hpp

@@ -1,21 +0,0 @@
-/*
- * Copyright (c) 2018-2020 Atmosphère-NX
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-#pragma once
-
-#define FLOW_CTLR_HALT_COP_EVENTS       0x004
-#define FLOW_CTLR_CC4_HVC_CONTROL       0x060
-#define FLOW_CTLR_CC4_RETENTION_CONTROL 0x064
-#define FLOW_CTLR_CC4_HVC_RETRY         0x08C

libraries/libmesosphere/source/board/nintendo/nx/kern_k_device_page_table.cpp

@@ -14,7 +14,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include <mesosphere.hpp>
-#include "kern_mc_registers.hpp"
 
 #if defined(MESOSPHERE_BUILD_FOR_DEBUGGING) || defined(MESOSPHERE_BUILD_FOR_AUDITING)
 #define MESOSPHERE_ENABLE_MEMORY_CONTROLLER_INTERRUPT

libraries/libmesosphere/source/board/nintendo/nx/kern_k_sleep_manager.cpp

@@ -78,13 +78,11 @@ namespace ams::kern::board::nintendo::nx {
 
         void WaitOtherCpuPowerOff() {
             constexpr u64 PmcPhysicalAddress = 0x7000E400;
-            constexpr u64 APBDEV_PMC_PWRGATE_STATUS = PmcPhysicalAddress + 0x38;
-
             constexpr u32 PWRGATE_STATUS_CE123_MASK = ((1u << 3) - 1) << 9;
 
             u32 value;
             do {
-                bool res = smc::ReadWriteRegister(std::addressof(value), APBDEV_PMC_PWRGATE_STATUS, 0, 0);
+                bool res = smc::ReadWriteRegister(std::addressof(value), PmcPhysicalAddress + APBDEV_PMC_PWRGATE_STATUS, 0, 0);
                 MESOSPHERE_ASSERT(res);
             } while ((value & PWRGATE_STATUS_CE123_MASK) != 0);
         }

libraries/libmesosphere/source/board/nintendo/nx/kern_k_system_control.cpp

@@ -308,6 +308,15 @@ namespace ams::kern::board::nintendo::nx {
             g_secure_applet_memory_used = false;
         }
 
+        u64 GetVersionIdentifier() {
+            u64 value = kern::GetTargetFirmware();
+            value |= static_cast<u64>(ATMOSPHERE_RELEASE_VERSION_MICRO) << 32;
+            value |= static_cast<u64>(ATMOSPHERE_RELEASE_VERSION_MINOR) << 40;
+            value |= static_cast<u64>(ATMOSPHERE_RELEASE_VERSION_MAJOR) << 48;
+            value |= static_cast<u64>('M') << 56;
+            return value;
+        }
+
     }
 
     /* Initialization. */
@@ -534,10 +543,14 @@ namespace ams::kern::board::nintendo::nx {
 
     void KSystemControl::StopSystem(void *arg) {
         if (arg != nullptr) {
+            /* Get the address of the legacy IRAM region. */
+            const KVirtualAddress iram_address = KMemoryLayout::GetDeviceVirtualAddress(KMemoryRegionType_LegacyLpsIram) + 64_KB;
+            constexpr size_t RebootPayloadSize = 0x2E000;
+
             /* NOTE: Atmosphere extension; if we received an exception context from Panic(), */
             /*       generate a fatal error report using it. */
             const KExceptionContext *e_ctx = static_cast<const KExceptionContext *>(arg);
-            auto *f_ctx = GetPointer<::ams::impl::FatalErrorContext>(KMemoryLayout::GetDeviceVirtualAddress(KMemoryRegionType_LegacyLpsIram) + 0x3E000);
+            auto *f_ctx = GetPointer<::ams::impl::FatalErrorContext>(iram_address + RebootPayloadSize);
 
             /* Clear the fatal context. */
             std::memset(f_ctx, 0xCC, sizeof(*f_ctx));
@@ -553,6 +566,10 @@ namespace ams::kern::board::nintendo::nx {
             /* Set module base. */
             f_ctx->module_base = KMemoryLayout::GetKernelCodeRegionExtents().GetAddress();
 
+            /* Set afsr1. */
+            f_ctx->afsr0 = 0;
+            f_ctx->afsr1 = GetVersionIdentifier();
+
             /* Copy registers. */
             for (size_t i = 0; i < util::size(e_ctx->x); ++i) {
                 f_ctx->gprs[i] = e_ctx->x[i];
@@ -581,8 +598,27 @@ namespace ams::kern::board::nintendo::nx {
                 }
             }
 
-            /* Trigger a reboot to rcm. */
-            smc::init::SetConfig(smc::ConfigItem::ExosphereNeedsReboot, smc::UserRebootType_ToRcm);
+            /* Try to get a payload address. */
+            const KMemoryRegion *cached_region = nullptr;
+            u64 reboot_payload_paddr = 0;
+            if (smc::TryGetConfig(std::addressof(reboot_payload_paddr), 1, smc::ConfigItem::ExospherePayloadAddress) && KMemoryLayout::IsLinearMappedPhysicalAddress(cached_region, reboot_payload_paddr, RebootPayloadSize)) {
+                /* If we have a payload, reboot to it. */
+                const KVirtualAddress reboot_payload = KMemoryLayout::GetLinearVirtualAddress(KPhysicalAddress(reboot_payload_paddr));
+
+                /* Clear IRAM. */
+                std::memset(GetVoidPointer(iram_address), 0xCC, RebootPayloadSize);
+
+                /* Copy the payload to iram. */
+                for (size_t i = 0; i < RebootPayloadSize / sizeof(u32); ++i) {
+                    GetPointer<volatile u32>(iram_address)[i] = GetPointer<volatile u32>(reboot_payload)[i];
+                }
+
+                /* Reboot. */
+                smc::SetConfig(smc::ConfigItem::ExosphereNeedsReboot, smc::UserRebootType_ToPayload);
+            } else {
+                /* If we don't have a payload, reboot to rcm. */
+                smc::SetConfig(smc::ConfigItem::ExosphereNeedsReboot, smc::UserRebootType_ToRcm);
+            }
         }
 
         if (g_call_smc_on_panic) {

libraries/libmesosphere/source/board/nintendo/nx/kern_lps_driver.cpp

@@ -19,11 +19,7 @@
 
 #include "kern_bpmp_api.hpp"
 #include "kern_atomics_registers.hpp"
-#include "kern_clkrst_registers.hpp"
-#include "kern_evp_registers.hpp"
-#include "kern_flow_registers.hpp"
 #include "kern_ictlr_registers.hpp"
-#include "kern_pmc_registers.hpp"
 #include "kern_sema_registers.hpp"
 
 namespace ams::kern::board::nintendo::nx::lps {

libraries/libmesosphere/source/board/nintendo/nx/kern_mc_registers.hpp

@@ -1,526 +0,0 @@
-/*
- * Copyright (c) 2018-2020 Atmosphère-NX
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-#pragma once
-
-#define MC_INTSTATUS                                            0x0
-#define MC_INTMASK                                              0x4
-#define MC_ERR_STATUS                                           0x8
-#define MC_ERR_ADR                                              0xc
-#define MC_SMMU_CONFIG                                          0x10
-#define MC_SMMU_TLB_CONFIG                                      0x14
-#define MC_SMMU_PTC_CONFIG                                      0x18
-#define MC_SMMU_PTB_ASID                                        0x1c
-#define MC_SMMU_PTB_DATA                                        0x20
-#define MC_SMMU_TLB_FLUSH                                       0x30
-#define MC_SMMU_PTC_FLUSH_0                                     0x34
-#define MC_SMMU_PTC_FLUSH_1                                     0x9b8
-#define MC_SMMU_ASID_SECURITY                                   0x38
-#define MC_SMMU_ASID_SECURITY_1                                 0x3c
-#define MC_SMMU_ASID_SECURITY_2                                 0x9e0
-#define MC_SMMU_ASID_SECURITY_3                                 0x9e4
-#define MC_SMMU_ASID_SECURITY_4                                 0x9e8
-#define MC_SMMU_ASID_SECURITY_5                                 0x9ec
-#define MC_SMMU_ASID_SECURITY_6                                 0x9f0
-#define MC_SMMU_ASID_SECURITY_7                                 0x9f4
-#define MC_SMMU_AFI_ASID                                        0x238
-#define MC_SMMU_AVPC_ASID                                       0x23c
-#define MC_SMMU_DC_ASID                                         0x240
-#define MC_SMMU_DCB_ASID                                        0x244
-#define MC_SMMU_HC_ASID                                         0x250
-#define MC_SMMU_HDA_ASID                                        0x254
-#define MC_SMMU_ISP2_ASID                                       0x258
-#define MC_SMMU_MSENC_NVENC_ASID                                0x264
-#define MC_SMMU_NV_ASID                                         0x268
-#define MC_SMMU_NV2_ASID                                        0x26c
-#define MC_SMMU_PPCS_ASID                                       0x270
-#define MC_SMMU_SATA_ASID                                       0x274
-#define MC_SMMU_VDE_ASID                                        0x27c
-#define MC_SMMU_VI_ASID                                         0x280
-#define MC_SMMU_VIC_ASID                                        0x284
-#define MC_SMMU_XUSB_HOST_ASID                                  0x288
-#define MC_SMMU_XUSB_DEV_ASID                                   0x28c
-#define MC_SMMU_TSEC_ASID                                       0x294
-#define MC_SMMU_PPCS1_ASID                                      0x298
-#define MC_SMMU_DC1_ASID                                        0xa88
-#define MC_SMMU_SDMMC1A_ASID                                    0xa94
-#define MC_SMMU_SDMMC2A_ASID                                    0xa98
-#define MC_SMMU_SDMMC3A_ASID                                    0xa9c
-#define MC_SMMU_SDMMC4A_ASID                                    0xaa0
-#define MC_SMMU_ISP2B_ASID                                      0xaa4
-#define MC_SMMU_GPU_ASID                                        0xaa8
-#define MC_SMMU_GPUB_ASID                                       0xaac
-#define MC_SMMU_PPCS2_ASID                                      0xab0
-#define MC_SMMU_NVDEC_ASID                                      0xab4
-#define MC_SMMU_APE_ASID                                        0xab8
-#define MC_SMMU_SE_ASID                                         0xabc
-#define MC_SMMU_NVJPG_ASID                                      0xac0
-#define MC_SMMU_HC1_ASID                                        0xac4
-#define MC_SMMU_SE1_ASID                                        0xac8
-#define MC_SMMU_AXIAP_ASID                                      0xacc
-#define MC_SMMU_ETR_ASID                                        0xad0
-#define MC_SMMU_TSECB_ASID                                      0xad4
-#define MC_SMMU_TSEC1_ASID                                      0xad8
-#define MC_SMMU_TSECB1_ASID                                     0xadc
-#define MC_SMMU_NVDEC1_ASID                                     0xae0
-#define MC_SMMU_TRANSLATION_ENABLE_0                            0x228
-#define MC_SMMU_TRANSLATION_ENABLE_1                            0x22c
-#define MC_SMMU_TRANSLATION_ENABLE_2                            0x230
-#define MC_SMMU_TRANSLATION_ENABLE_3                            0x234
-#define MC_SMMU_TRANSLATION_ENABLE_4                            0xb98
-#define MC_PCFIFO_CLIENT_CONFIG0                                0xdd0
-#define MC_PCFIFO_CLIENT_CONFIG1                                0xdd4
-#define MC_PCFIFO_CLIENT_CONFIG2                                0xdd8
-#define MC_PCFIFO_CLIENT_CONFIG3                                0xddc
-#define MC_PCFIFO_CLIENT_CONFIG4                                0xde0
-#define MC_EMEM_CFG                                             0x50
-#define MC_EMEM_ADR_CFG                                         0x54
-#define MC_EMEM_ADR_CFG_DEV0                                    0x58
-#define MC_EMEM_ADR_CFG_DEV1                                    0x5c
-#define MC_EMEM_ADR_CFG_CHANNEL_MASK                            0x60
-#define MC_EMEM_ADR_CFG_BANK_MASK_0                             0x64
-#define MC_EMEM_ADR_CFG_BANK_MASK_1                             0x68
-#define MC_EMEM_ADR_CFG_BANK_MASK_2                             0x6c
-#define MC_SECURITY_CFG0                                        0x70
-#define MC_SECURITY_CFG1                                        0x74
-#define MC_SECURITY_CFG3                                        0x9bc
-#define MC_SECURITY_RSV                                         0x7c
-#define MC_EMEM_ARB_CFG                                         0x90
-#define MC_EMEM_ARB_OUTSTANDING_REQ                             0x94
-#define MC_EMEM_ARB_TIMING_RCD                                  0x98
-#define MC_EMEM_ARB_TIMING_RP                                   0x9c
-#define MC_EMEM_ARB_TIMING_RC                                   0xa0
-#define MC_EMEM_ARB_TIMING_RAS                                  0xa4
-#define MC_EMEM_ARB_TIMING_FAW                                  0xa8
-#define MC_EMEM_ARB_TIMING_RRD                                  0xac
-#define MC_EMEM_ARB_TIMING_RAP2PRE                              0xb0
-#define MC_EMEM_ARB_TIMING_WAP2PRE                              0xb4
-#define MC_EMEM_ARB_TIMING_R2R                                  0xb8
-#define MC_EMEM_ARB_TIMING_W2W                                  0xbc
-#define MC_EMEM_ARB_TIMING_R2W                                  0xc0
-#define MC_EMEM_ARB_TIMING_W2R                                  0xc4
-#define MC_EMEM_ARB_TIMING_RFCPB                                0x6c0
-#define MC_EMEM_ARB_TIMING_CCDMW                                0x6c4
-#define MC_EMEM_ARB_REFPB_HP_CTRL                               0x6f0
-#define MC_EMEM_ARB_REFPB_BANK_CTRL                             0x6f4
-#define MC_EMEM_ARB_DA_TURNS                                    0xd0
-#define MC_EMEM_ARB_DA_COVERS                                   0xd4
-#define MC_EMEM_ARB_MISC0                                       0xd8
-#define MC_EMEM_ARB_MISC1                                       0xdc
-#define MC_EMEM_ARB_MISC2                                       0xc8
-#define MC_EMEM_ARB_RING1_THROTTLE                              0xe0
-#define MC_EMEM_ARB_RING3_THROTTLE                              0xe4
-#define MC_EMEM_ARB_NISO_THROTTLE                               0x6b0
-#define MC_EMEM_ARB_OVERRIDE                                    0xe8
-#define MC_EMEM_ARB_RSV                                         0xec
-#define MC_CLKEN_OVERRIDE                                       0xf4
-#define MC_TIMING_CONTROL_DBG                                   0xf8
-#define MC_TIMING_CONTROL                                       0xfc
-#define MC_STAT_CONTROL                                         0x100
-#define MC_STAT_STATUS                                          0x104
-#define MC_STAT_EMC_CLOCK_LIMIT                                 0x108
-#define MC_STAT_EMC_CLOCK_LIMIT_MSBS                            0x10c
-#define MC_STAT_EMC_CLOCKS                                      0x110
-#define MC_STAT_EMC_CLOCKS_MSBS                                 0x114
-#define MC_STAT_EMC_FILTER_SET0_ADR_LIMIT_LO                    0x118
-#define MC_STAT_EMC_FILTER_SET1_ADR_LIMIT_LO                    0x158
-#define MC_STAT_EMC_FILTER_SET0_ADR_LIMIT_HI                    0x11c
-#define MC_STAT_EMC_FILTER_SET1_ADR_LIMIT_HI                    0x15c
-#define MC_STAT_EMC_FILTER_SET0_ADR_LIMIT_UPPER                 0xa20
-#define MC_STAT_EMC_FILTER_SET1_ADR_LIMIT_UPPER                 0xa24
-#define MC_STAT_EMC_FILTER_SET0_VIRTUAL_ADR_LIMIT_LO            0x198
-#define MC_STAT_EMC_FILTER_SET1_VIRTUAL_ADR_LIMIT_LO            0x1a8
-#define MC_STAT_EMC_FILTER_SET0_VIRTUAL_ADR_LIMIT_HI            0x19c
-#define MC_STAT_EMC_FILTER_SET1_VIRTUAL_ADR_LIMIT_HI            0x1ac
-#define MC_STAT_EMC_FILTER_SET0_VIRTUAL_ADR_LIMIT_UPPER         0xa28
-#define MC_STAT_EMC_FILTER_SET1_VIRTUAL_ADR_LIMIT_UPPER         0xa2c
-#define MC_STAT_EMC_FILTER_SET0_ASID                            0x1a0
-#define MC_STAT_EMC_FILTER_SET1_ASID                            0x1b0
-#define MC_STAT_EMC_FILTER_SET0_SLACK_LIMIT                     0x120
-#define MC_STAT_EMC_FILTER_SET1_SLACK_LIMIT                     0x160
-#define MC_STAT_EMC_FILTER_SET0_CLIENT_0                        0x128
-#define MC_STAT_EMC_FILTER_SET1_CLIENT_0                        0x168
-#define MC_STAT_EMC_FILTER_SET0_CLIENT_1                        0x12c
-#define MC_STAT_EMC_FILTER_SET1_CLIENT_1                        0x16c
-#define MC_STAT_EMC_FILTER_SET0_CLIENT_2                        0x130
-#define MC_STAT_EMC_FILTER_SET1_CLIENT_2                        0x170
-#define MC_STAT_EMC_FILTER_SET0_CLIENT_3                        0x134
-#define MC_STAT_EMC_FILTER_SET0_CLIENT_4                        0xb88
-#define MC_STAT_EMC_FILTER_SET1_CLIENT_3                        0x174
-#define MC_STAT_EMC_FILTER_SET1_CLIENT_4                        0xb8c
-#define MC_STAT_EMC_SET0_COUNT                                  0x138
-#define MC_STAT_EMC_SET0_COUNT_MSBS                             0x13c
-#define MC_STAT_EMC_SET1_COUNT                                  0x178
-#define MC_STAT_EMC_SET1_COUNT_MSBS                             0x17c
-#define MC_STAT_EMC_SET0_SLACK_ACCUM                            0x140
-#define MC_STAT_EMC_SET0_SLACK_ACCUM_MSBS                       0x144
-#define MC_STAT_EMC_SET1_SLACK_ACCUM                            0x180
-#define MC_STAT_EMC_SET1_SLACK_ACCUM_MSBS                       0x184
-#define MC_STAT_EMC_SET0_HISTO_COUNT                            0x148
-#define MC_STAT_EMC_SET0_HISTO_COUNT_MSBS                       0x14c
-#define MC_STAT_EMC_SET1_HISTO_COUNT                            0x188
-#define MC_STAT_EMC_SET1_HISTO_COUNT_MSBS                       0x18c
-#define MC_STAT_EMC_SET0_MINIMUM_SLACK_OBSERVED                 0x150
-#define MC_STAT_EMC_SET1_MINIMUM_SLACK_OBSERVED                 0x190
-#define MC_STAT_EMC_SET0_IDLE_CYCLE_COUNT                       0x1b8
-#define MC_STAT_EMC_SET0_IDLE_CYCL_COUNT_MSBS                   0x1bc
-#define MC_STAT_EMC_SET1_IDLE_CYCLE_COUNT                       0x1c8
-#define MC_STAT_EMC_SET1_IDLE_CYCL_COUNT_MSBS                   0x1cc
-#define MC_STAT_EMC_SET0_IDLE_CYCLE_PARTITION_SELECT            0x1c0
-#define MC_STAT_EMC_SET1_IDLE_CYCLE_PARTITION_SELECT            0x1d0
-#define MC_CLIENT_HOTRESET_CTRL                                 0x200
-#define MC_CLIENT_HOTRESET_CTRL_1                               0x970
-#define MC_CLIENT_HOTRESET_STATUS                               0x204
-#define MC_CLIENT_HOTRESET_STATUS_1                             0x974
-#define MC_EMEM_ARB_ISOCHRONOUS_0                               0x208
-#define MC_EMEM_ARB_ISOCHRONOUS_1                               0x20c
-#define MC_EMEM_ARB_ISOCHRONOUS_2                               0x210
-#define MC_EMEM_ARB_ISOCHRONOUS_3                               0x214
-#define MC_EMEM_ARB_ISOCHRONOUS_4                               0xb94
-#define MC_EMEM_ARB_HYSTERESIS_0                                0x218
-#define MC_EMEM_ARB_HYSTERESIS_1                                0x21c
-#define MC_EMEM_ARB_HYSTERESIS_2                                0x220
-#define MC_EMEM_ARB_HYSTERESIS_3                                0x224
-#define MC_EMEM_ARB_HYSTERESIS_4                                0xb84
-#define MC_EMEM_ARB_DHYSTERESIS_0                               0xbb0
-#define MC_EMEM_ARB_DHYSTERESIS_1                               0xbb4
-#define MC_EMEM_ARB_DHYSTERESIS_2                               0xbb8
-#define MC_EMEM_ARB_DHYSTERESIS_3                               0xbbc
-#define MC_EMEM_ARB_DHYSTERESIS_4                               0xbc0
-#define MC_EMEM_ARB_DHYST_CTRL                                  0xbcc
-#define MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0                        0xbd0
-#define MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1                        0xbd4
-#define MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2                        0xbd8
-#define MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3                        0xbdc
-#define MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4                        0xbe0
-#define MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5                        0xbe4
-#define MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6                        0xbe8
-#define MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7                        0xbec
-#define MC_RESERVED_RSV                                         0x3fc
-#define MC_DISB_EXTRA_SNAP_LEVELS                               0x408
-#define MC_APB_EXTRA_SNAP_LEVELS                                0x2a4
-#define MC_AHB_EXTRA_SNAP_LEVELS                                0x2a0
-#define MC_USBD_EXTRA_SNAP_LEVELS                               0xa18
-#define MC_ISP_EXTRA_SNAP_LEVELS                                0xa08
-#define MC_AUD_EXTRA_SNAP_LEVELS                                0xa10
-#define MC_MSE_EXTRA_SNAP_LEVELS                                0x40c
-#define MC_GK2_EXTRA_SNAP_LEVELS                                0xa40
-#define MC_A9AVPPC_EXTRA_SNAP_LEVELS                            0x414
-#define MC_FTOP_EXTRA_SNAP_LEVELS                               0x2bc
-#define MC_JPG_EXTRA_SNAP_LEVELS                                0xa3c
-#define MC_HOST_EXTRA_SNAP_LEVELS                               0xa14
-#define MC_SAX_EXTRA_SNAP_LEVELS                                0x2c0
-#define MC_DIS_EXTRA_SNAP_LEVELS                                0x2ac
-#define MC_VICPC_EXTRA_SNAP_LEVELS                              0xa1c
-#define MC_HDAPC_EXTRA_SNAP_LEVELS                              0xa48
-#define MC_AVP_EXTRA_SNAP_LEVELS                                0x2a8
-#define MC_USBX_EXTRA_SNAP_LEVELS                               0x404
-#define MC_PCX_EXTRA_SNAP_LEVELS                                0x2b8
-#define MC_SD_EXTRA_SNAP_LEVELS                                 0xa04
-#define MC_DFD_EXTRA_SNAP_LEVELS                                0xa4c
-#define MC_VE_EXTRA_SNAP_LEVELS                                 0x2d8
-#define MC_GK_EXTRA_SNAP_LEVELS                                 0xa00
-#define MC_VE2_EXTRA_SNAP_LEVELS                                0x410
-#define MC_SDM_EXTRA_SNAP_LEVELS                                0xa44
-#define MC_VIDEO_PROTECT_BOM                                    0x648
-#define MC_VIDEO_PROTECT_SIZE_MB                                0x64c
-#define MC_VIDEO_PROTECT_BOM_ADR_HI                             0x978
-#define MC_VIDEO_PROTECT_REG_CTRL                               0x650
-#define MC_ERR_VPR_STATUS                                       0x654
-#define MC_ERR_VPR_ADR                                          0x658
-#define MC_VIDEO_PROTECT_VPR_OVERRIDE                           0x418
-#define MC_VIDEO_PROTECT_VPR_OVERRIDE1                          0x590
-#define MC_IRAM_BOM                                             0x65c
-#define MC_IRAM_TOM                                             0x660
-#define MC_IRAM_ADR_HI                                          0x980
-#define MC_IRAM_REG_CTRL                                        0x964
-#define MC_EMEM_CFG_ACCESS_CTRL                                 0x664
-#define MC_TZ_SECURITY_CTRL                                     0x668
-#define MC_EMEM_ARB_OUTSTANDING_REQ_RING3                       0x66c
-#define MC_EMEM_ARB_OUTSTANDING_REQ_NISO                        0x6b4
-#define MC_EMEM_ARB_RING0_THROTTLE_MASK                         0x6bc
-#define MC_EMEM_ARB_NISO_THROTTLE_MASK                          0x6b8
-#define MC_EMEM_ARB_NISO_THROTTLE_MASK_1                        0xb80
-#define MC_SEC_CARVEOUT_BOM                                     0x670
-#define MC_SEC_CARVEOUT_SIZE_MB                                 0x674
-#define MC_SEC_CARVEOUT_ADR_HI                                  0x9d4
-#define MC_SEC_CARVEOUT_REG_CTRL                                0x678
-#define MC_ERR_SEC_STATUS                                       0x67c
-#define MC_ERR_SEC_ADR                                          0x680
-#define MC_PC_IDLE_CLOCK_GATE_CONFIG                            0x684
-#define MC_STUTTER_CONTROL                                      0x688
-#define MC_RESERVED_RSV_1                                       0x958
-#define MC_DVFS_PIPE_SELECT                                     0x95c
-#define MC_AHB_PTSA_MIN                                         0x4e0
-#define MC_AUD_PTSA_MIN                                         0x54c
-#define MC_MLL_MPCORER_PTSA_RATE                                0x44c
-#define MC_RING2_PTSA_RATE                                      0x440
-#define MC_USBD_PTSA_RATE                                       0x530
-#define MC_USBX_PTSA_MIN                                        0x528
-#define MC_USBD_PTSA_MIN                                        0x534
-#define MC_APB_PTSA_MAX                                         0x4f0
-#define MC_JPG_PTSA_RATE                                        0x584
-#define MC_DIS_PTSA_MIN                                         0x420
-#define MC_AVP_PTSA_MAX                                         0x4fc
-#define MC_AVP_PTSA_RATE                                        0x4f4
-#define MC_RING1_PTSA_MIN                                       0x480
-#define MC_DIS_PTSA_MAX                                         0x424
-#define MC_SD_PTSA_MAX                                          0x4d8
-#define MC_MSE_PTSA_RATE                                        0x4c4
-#define MC_VICPC_PTSA_MIN                                       0x558
-#define MC_PCX_PTSA_MAX                                         0x4b4
-#define MC_ISP_PTSA_RATE                                        0x4a0
-#define MC_A9AVPPC_PTSA_MIN                                     0x48c
-#define MC_RING2_PTSA_MAX                                       0x448
-#define MC_AUD_PTSA_RATE                                        0x548
-#define MC_HOST_PTSA_MIN                                        0x51c
-#define MC_MLL_MPCORER_PTSA_MAX                                 0x454
-#define MC_SD_PTSA_MIN                                          0x4d4
-#define MC_RING1_PTSA_RATE                                      0x47c
-#define MC_JPG_PTSA_MIN                                         0x588
-#define MC_HDAPC_PTSA_MIN                                       0x62c
-#define MC_AVP_PTSA_MIN                                         0x4f8
-#define MC_JPG_PTSA_MAX                                         0x58c
-#define MC_VE_PTSA_MAX                                          0x43c
-#define MC_DFD_PTSA_MAX                                         0x63c
-#define MC_VICPC_PTSA_RATE                                      0x554
-#define MC_GK_PTSA_MAX                                          0x544
-#define MC_VICPC_PTSA_MAX                                       0x55c
-#define MC_SDM_PTSA_MAX                                         0x624
-#define MC_SAX_PTSA_RATE                                        0x4b8
-#define MC_PCX_PTSA_MIN                                         0x4b0
-#define MC_APB_PTSA_MIN                                         0x4ec
-#define MC_GK2_PTSA_MIN                                         0x614
-#define MC_PCX_PTSA_RATE                                        0x4ac
-#define MC_RING1_PTSA_MAX                                       0x484
-#define MC_HDAPC_PTSA_RATE                                      0x628
-#define MC_MLL_MPCORER_PTSA_MIN                                 0x450
-#define MC_GK2_PTSA_MAX                                         0x618
-#define MC_AUD_PTSA_MAX                                         0x550
-#define MC_GK2_PTSA_RATE                                        0x610
-#define MC_ISP_PTSA_MAX                                         0x4a8
-#define MC_DISB_PTSA_RATE                                       0x428
-#define MC_VE2_PTSA_MAX                                         0x49c
-#define MC_DFD_PTSA_MIN                                         0x638
-#define MC_FTOP_PTSA_RATE                                       0x50c
-#define MC_A9AVPPC_PTSA_RATE                                    0x488
-#define MC_VE2_PTSA_MIN                                         0x498
-#define MC_USBX_PTSA_MAX                                        0x52c
-#define MC_DIS_PTSA_RATE                                        0x41c
-#define MC_USBD_PTSA_MAX                                        0x538
-#define MC_A9AVPPC_PTSA_MAX                                     0x490
-#define MC_USBX_PTSA_RATE                                       0x524
-#define MC_FTOP_PTSA_MAX                                        0x514
-#define MC_HDAPC_PTSA_MAX                                       0x630
-#define MC_SD_PTSA_RATE                                         0x4d0
-#define MC_DFD_PTSA_RATE                                        0x634
-#define MC_FTOP_PTSA_MIN                                        0x510
-#define MC_SDM_PTSA_RATE                                        0x61c
-#define MC_AHB_PTSA_RATE                                        0x4dc
-#define MC_SMMU_SMMU_PTSA_MAX                                   0x460
-#define MC_RING2_PTSA_MIN                                       0x444
-#define MC_SDM_PTSA_MIN                                         0x620
-#define MC_APB_PTSA_RATE                                        0x4e8
-#define MC_MSE_PTSA_MIN                                         0x4c8
-#define MC_HOST_PTSA_RATE                                       0x518
-#define MC_VE_PTSA_RATE                                         0x434
-#define MC_AHB_PTSA_MAX                                         0x4e4
-#define MC_SAX_PTSA_MIN                                         0x4bc
-#define MC_SMMU_SMMU_PTSA_MIN                                   0x45c
-#define MC_ISP_PTSA_MIN                                         0x4a4
-#define MC_HOST_PTSA_MAX                                        0x520
-#define MC_SAX_PTSA_MAX                                         0x4c0
-#define MC_VE_PTSA_MIN                                          0x438
-#define MC_GK_PTSA_MIN                                          0x540
-#define MC_MSE_PTSA_MAX                                         0x4cc
-#define MC_DISB_PTSA_MAX                                        0x430
-#define MC_DISB_PTSA_MIN                                        0x42c
-#define MC_SMMU_SMMU_PTSA_RATE                                  0x458
-#define MC_VE2_PTSA_RATE                                        0x494
-#define MC_GK_PTSA_RATE                                         0x53c
-#define MC_PTSA_GRANT_DECREMENT                                 0x960
-#define MC_LATENCY_ALLOWANCE_AVPC_0                             0x2e4
-#define MC_LATENCY_ALLOWANCE_AXIAP_0                            0x3a0
-#define MC_LATENCY_ALLOWANCE_XUSB_1                             0x380
-#define MC_LATENCY_ALLOWANCE_ISP2B_0                            0x384
-#define MC_LATENCY_ALLOWANCE_SDMMCAA_0                          0x3bc
-#define MC_LATENCY_ALLOWANCE_SDMMCA_0                           0x3b8
-#define MC_LATENCY_ALLOWANCE_ISP2_0                             0x370
-#define MC_LATENCY_ALLOWANCE_SE_0                               0x3e0
-#define MC_LATENCY_ALLOWANCE_ISP2_1                             0x374
-#define MC_LATENCY_ALLOWANCE_DC_0                               0x2e8
-#define MC_LATENCY_ALLOWANCE_VIC_0                              0x394
-#define MC_LATENCY_ALLOWANCE_DCB_1                              0x2f8
-#define MC_LATENCY_ALLOWANCE_NVDEC_0                            0x3d8
-#define MC_LATENCY_ALLOWANCE_DCB_2                              0x2fc
-#define MC_LATENCY_ALLOWANCE_TSEC_0                             0x390
-#define MC_LATENCY_ALLOWANCE_DC_2                               0x2f0
-#define MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB                  0x694
-#define MC_LATENCY_ALLOWANCE_PPCS_1                             0x348
-#define MC_LATENCY_ALLOWANCE_XUSB_0                             0x37c
-#define MC_LATENCY_ALLOWANCE_PPCS_0                             0x344
-#define MC_LATENCY_ALLOWANCE_TSECB_0                            0x3f0
-#define MC_LATENCY_ALLOWANCE_AFI_0                              0x2e0
-#define MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B                   0x698
-#define MC_LATENCY_ALLOWANCE_DC_1                               0x2ec
-#define MC_LATENCY_ALLOWANCE_APE_0                              0x3dc
-#define MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C                   0x6a0
-#define MC_LATENCY_ALLOWANCE_A9AVP_0                            0x3a4
-#define MC_LATENCY_ALLOWANCE_GPU2_0                             0x3e8
-#define MC_LATENCY_ALLOWANCE_DCB_0                              0x2f4
-#define MC_LATENCY_ALLOWANCE_HC_1                               0x314
-#define MC_LATENCY_ALLOWANCE_SDMMC_0                            0x3c0
-#define MC_LATENCY_ALLOWANCE_NVJPG_0                            0x3e4
-#define MC_LATENCY_ALLOWANCE_PTC_0                              0x34c
-#define MC_LATENCY_ALLOWANCE_ETR_0                              0x3ec
-#define MC_LATENCY_ALLOWANCE_MPCORE_0                           0x320
-#define MC_LATENCY_ALLOWANCE_VI2_0                              0x398
-#define MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB                  0x69c
-#define MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB                  0x6a4
-#define MC_LATENCY_ALLOWANCE_SATA_0                             0x350
-#define MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A                   0x690
-#define MC_LATENCY_ALLOWANCE_HC_0                               0x310
-#define MC_LATENCY_ALLOWANCE_DC_3                               0x3c8
-#define MC_LATENCY_ALLOWANCE_GPU_0                              0x3ac
-#define MC_LATENCY_ALLOWANCE_SDMMCAB_0                          0x3c4
-#define MC_LATENCY_ALLOWANCE_ISP2B_1                            0x388
-#define MC_LATENCY_ALLOWANCE_NVENC_0                            0x328
-#define MC_LATENCY_ALLOWANCE_HDA_0                              0x318
-#define MC_MIN_LENGTH_APE_0                                     0xb34
-#define MC_MIN_LENGTH_DCB_2                                     0x8a8
-#define MC_MIN_LENGTH_A9AVP_0                                   0x950
-#define MC_MIN_LENGTH_TSEC_0                                    0x93c
-#define MC_MIN_LENGTH_DC_1                                      0x898
-#define MC_MIN_LENGTH_AXIAP_0                                   0x94c
-#define MC_MIN_LENGTH_ISP2B_0                                   0x930
-#define MC_MIN_LENGTH_VI2_0                                     0x944
-#define MC_MIN_LENGTH_DCB_0                                     0x8a0
-#define MC_MIN_LENGTH_DCB_1                                     0x8a4
-#define MC_MIN_LENGTH_PPCS_1                                    0x8f4
-#define MC_MIN_LENGTH_NVJPG_0                                   0xb3c
-#define MC_MIN_LENGTH_HDA_0                                     0x8c4
-#define MC_MIN_LENGTH_NVENC_0                                   0x8d4
-#define MC_MIN_LENGTH_SDMMC_0                                   0xb18
-#define MC_MIN_LENGTH_ISP2B_1                                   0x934
-#define MC_MIN_LENGTH_HC_1                                      0x8c0
-#define MC_MIN_LENGTH_DC_3                                      0xb20
-#define MC_MIN_LENGTH_AVPC_0                                    0x890
-#define MC_MIN_LENGTH_VIC_0                                     0x940
-#define MC_MIN_LENGTH_ISP2_0                                    0x91c
-#define MC_MIN_LENGTH_HC_0                                      0x8bc
-#define MC_MIN_LENGTH_SE_0                                      0xb38
-#define MC_MIN_LENGTH_NVDEC_0                                   0xb30
-#define MC_MIN_LENGTH_SATA_0                                    0x8fc
-#define MC_MIN_LENGTH_DC_0                                      0x894
-#define MC_MIN_LENGTH_XUSB_1                                    0x92c
-#define MC_MIN_LENGTH_DC_2                                      0x89c
-#define MC_MIN_LENGTH_SDMMCAA_0                                 0xb14
-#define MC_MIN_LENGTH_GPU_0                                     0xb04
-#define MC_MIN_LENGTH_ETR_0                                     0xb44
-#define MC_MIN_LENGTH_AFI_0                                     0x88c
-#define MC_MIN_LENGTH_PPCS_0                                    0x8f0
-#define MC_MIN_LENGTH_ISP2_1                                    0x920
-#define MC_MIN_LENGTH_XUSB_0                                    0x928
-#define MC_MIN_LENGTH_MPCORE_0                                  0x8cc
-#define MC_MIN_LENGTH_TSECB_0                                   0xb48
-#define MC_MIN_LENGTH_SDMMCA_0                                  0xb10
-#define MC_MIN_LENGTH_GPU2_0                                    0xb40
-#define MC_MIN_LENGTH_SDMMCAB_0                                 0xb1c
-#define MC_MIN_LENGTH_PTC_0                                     0x8f8
-#define MC_EMEM_ARB_OVERRIDE_1                                  0x968
-#define MC_VIDEO_PROTECT_GPU_OVERRIDE_0                         0x984
-#define MC_VIDEO_PROTECT_GPU_OVERRIDE_1                         0x988
-#define MC_EMEM_ARB_STATS_0                                     0x990
-#define MC_EMEM_ARB_STATS_1                                     0x994
-#define MC_MTS_CARVEOUT_BOM                                     0x9a0
-#define MC_MTS_CARVEOUT_SIZE_MB                                 0x9a4
-#define MC_MTS_CARVEOUT_ADR_HI                                  0x9a8
-#define MC_MTS_CARVEOUT_REG_CTRL                                0x9ac
-#define MC_ERR_MTS_STATUS                                       0x9b0
-#define MC_ERR_MTS_ADR                                          0x9b4
-#define MC_ERR_GENERALIZED_CARVEOUT_STATUS                      0xc00
-#define MC_ERR_GENERALIZED_CARVEOUT_ADR                         0xc04
-#define MC_SECURITY_CARVEOUT5_CLIENT_FORCE_INTERNAL_ACCESS2     0xd74
-#define MC_SECURITY_CARVEOUT4_CFG0                              0xcf8
-#define MC_SECURITY_CARVEOUT4_CLIENT_ACCESS2                    0xd10
-#define MC_SECURITY_CARVEOUT4_SIZE_128KB                        0xd04
-#define MC_SECURITY_CARVEOUT1_CLIENT_ACCESS4                    0xc28
-#define MC_SECURITY_CARVEOUT1_CLIENT_FORCE_INTERNAL_ACCESS1     0xc30
-#define MC_SECURITY_CARVEOUT2_CLIENT_FORCE_INTERNAL_ACCESS4     0xc8c
-#define MC_SECURITY_CARVEOUT4_CLIENT_FORCE_INTERNAL_ACCESS0     0xd1c
-#define MC_SECURITY_CARVEOUT5_CLIENT_FORCE_INTERNAL_ACCESS1     0xd70
-#define MC_SECURITY_CARVEOUT1_CLIENT_FORCE_INTERNAL_ACCESS0     0xc2c
-#define MC_SECURITY_CARVEOUT5_CLIENT_FORCE_INTERNAL_ACCESS4     0xd7c
-#define MC_SECURITY_CARVEOUT3_SIZE_128KB                        0xcb4
-#define MC_SECURITY_CARVEOUT2_CFG0                              0xc58
-#define MC_SECURITY_CARVEOUT1_CFG0                              0xc08
-#define MC_SECURITY_CARVEOUT2_CLIENT_FORCE_INTERNAL_ACCESS2     0xc84
-#define MC_SECURITY_CARVEOUT2_CLIENT_ACCESS0                    0xc68
-#define MC_SECURITY_CARVEOUT3_BOM                               0xcac
-#define MC_SECURITY_CARVEOUT2_CLIENT_ACCESS2                    0xc70
-#define MC_SECURITY_CARVEOUT5_CLIENT_FORCE_INTERNAL_ACCESS3     0xd78
-#define MC_SECURITY_CARVEOUT2_CLIENT_FORCE_INTERNAL_ACCESS0     0xc7c
-#define MC_SECURITY_CARVEOUT4_CLIENT_ACCESS4                    0xd18
-#define MC_SECURITY_CARVEOUT3_CLIENT_ACCESS1                    0xcbc
-#define MC_SECURITY_CARVEOUT1_CLIENT_FORCE_INTERNAL_ACCESS3     0xc38
-#define MC_SECURITY_CARVEOUT1_CLIENT_FORCE_INTERNAL_ACCESS2     0xc34
-#define MC_SECURITY_CARVEOUT3_CLIENT_ACCESS2                    0xcc0
-#define MC_SECURITY_CARVEOUT5_CLIENT_ACCESS2                    0xd60
-#define MC_SECURITY_CARVEOUT3_CFG0                              0xca8
-#define MC_SECURITY_CARVEOUT3_CLIENT_ACCESS0                    0xcb8
-#define MC_SECURITY_CARVEOUT2_CLIENT_FORCE_INTERNAL_ACCESS3     0xc88
-#define MC_SECURITY_CARVEOUT2_SIZE_128KB                        0xc64
-#define MC_SECURITY_CARVEOUT5_BOM_HI                            0xd50
-#define MC_SECURITY_CARVEOUT1_SIZE_128KB                        0xc14
-#define MC_SECURITY_CARVEOUT4_CLIENT_ACCESS3                    0xd14
-#define MC_SECURITY_CARVEOUT1_BOM                               0xc0c
-#define MC_SECURITY_CARVEOUT4_CLIENT_FORCE_INTERNAL_ACCESS4     0xd2c
-#define MC_SECURITY_CARVEOUT5_CLIENT_ACCESS4                    0xd68
-#define MC_SECURITY_CARVEOUT3_CLIENT_ACCESS4                    0xcc8
-#define MC_SECURITY_CARVEOUT5_CLIENT_ACCESS0                    0xd58
-#define MC_SECURITY_CARVEOUT4_CLIENT_FORCE_INTERNAL_ACCESS2     0xd24
-#define MC_SECURITY_CARVEOUT3_CLIENT_ACCESS3                    0xcc4
-#define MC_SECURITY_CARVEOUT2_CLIENT_ACCESS4                    0xc78
-#define MC_SECURITY_CARVEOUT1_CLIENT_ACCESS1                    0xc1c
-#define MC_SECURITY_CARVEOUT1_CLIENT_ACCESS0                    0xc18
-#define MC_SECURITY_CARVEOUT4_CLIENT_FORCE_INTERNAL_ACCESS3     0xd28
-#define MC_SECURITY_CARVEOUT5_CLIENT_ACCESS1                    0xd5c
-#define MC_SECURITY_CARVEOUT3_BOM_HI                            0xcb0
-#define MC_SECURITY_CARVEOUT3_CLIENT_FORCE_INTERNAL_ACCESS3     0xcd8
-#define MC_SECURITY_CARVEOUT2_BOM_HI                            0xc60
-#define MC_SECURITY_CARVEOUT4_BOM_HI                            0xd00
-#define MC_SECURITY_CARVEOUT5_CLIENT_ACCESS3                    0xd64
-#define MC_SECURITY_CARVEOUT3_CLIENT_FORCE_INTERNAL_ACCESS4     0xcdc
-#define MC_SECURITY_CARVEOUT2_CLIENT_FORCE_INTERNAL_ACCESS1     0xc80
-#define MC_SECURITY_CARVEOUT5_SIZE_128KB                        0xd54
-#define MC_SECURITY_CARVEOUT4_CLIENT_FORCE_INTERNAL_ACCESS1     0xd20
-#define MC_SECURITY_CARVEOUT3_CLIENT_FORCE_INTERNAL_ACCESS2     0xcd4
-#define MC_SECURITY_CARVEOUT4_CLIENT_ACCESS1                    0xd0c
-#define MC_SECURITY_CARVEOUT2_CLIENT_ACCESS3                    0xc74
-#define MC_SECURITY_CARVEOUT3_CLIENT_FORCE_INTERNAL_ACCESS0     0xccc
-#define MC_SECURITY_CARVEOUT4_BOM                               0xcfc
-#define MC_SECURITY_CARVEOUT5_CFG0                              0xd48
-#define MC_SECURITY_CARVEOUT2_BOM                               0xc5c
-#define MC_SECURITY_CARVEOUT5_BOM                               0xd4c
-#define MC_SECURITY_CARVEOUT1_CLIENT_ACCESS3                    0xc24
-#define MC_SECURITY_CARVEOUT5_CLIENT_FORCE_INTERNAL_ACCESS0     0xd6c
-#define MC_SECURITY_CARVEOUT3_CLIENT_FORCE_INTERNAL_ACCESS1     0xcd0
-#define MC_SECURITY_CARVEOUT1_BOM_HI                            0xc10
-#define MC_SECURITY_CARVEOUT1_CLIENT_ACCESS2                    0xc20
-#define MC_SECURITY_CARVEOUT1_CLIENT_FORCE_INTERNAL_ACCESS4     0xc3c
-#define MC_SECURITY_CARVEOUT2_CLIENT_ACCESS1                    0xc6c
-#define MC_SECURITY_CARVEOUT4_CLIENT_ACCESS0                    0xd08
-#define MC_ERR_APB_ASID_UPDATE_STATUS                           0x9d0
-#define MC_DA_CONFIG0                                           0x9dc

libraries/libmesosphere/source/board/nintendo/nx/kern_pmc_registers.hpp

@@ -1,21 +0,0 @@
-/*
- * Copyright (c) 2018-2020 Atmosphère-NX
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-#pragma once
-
-#define APBDEV_PMC_DPD_ENABLE 0x024
-#define APBDEV_PMC_SCRATCH0   0x050
-#define APBDEV_PMC_SCRATCH4   0x060
-#define APBDEV_PMC_SCRATCH39  0x138

libraries/libmesosphere/source/board/nintendo/nx/kern_secure_monitor.cpp

@@ -37,6 +37,9 @@ namespace ams::kern::board::nintendo::nx::smc {
             FunctionId_Panic               = 0xC3000006,
             FunctionId_ConfigureCarveout   = 0xC3000007,
             FunctionId_ReadWriteRegister   = 0xC3000008,
+
+            /* NOTE: Atmosphere extension for mesosphere. This ID is subject to change at any time. */
+            FunctionId_SetConfig           = 0xC3000409,
         };
 
         void CallPrivilegedSecureMonitorFunction(SecureMonitorArguments &args) {
@@ -140,35 +143,6 @@ namespace ams::kern::board::nintendo::nx::smc {
             args.x[7] = x7;
         }
 
-        void CallUserSecureMonitorFunctionForInit(SecureMonitorArguments &args) {
-            /* Load arguments into registers. */
-            register u64 x0 asm("x0") = args.x[0];
-            register u64 x1 asm("x1") = args.x[1];
-            register u64 x2 asm("x2") = args.x[2];
-            register u64 x3 asm("x3") = args.x[3];
-            register u64 x4 asm("x4") = args.x[4];
-            register u64 x5 asm("x5") = args.x[5];
-            register u64 x6 asm("x6") = args.x[6];
-            register u64 x7 asm("x7") = args.x[7];
-
-            /* Actually make the call. */
-            __asm__ __volatile__("smc #0"
-                                : "+r"(x0), "+r"(x1), "+r"(x2), "+r"(x3), "+r"(x4), "+r"(x5), "+r"(x6), "+r"(x7)
-                                :
-                                : "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "cc", "memory"
-                                );
-
-            /* Store arguments to output. */
-            args.x[0] = x0;
-            args.x[1] = x1;
-            args.x[2] = x2;
-            args.x[3] = x3;
-            args.x[4] = x4;
-            args.x[5] = x5;
-            args.x[6] = x6;
-            args.x[7] = x7;
-        }
-
         /* Global lock for generate random bytes. */
         KSpinLock g_generate_random_lock;
 
@@ -210,21 +184,30 @@ namespace ams::kern::board::nintendo::nx::smc {
             return static_cast<SmcResult>(args.x[0]) == SmcResult::Success;
         }
 
-        bool SetConfig(ConfigItem config_item, u64 value) {
-            SecureMonitorArguments args = { UserFunctionId_SetConfig, static_cast<u32>(config_item), 0, value };
-            CallUserSecureMonitorFunctionForInit(args);
-            return static_cast<SmcResult>(args.x[0]) == SmcResult::Success;
-        }
-
     }
 
-    void GetConfig(u64 *out, size_t num_qwords, ConfigItem config_item) {
+    bool TryGetConfig(u64 *out, size_t num_qwords, ConfigItem config_item) {
         SecureMonitorArguments args = { FunctionId_GetConfig, static_cast<u32>(config_item) };
         CallPrivilegedSecureMonitorFunction(args);
-        MESOSPHERE_ABORT_UNLESS((static_cast<SmcResult>(args.x[0]) == SmcResult::Success));
+        if (static_cast<SmcResult>(args.x[0]) != SmcResult::Success) {
+            return false;
+        }
+
         for (size_t i = 0; i < num_qwords && i < 7; i++) {
             out[i] = args.x[1 + i];
         }
+
+        return true;
+    }
+
+    void GetConfig(u64 *out, size_t num_qwords, ConfigItem config_item) {
+        MESOSPHERE_ABORT_UNLESS(TryGetConfig(out, num_qwords, config_item));
+    }
+
+    bool SetConfig(ConfigItem config_item, u64 value) {
+        SecureMonitorArguments args = { FunctionId_SetConfig, static_cast<u32>(config_item), 0, value };
+        CallPrivilegedSecureMonitorFunction(args);
+        return static_cast<SmcResult>(args.x[0]) == SmcResult::Success;
     }
 
     bool ReadWriteRegister(u32 *out, ams::svc::PhysicalAddress address, u32 mask, u32 value) {

libraries/libmesosphere/source/board/nintendo/nx/kern_secure_monitor.hpp

@@ -60,6 +60,10 @@ namespace ams::kern::board::nintendo::nx::smc {
         ExosphereNeedsShutdown  = 65002,
         ExosphereGitCommitHash  = 65003,
         ExosphereHasRcmBugPatch = 65004,
+        ExosphereBlankProdInfo  = 65005,
+        ExosphereAllowCalWrites = 65006,
+        ExosphereEmummcType     = 65007,
+        ExospherePayloadAddress = 65008,
     };
 
     enum class SmcResult {
@@ -89,12 +93,14 @@ namespace ams::kern::board::nintendo::nx::smc {
         UserRebootType_ToPayload = 2,
     };
 
-    /* TODO: Rest of Secure Monitor API. */
     void GenerateRandomBytes(void *dst, size_t size);
+    bool TryGetConfig(u64 *out, size_t num_qwords, ConfigItem config_item);
     void GetConfig(u64 *out, size_t num_qwords, ConfigItem config_item);
     bool ReadWriteRegister(u32 *out, ams::svc::PhysicalAddress address, u32 mask, u32 value);
     void ConfigureCarveout(size_t which, uintptr_t address, size_t size);
 
+    bool SetConfig(ConfigItem config_item, u64 value);
+
     void CpuOn(u64 core_id, uintptr_t entrypoint, uintptr_t arg);
 
     void NORETURN Panic(u32 color);
@@ -108,8 +114,6 @@ namespace ams::kern::board::nintendo::nx::smc {
         void GenerateRandomBytes(void *dst, size_t size);
         bool ReadWriteRegister(u32 *out, u64 address, u32 mask, u32 value);
 
-        bool SetConfig(ConfigItem config_item, u64 value);
-
     }
 
 }

libraries/libmesosphere/source/kern_debug_log.cpp

@@ -17,386 +17,9 @@
 #include "kern_debug_log_impl.hpp"
 
 namespace ams::kern {
-    #pragma GCC push_options
-    #pragma GCC optimize ("-Os")
 
     namespace {
 
-        /* Useful definitions for our VSNPrintf implementation. */
-        enum FormatSpecifierFlag : u32 {
-            FormatSpecifierFlag_None         = 0,
-            FormatSpecifierFlag_EmptySign    = (1 << 0),
-            FormatSpecifierFlag_ForceSign    = (1 << 1),
-            FormatSpecifierFlag_Hash         = (1 << 2),
-            FormatSpecifierFlag_LeftJustify  = (1 << 3),
-            FormatSpecifierFlag_ZeroPad      = (1 << 4),
-            FormatSpecifierFlag_Char         = (1 << 5),
-            FormatSpecifierFlag_Short        = (1 << 6),
-            FormatSpecifierFlag_Long         = (1 << 7),
-            FormatSpecifierFlag_LongLong     = (1 << 8),
-            FormatSpecifierFlag_Uppercase    = (1 << 9),
-            FormatSpecifierFlag_HasPrecision = (1 << 10),
-        };
-
-        using FormatSpecifierFlagStorage = std::underlying_type<FormatSpecifierFlag>::type;
-
-        constexpr ALWAYS_INLINE bool IsDigit(char c) {
-            return '0' <= c && c <= '9';
-        }
-
-        constexpr ALWAYS_INLINE u32 ParseU32(const char *&str) {
-            u32 value = 0;
-            do {
-                value = (value * 10) + static_cast<u32>(*(str++) - '0');
-            } while (IsDigit(*str));
-            return value;
-        }
-
-        constexpr ALWAYS_INLINE size_t Strnlen(const char *str, size_t max) {
-            const char *cur = str;
-            while (*cur && max--) {
-                cur++;
-            }
-            return static_cast<size_t>(cur - str);
-        }
-
-        ALWAYS_INLINE void VSNPrintfImpl(char * const dst, const size_t dst_size, const char *format, ::std::va_list vl) {
-            size_t dst_index = 0;
-
-            auto WriteCharacter = [dst, dst_size, &dst_index](char c) ALWAYS_INLINE_LAMBDA {
-                if (dst_index < dst_size) {
-                    dst[dst_index++] = c;
-                }
-            };
-
-            /* Loop over every character in the string, looking for format specifiers. */
-            while (*format) {
-                if (const char c = *(format++); c != '%') {
-                    WriteCharacter(c);
-                    continue;
-                }
-
-                /* We have to parse a format specifier. */
-                /* Start by parsing flags. */
-                FormatSpecifierFlagStorage flags = FormatSpecifierFlag_None;
-                auto SetFlag   = [&flags](FormatSpecifierFlag f) ALWAYS_INLINE_LAMBDA { flags |= f; };
-                auto ClearFlag = [&flags](FormatSpecifierFlag f) ALWAYS_INLINE_LAMBDA { flags &= ~f; };
-                auto HasFlag   = [&flags](FormatSpecifierFlag f) ALWAYS_INLINE_LAMBDA { return (flags & f) != 0; };
-                {
-                    bool parsed_flags = false;
-                    while (!parsed_flags) {
-                        switch (*format) {
-                            case ' ': SetFlag(FormatSpecifierFlag_EmptySign);   format++; break;
-                            case '+': SetFlag(FormatSpecifierFlag_ForceSign);   format++; break;
-                            case '#': SetFlag(FormatSpecifierFlag_Hash);        format++; break;
-                            case '-': SetFlag(FormatSpecifierFlag_LeftJustify); format++; break;
-                            case '0': SetFlag(FormatSpecifierFlag_ZeroPad);     format++; break;
-                            default:
-                                parsed_flags = true;
-                                break;
-                        }
-                    }
-                }
-
-                /* Next, parse width. */
-                u32 width = 0;
-                if (IsDigit(*format)) {
-                    /* Integer width. */
-                    width = ParseU32(format);
-                } else if (*format == '*') {
-                    /* Dynamic width. */
-                    const int _width = va_arg(vl, int);
-                    if (_width >= 0) {
-                        width = static_cast<u32>(_width);
-                    } else {
-                        SetFlag(FormatSpecifierFlag_LeftJustify);
-                        width = static_cast<u32>(-_width);
-                    }
-                    format++;
-                }
-
-                /* Next, parse precision if present. */
-                u32 precision = 0;
-                if (*format == '.') {
-                    SetFlag(FormatSpecifierFlag_HasPrecision);
-                    format++;
-
-                    if (IsDigit(*format)) {
-                        /* Integer precision. */
-                        precision = ParseU32(format);
-                    } else if (*format == '*') {
-                        /* Dynamic precision. */
-                        const int _precision = va_arg(vl, int);
-                        if (_precision > 0) {
-                            precision = static_cast<u32>(_precision);
-                        }
-                        format++;
-                    }
-                }
-
-                /* Parse length. */
-                constexpr bool SizeIsLong    = sizeof(size_t)    == sizeof(long);
-                constexpr bool IntMaxIsLong  = sizeof(intmax_t)  == sizeof(long);
-                constexpr bool PtrDiffIsLong = sizeof(ptrdiff_t) == sizeof(long);
-                switch (*format) {
-                    case 'z':
-                        SetFlag(SizeIsLong    ? FormatSpecifierFlag_Long : FormatSpecifierFlag_LongLong);
-                        format++;
-                        break;
-                    case 'j':
-                        SetFlag(IntMaxIsLong  ? FormatSpecifierFlag_Long : FormatSpecifierFlag_LongLong);
-                        format++;
-                        break;
-                    case 't':
-                        SetFlag(PtrDiffIsLong ? FormatSpecifierFlag_Long : FormatSpecifierFlag_LongLong);
-                        format++;
-                        break;
-                    case 'h':
-                        SetFlag(FormatSpecifierFlag_Short);
-                        format++;
-                        if (*format == 'h') {
-                            SetFlag(FormatSpecifierFlag_Char);
-                            format++;
-                        }
-                        break;
-                    case 'l':
-                        SetFlag(FormatSpecifierFlag_Long);
-                        format++;
-                        if (*format == 'l') {
-                            SetFlag(FormatSpecifierFlag_LongLong);
-                            format++;
-                        }
-                        break;
-                    default:
-                        break;
-                }
-
-                const char specifier = *(format++);
-                switch (specifier) {
-                    case 'p':
-                        if constexpr (sizeof(uintptr_t) == sizeof(long long)) {
-                            SetFlag(FormatSpecifierFlag_LongLong);
-                        } else {
-                            SetFlag(FormatSpecifierFlag_Long);
-                        }
-                        SetFlag(FormatSpecifierFlag_Hash);
-                        [[fallthrough]];
-                    case 'd':
-                    case 'i':
-                    case 'u':
-                    case 'b':
-                    case 'o':
-                    case 'x':
-                    case 'X':
-                        {
-                            /* Determine the base to print with. */
-                            u32 base;
-                            switch (specifier) {
-                                case 'b':
-                                    base = 2;
-                                    break;
-                                case 'o':
-                                    base = 8;
-                                    break;
-                                case 'X':
-                                    SetFlag(FormatSpecifierFlag_Uppercase);
-                                    [[fallthrough]];
-                                case 'p':
-                                case 'x':
-                                    base = 16;
-                                    break;
-                                default:
-                                    base = 10;
-                                    ClearFlag(FormatSpecifierFlag_Hash);
-                                    break;
-                            }
-
-                            /* Precision implies no zero-padding. */
-                            if (HasFlag(FormatSpecifierFlag_HasPrecision)) {
-                                ClearFlag(FormatSpecifierFlag_ZeroPad);
-                            }
-
-                            /* Unsigned types don't get signs. */
-                            const bool is_unsigned = base != 10 || specifier == 'u';
-                            if (is_unsigned) {
-                                ClearFlag(FormatSpecifierFlag_EmptySign);
-                                ClearFlag(FormatSpecifierFlag_ForceSign);
-                            }
-
-                            auto PrintInteger = [&](bool negative, uintmax_t value) {
-                                constexpr size_t BufferSize = 64; /* Binary digits for 64-bit numbers may use 64 digits. */
-                                char buf[BufferSize];
-                                size_t len = 0;
-
-                                /* No hash flag for zero. */
-                                if (value == 0) {
-                                    ClearFlag(FormatSpecifierFlag_Hash);
-                                }
-
-                                if (!HasFlag(FormatSpecifierFlag_HasPrecision) || value != 0) {
-                                    do {
-                                        const char digit = static_cast<char>(value % base);
-                                        buf[len++] = (digit < 10) ? ('0' + digit) : ((HasFlag(FormatSpecifierFlag_Uppercase) ? 'A' : 'a') + digit - 10);
-                                        value /= base;
-                                    } while (value);
-                                }
-
-                                /* Determine our prefix length. */
-                                size_t prefix_len = 0;
-                                const bool has_sign = negative || HasFlag(FormatSpecifierFlag_ForceSign) || HasFlag(FormatSpecifierFlag_EmptySign);
-                                if (has_sign) {
-                                    prefix_len++;
-                                }
-                                if (HasFlag(FormatSpecifierFlag_Hash)) {
-                                    prefix_len += (base != 8) ? 2 : 1;
-                                }
-
-                                /* Determine zero-padding count. */
-                                size_t num_zeroes = (len < precision) ? precision - len : 0;
-                                if (!HasFlag(FormatSpecifierFlag_LeftJustify) && HasFlag(FormatSpecifierFlag_ZeroPad)) {
-                                    num_zeroes = (len + prefix_len < width) ? width - len - prefix_len : 0;
-                                }
-
-                                /* Print out left padding. */
-                                if (!HasFlag(FormatSpecifierFlag_LeftJustify)) {
-                                    for (size_t i = len + prefix_len + num_zeroes; i < static_cast<size_t>(width); i++) {
-                                        WriteCharacter(' ');
-                                    }
-                                }
-
-                                /* Print out sign. */
-                                if (negative) {
-                                    WriteCharacter('-');
-                                } else if (HasFlag(FormatSpecifierFlag_ForceSign)) {
-                                    WriteCharacter('+');
-                                } else if (HasFlag(FormatSpecifierFlag_EmptySign)) {
-                                    WriteCharacter(' ');
-                                }
-
-                                /* Print out base prefix. */
-                                if (HasFlag(FormatSpecifierFlag_Hash)) {
-                                    WriteCharacter('0');
-                                    if (base == 2) {
-                                        WriteCharacter('b');
-                                    } else if (base == 16) {
-                                        WriteCharacter('x');
-                                    }
-                                }
-
-                                /* Print out zeroes. */
-                                for (size_t i = 0; i < num_zeroes; i++) {
-                                    WriteCharacter('0');
-                                }
-
-                                /* Print out digits. */
-                                for (size_t i = 0; i < len; i++) {
-                                    WriteCharacter(buf[len - 1 - i]);
-                                }
-
-                                /* Print out right padding. */
-                                if (HasFlag(FormatSpecifierFlag_LeftJustify)) {
-                                    for (size_t i = len + prefix_len + num_zeroes; i < static_cast<size_t>(width); i++) {
-                                        WriteCharacter(' ');
-                                    }
-                                }
-                            };
-
-                            /* Output the integer. */
-                            if (is_unsigned) {
-                                uintmax_t n = 0;
-                                if (HasFlag(FormatSpecifierFlag_LongLong)) {
-                                    n = static_cast<unsigned long long>(va_arg(vl, unsigned long long));
-                                } else if (HasFlag(FormatSpecifierFlag_Long)) {
-                                    n = static_cast<unsigned long>(va_arg(vl, unsigned long));
-                                } else if (HasFlag(FormatSpecifierFlag_Char)) {
-                                    n = static_cast<unsigned char>(va_arg(vl, unsigned int));
-                                } else if (HasFlag(FormatSpecifierFlag_Short)) {
-                                    n = static_cast<unsigned short>(va_arg(vl, unsigned int));
-                                } else {
-                                    n = static_cast<unsigned int>(va_arg(vl, unsigned int));
-                                }
-                                if (specifier == 'p' && n == 0) {
-                                    WriteCharacter('(');
-                                    WriteCharacter('n');
-                                    WriteCharacter('i');
-                                    WriteCharacter('l');
-                                    WriteCharacter(')');
-                                } else {
-                                    PrintInteger(false, n);
-                                }
-                            } else {
-                                intmax_t n = 0;
-                                if (HasFlag(FormatSpecifierFlag_LongLong)) {
-                                    n = static_cast<signed long long>(va_arg(vl, signed long long));
-                                } else if (HasFlag(FormatSpecifierFlag_Long)) {
-                                    n = static_cast<signed long>(va_arg(vl, signed long));
-                                } else if (HasFlag(FormatSpecifierFlag_Char)) {
-                                    n = static_cast<signed char>(va_arg(vl, signed int));
-                                } else if (HasFlag(FormatSpecifierFlag_Short)) {
-                                    n = static_cast<signed short>(va_arg(vl, signed int));
-                                } else {
-                                    n = static_cast<signed int>(va_arg(vl, signed int));
-                                }
-                                const bool negative = n < 0;
-                                const uintmax_t u = (negative) ? static_cast<uintmax_t>(-n) : static_cast<uintmax_t>(n);
-                                PrintInteger(negative, u);
-                            }
-                        }
-                        break;
-                    case 'c':
-                        {
-                            size_t len = 1;
-                            if (!HasFlag(FormatSpecifierFlag_LeftJustify)) {
-                                while (len++ < width) {
-                                    WriteCharacter(' ');
-                                }
-                            }
-                            WriteCharacter(static_cast<char>(va_arg(vl, int)));
-                            if (HasFlag(FormatSpecifierFlag_LeftJustify)) {
-                                while (len++ < width) {
-                                    WriteCharacter(' ');
-                                }
-                            }
-                        }
-                        break;
-                    case 's':
-                        {
-                            const char *str = va_arg(vl, char *);
-                            if (str == nullptr) {
-                                str = "(null)";
-                            }
-
-                            size_t len = Strnlen(str, precision > 0 ? precision : std::numeric_limits<size_t>::max());
-                            if (HasFlag(FormatSpecifierFlag_HasPrecision)) {
-                                len = (len < precision) ? len : precision;
-                            }
-                            if (!HasFlag(FormatSpecifierFlag_LeftJustify)) {
-                                while (len++ < width) {
-                                    WriteCharacter(' ');
-                                }
-                            }
-                            while (*str && (!HasFlag(FormatSpecifierFlag_HasPrecision) || (precision--) != 0)) {
-                                WriteCharacter(*(str++));
-                            }
-                            if (HasFlag(FormatSpecifierFlag_LeftJustify)) {
-                                while (len++ < width) {
-                                    WriteCharacter(' ');
-                                }
-                            }
-                        }
-                        break;
-                    case '%':
-                    default:
-                        WriteCharacter(specifier);
-                        break;
-                }
-            }
-
-            /* Ensure null termination. */
-            WriteCharacter('\0');
-            dst[dst_size - 1] = '\0';
-        }
-
         KSpinLock g_debug_log_lock;
         bool      g_initialized_impl;
 
@@ -452,9 +75,6 @@ namespace ams::kern {
 
     }
 
-
-    #pragma GCC pop_options
-
     void KDebugLog::Initialize() {
         if (KTargetSystem::IsDebugLoggingEnabled()) {
             KScopedInterruptDisable di;
@@ -486,7 +106,7 @@ namespace ams::kern {
     }
 
     void KDebugLog::VSNPrintf(char *dst, const size_t dst_size, const char *format, ::std::va_list vl) {
-        VSNPrintfImpl(dst, dst_size, format, vl);
+        ::ams::util::TVSNPrintf(dst, dst_size, format, vl);
     }
 
     Result KDebugLog::PrintUserString(ams::kern::svc::KUserPointer<const char *> user_str, size_t len) {

libraries/libmesosphere/source/kern_k_address_arbiter.cpp

@@ -73,15 +73,16 @@ namespace ams::kern {
         s32 num_waiters = 0;
         {
             KScopedSchedulerLock sl;
-            g_cv_arbiter_compare_thread.SetupForAddressArbiterCompare(addr, -1);
-
-            auto it = this->tree.nfind(g_cv_arbiter_compare_thread);
 
             /* Check the userspace value. */
             s32 user_value;
             R_UNLESS(UpdateIfEqual(std::addressof(user_value), addr, value, value + 1), svc::ResultInvalidCurrentMemory());
             R_UNLESS(user_value == value,                                               svc::ResultInvalidState());
 
+            g_cv_arbiter_compare_thread.SetupForAddressArbiterCompare(addr, -1);
+
+            auto it = this->tree.nfind(g_cv_arbiter_compare_thread);
+
             while ((it != this->tree.end()) && (count <= 0 || num_waiters < count) && (it->GetAddressArbiterKey() == addr)) {
                 KThread *target_thread = std::addressof(*it);
                 target_thread->SetSyncedObject(nullptr, ResultSuccess());
@@ -108,26 +109,54 @@ namespace ams::kern {
 
             /* Determine the updated value. */
             s32 new_value;
-            if (count <= 0) {
-                if ((it != this->tree.end()) && (it->GetAddressArbiterKey() == addr)) {
-                    new_value = value - 1;
+            if (GetTargetFirmware() >= TargetFirmware_7_0_0) {
+                if (count <= 0) {
+                    if ((it != this->tree.end()) && (it->GetAddressArbiterKey() == addr)) {
+                        new_value = value - 2;
+                    } else {
+                        new_value = value + 1;
+                    }
                 } else {
-                    new_value = value + 1;
+                    if ((it != this->tree.end()) && (it->GetAddressArbiterKey() == addr)) {
+                        auto tmp_it = it;
+                        s32 tmp_num_waiters = 0;
+                        while ((++tmp_it != this->tree.end()) && (tmp_it->GetAddressArbiterKey() == addr)) {
+                            if ((tmp_num_waiters++) >= count) {
+                                break;
+                            }
+                        }
+
+                        if (tmp_num_waiters < count) {
+                            new_value = value - 1;
+                        } else {
+                            new_value = value;
+                        }
+                    } else {
+                        new_value = value + 1;
+                    }
                 }
             } else {
-                auto tmp_it = it;
-                int tmp_num_waiters = 0;
-                while ((tmp_it != this->tree.end()) && (tmp_it->GetAddressArbiterKey() == addr) && (tmp_num_waiters < count + 1)) {
-                    ++tmp_num_waiters;
-                    ++tmp_it;
-                }
-
-                if (tmp_num_waiters == 0) {
-                    new_value = value + 1;
-                } else if (tmp_num_waiters <= count) {
-                    new_value = value - 1;
+                if (count <= 0) {
+                    if ((it != this->tree.end()) && (it->GetAddressArbiterKey() == addr)) {
+                        new_value = value - 1;
+                    } else {
+                        new_value = value + 1;
+                    }
                 } else {
-                    new_value = value;
+                    auto tmp_it = it;
+                    s32 tmp_num_waiters = 0;
+                    while ((tmp_it != this->tree.end()) && (tmp_it->GetAddressArbiterKey() == addr) && (tmp_num_waiters < count + 1)) {
+                        ++tmp_num_waiters;
+                        ++tmp_it;
+                    }
+
+                    if (tmp_num_waiters == 0) {
+                        new_value = value + 1;
+                    } else if (tmp_num_waiters <= count) {
+                        new_value = value - 1;
+                    } else {
+                        new_value = value;
+                    }
                 }
             }
 

libraries/libmesosphere/source/kern_k_condition_variable.cpp

@@ -205,13 +205,8 @@ namespace ams::kern {
         }
 
         /* Close threads in the list. */
-        if (num_waiters > MaxThreads) {
-            auto it = thread_list.begin();
-            while (it != thread_list.end()) {
-                KThread *thread = std::addressof(*it);
-                thread->Close();
-                it = thread_list.erase(it);
-            }
+        for (auto it = thread_list.begin(); it != thread_list.end(); it = thread_list.erase(it)) {
+            (*it).Close();
         }
     }
 

libraries/libmesosphere/source/kern_k_scoped_disable_dispatch.cpp

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <mesosphere.hpp>
+
+namespace ams::kern {
+
+    KScopedDisableDispatch::~KScopedDisableDispatch() {
+        if (GetCurrentThread().GetDisableDispatchCount() <= 1) {
+            Kernel::GetScheduler().RescheduleCurrentCore();
+        } else {
+            GetCurrentThread().EnableDispatch();
+        }
+    }
+
+}

libraries/libstratosphere/Makefile

@@ -1,7 +1,9 @@
 #---------------------------------------------------------------------------------
 # pull in common atmosphere configuration
 #---------------------------------------------------------------------------------
-include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../config/common.mk
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
+include $(CURRENT_DIRECTORY)/../config/common.mk
 
 #---------------------------------------------------------------------------------
 # pull in switch rules
@@ -15,7 +17,7 @@ include $(DEVKITPRO)/libnx/switch_rules
 #---------------------------------------------------------------------------------
 # options for code generation
 #---------------------------------------------------------------------------------
-PRECOMPILED_HEADERS := $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/include/stratosphere.hpp
+PRECOMPILED_HEADERS := $(CURRENT_DIRECTORY)/include/stratosphere.hpp
 
 DEFINES	    := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_STRATOSPHERE -D_GNU_SOURCE
 SETTINGS    := $(ATMOSPHERE_SETTINGS) -O2
@@ -66,7 +68,7 @@ endif
 
 export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
 export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
-export GCH_FILES    :=	$(foreach hdr,$(PRECOMPILED_HEADERS:.hpp=.gch),$(notdir $(hdr)))
+export GCH_FILES    :=	$(PRECOMPILED_HEADERS:.hpp=.hpp.gch)
 export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
 export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(BINFILES)))
 
@@ -103,12 +105,12 @@ dist: dist-src dist-bin
 #---------------------------------------------------------------------------------
 clean:
 	@echo clean ...
-	@rm -fr release lib *.bz2 include/stratosphere.hpp.gch
+	@rm -fr release lib *.bz2 $(GCH_FILES)
 
 #---------------------------------------------------------------------------------
 else
 
-DEPENDS	:=	$(OFILES:.o=.d) $(GCH_FILES:.gch=.d)
+DEPENDS	:=	$(OFILES:.o=.d) $(foreach hdr,$(GCH_FILES:.hpp.gch=.d),$(notdir $(hdr)))
 
 #---------------------------------------------------------------------------------
 # main targets

libraries/libstratosphere/include/stratosphere.hpp

@@ -41,14 +41,19 @@
 /* At this point, just include the rest alphabetically. */
 /* TODO: Figure out optimal order. */
 #include <stratosphere/boot2.hpp>
+#include <stratosphere/cal.hpp>
 #include <stratosphere/capsrv.hpp>
 #include <stratosphere/cfg.hpp>
+#include <stratosphere/clkrst.hpp>
+#include <stratosphere/ddsf.hpp>
 #include <stratosphere/dmnt.hpp>
 #include <stratosphere/erpt.hpp>
 #include <stratosphere/err.hpp>
 #include <stratosphere/fatal.hpp>
+#include <stratosphere/gpio.hpp>
 #include <stratosphere/hid.hpp>
 #include <stratosphere/hos.hpp>
+#include <stratosphere/i2c.hpp>
 #include <stratosphere/kvdb.hpp>
 #include <stratosphere/ldr.hpp>
 #include <stratosphere/lr.hpp>
@@ -57,10 +62,14 @@
 #include <stratosphere/nim.hpp>
 #include <stratosphere/ns.hpp>
 #include <stratosphere/patcher.hpp>
+#include <stratosphere/pcv.hpp>
 #include <stratosphere/pgl.hpp>
+#include <stratosphere/pinmux.hpp>
+#include <stratosphere/powctl.hpp>
 #include <stratosphere/psc.hpp>
 #include <stratosphere/pm.hpp>
-#include <stratosphere/reg.hpp>
+#include <stratosphere/pwm.hpp>
+#include <stratosphere/regulator.hpp>
 #include <stratosphere/ro.hpp>
 #include <stratosphere/settings.hpp>
 #include <stratosphere/sf.hpp>
@@ -68,6 +77,7 @@
 #include <stratosphere/spl.hpp>
 #include <stratosphere/time.hpp>
 #include <stratosphere/updater.hpp>
+#include <stratosphere/wec.hpp>
 
 /* Include FS last. */
 #include <stratosphere/fs.hpp>

libraries/libstratosphere/include/stratosphere/ams/impl/ams_system_thread_definitions.hpp

@@ -39,19 +39,21 @@ namespace ams::impl {
     AMS_DEFINE_SYSTEM_THREAD(21, pm, Main);
     AMS_DEFINE_SYSTEM_THREAD(21, pm, ProcessTrack);
 
+
     /* NCM. */
     AMS_DEFINE_SYSTEM_THREAD(21, ncm, MainWaitThreads);
     AMS_DEFINE_SYSTEM_THREAD(21, ncm, ContentManagerServerIpcSession);
     AMS_DEFINE_SYSTEM_THREAD(21, ncm, LocationResolverServerIpcSession);
 
     /* FS. */
-    AMS_DEFINE_SYSTEM_THREAD(16, fs, WorkerThreadPool);
-    AMS_DEFINE_SYSTEM_THREAD(17, fs, Main);
-    AMS_DEFINE_SYSTEM_THREAD(17, fs, WorkerRealTimeAccess);
-    AMS_DEFINE_SYSTEM_THREAD(18, fs, WorkerNormalPriorityAccess);
-    AMS_DEFINE_SYSTEM_THREAD(19, fs, WorkerLowPriorityAccess);
-    AMS_DEFINE_SYSTEM_THREAD(30, fs, WorkerBackgroundAccess);
-    AMS_DEFINE_SYSTEM_THREAD(30, fs, PatrolReader);
+    AMS_DEFINE_SYSTEM_THREAD(11, sdmmc, DeviceDetector);
+    AMS_DEFINE_SYSTEM_THREAD(16, fs,    WorkerThreadPool);
+    AMS_DEFINE_SYSTEM_THREAD(17, fs,    Main);
+    AMS_DEFINE_SYSTEM_THREAD(17, fs,    WorkerRealTimeAccess);
+    AMS_DEFINE_SYSTEM_THREAD(18, fs,    WorkerNormalPriorityAccess);
+    AMS_DEFINE_SYSTEM_THREAD(19, fs,    WorkerLowPriorityAccess);
+    AMS_DEFINE_SYSTEM_THREAD(30, fs,    WorkerBackgroundAccess);
+    AMS_DEFINE_SYSTEM_THREAD(30, fs,    PatrolReader);
 
     /* Boot. */
     AMS_DEFINE_SYSTEM_THREAD(-1, boot, Main);
@@ -87,9 +89,15 @@ namespace ams::impl {
     /* ro. */
     AMS_DEFINE_SYSTEM_THREAD(16, ro, Main);
 
+    /* gpio. */
+    AMS_DEFINE_SYSTEM_THREAD(-12, gpio, InterruptHandler);
+
     /* bpc. */
     AMS_DEFINE_SYSTEM_THREAD(4, bpc, IpcServer);
 
+    /* powctl. */
+    AMS_DEFINE_SYSTEM_THREAD(9, powctl, InterruptHandler);
+
     /* hid. */
     AMS_DEFINE_SYSTEM_THREAD(-10, hid, IpcServer);
 

libraries/libstratosphere/include/stratosphere/cal.hpp

@@ -2,7 +2,7 @@
  * Copyright (c) 2018-2020 Atmosphère-NX
  *
  * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License
+ * under the terms and conditions of the GNU General Public License,
  * version 2, as published by the Free Software Foundation.
  *
  * This program is distributed in the hope it will be useful, but WITHOUT
@@ -13,6 +13,7 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #pragma once
 
-#define EVP_COP_RESET_VECTOR 0x200
+#include <stratosphere/cal/cal_battery_api.hpp>

libraries/libstratosphere/include/stratosphere/cal/cal_battery_api.hpp

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+
+namespace ams::cal {
+
+    Result GetBatteryVersion(u8 *out);
+    Result GetBatteryVendor(size_t *out_vendor_size, void *dst, size_t dst_size);
+
+}

libraries/libstratosphere/include/stratosphere/clkrst.hpp

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <stratosphere/clkrst/clkrst_types.hpp>
+#include <stratosphere/clkrst/clkrst_api.hpp>
+#include <stratosphere/clkrst/clkrst_session_api.hpp>

libraries/libstratosphere/include/stratosphere/clkrst/clkrst_api.hpp

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/clkrst/clkrst_types.hpp>
+
+namespace ams::clkrst {
+
+    void Initialize();
+    void Finalize();
+
+}

libraries/libstratosphere/include/stratosphere/clkrst/clkrst_session_api.hpp

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/clkrst/clkrst_types.hpp>
+
+namespace ams::clkrst {
+
+    struct ClkRstSession {
+        void *_session;
+    };
+
+    Result OpenSession(ClkRstSession *out, DeviceCode device_code);
+    void CloseSession(ClkRstSession *session);
+
+    void SetResetAsserted(ClkRstSession *session);
+    void SetResetDeasserted(ClkRstSession *session);
+
+    void SetClockRate(ClkRstSession *session, u32 hz);
+
+    void SetClockDisabled(ClkRstSession *session);
+
+}

libraries/libstratosphere/include/stratosphere/clkrst/clkrst_types.hpp

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+
+namespace ams::clkrst {
+
+    /* ... */
+
+}

libraries/libstratosphere/include/stratosphere/dd.hpp

@@ -16,5 +16,7 @@
 
 #pragma once
 
-#include "dd/dd_io_mappings.hpp"
-#include "dd/dd_process_handle.hpp"
+#include <stratosphere/dd/dd_types.hpp>
+#include <stratosphere/dd/dd_device_address_space.hpp>
+#include <stratosphere/dd/dd_io_mappings.hpp>
+#include <stratosphere/dd/dd_process_handle.hpp>

libraries/libstratosphere/include/stratosphere/dd/dd_device_address_space.hpp

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+
+#include <stratosphere/dd/dd_device_address_space_common.hpp>
+#include <stratosphere/dd/dd_device_address_space_types.hpp>
+#include <stratosphere/dd/dd_device_address_space_api.hpp>

libraries/libstratosphere/include/stratosphere/dd/dd_device_address_space_api.hpp

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/dd/dd_types.hpp>
+#include <stratosphere/dd/dd_device_address_space_common.hpp>
+#include <stratosphere/dd/dd_device_address_space_types.hpp>
+
+namespace ams::dd {
+
+    Result CreateDeviceAddressSpace(DeviceAddressSpaceType *das, u64 address, u64 size);
+    Result CreateDeviceAddressSpace(DeviceAddressSpaceType *das, u64 size);
+    void DestroyDeviceAddressSpace(DeviceAddressSpaceType *das);
+
+    void AttachDeviceAddressSpaceHandle(DeviceAddressSpaceType *das, Handle handle, bool managed);
+
+    Handle GetDeviceAddressSpaceHandle(DeviceAddressSpaceType *das);
+
+    Result MapDeviceAddressSpaceAligned(DeviceAddressSpaceType *das, ProcessHandle process_handle, u64 process_address, size_t size, DeviceVirtualAddress device_address, MemoryPermission device_perm);
+    Result MapDeviceAddressSpaceNotAligned(DeviceAddressSpaceType *das, ProcessHandle process_handle, u64 process_address, size_t size, DeviceVirtualAddress device_address, MemoryPermission device_perm);
+    void UnmapDeviceAddressSpace(DeviceAddressSpaceType *das, ProcessHandle process_handle, u64 process_address, size_t size, DeviceVirtualAddress device_address);
+
+    void InitializeDeviceAddressSpaceMapInfo(DeviceAddressSpaceMapInfo *info, DeviceAddressSpaceType *das, ProcessHandle process_handle, u64 process_address, size_t size, DeviceVirtualAddress device_address, MemoryPermission device_perm);
+
+    Result MapNextDeviceAddressSpaceRegion(size_t *out_mapped_size, DeviceAddressSpaceMapInfo *info);
+    void UnmapDeviceAddressSpaceRegion(DeviceAddressSpaceMapInfo *info);
+
+    u64 GetMappedProcessAddress(DeviceAddressSpaceMapInfo *info);
+    DeviceVirtualAddress GetMappedDeviceVirtualAddress(DeviceAddressSpaceMapInfo *info);
+    size_t GetMappedSize(DeviceAddressSpaceMapInfo *info);
+
+    Result AttachDeviceAddressSpace(DeviceAddressSpaceType *das, DeviceName device_name);
+    void DetachDeviceAddressSpace(DeviceAddressSpaceType *das, DeviceName device_name);
+
+}

libraries/libstratosphere/include/stratosphere/dd/dd_device_address_space_common.hpp

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/dd/dd_types.hpp>
+
+namespace ams::dd {
+
+    using DeviceName = ::ams::svc::DeviceName;
+
+    constexpr inline u64 DeviceAddressSpaceMemoryRegionAlignment = 4_KB;
+
+}

libraries/libstratosphere/include/stratosphere/dd/dd_device_address_space_types.hpp

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/dd/dd_types.hpp>
+
+namespace ams::dd {
+
+    using DeviceVirtualAddress = u64;
+
+    using DeviceAddressSpaceHandle = ::Handle;
+
+    struct DeviceAddressSpaceType {
+        enum State {
+            State_NotInitialized = 0,
+            State_Initialized    = 1,
+        };
+        DeviceAddressSpaceHandle device_handle;
+        u8       state;
+        bool     is_handle_managed;
+    };
+    static_assert(std::is_trivial<DeviceAddressSpaceType>::value);
+
+    struct DeviceAddressSpaceMapInfo {
+        size_t last_mapped_size;
+        size_t size;
+        u64 process_address;
+        DeviceVirtualAddress device_start_address;
+        DeviceVirtualAddress device_end_address;
+        ProcessHandle process_handle;
+        MemoryPermission device_permission;
+        DeviceAddressSpaceType *device_address_space;
+    };
+    static_assert(std::is_trivial<DeviceAddressSpaceMapInfo>::value);
+
+}

libraries/libstratosphere/include/stratosphere/dd/dd_io_mappings.hpp

@@ -19,16 +19,9 @@
 
 namespace ams::dd {
 
-    uintptr_t QueryIoMapping(uintptr_t phys_addr, size_t size);
-
-    u32 ReadRegister(uintptr_t phys_addr);
-    void WriteRegister(uintptr_t phys_addr, u32 value);
-    u32 ReadWriteRegister(uintptr_t phys_addr, u32 value, u32 mask);
-
     /* Convenience Helper. */
-
-    inline uintptr_t GetIoMapping(uintptr_t phys_addr, size_t size) {
-        const uintptr_t io_mapping = QueryIoMapping(phys_addr, size);
+    inline uintptr_t GetIoMapping(dd::PhysicalAddress phys_addr, size_t size) {
+        const uintptr_t io_mapping = dd::QueryIoMapping(phys_addr, size);
         AMS_ABORT_UNLESS(io_mapping);
         return io_mapping;
     }

libraries/libstratosphere/include/stratosphere/dd/dd_process_handle.hpp

@@ -13,12 +13,12 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #pragma once
 #include <vapours.hpp>
+#include <stratosphere/dd/dd_types.hpp>
 
 namespace ams::dd {
 
-    ::Handle GetCurrentProcessHandle();
+    ProcessHandle GetCurrentProcessHandle();
 
 }

libraries/libstratosphere/include/stratosphere/dd/dd_types.hpp

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/dd/dd_types.hpp>
+
+namespace ams::dd {
+
+    using ProcessHandle = ::Handle;
+
+    enum MemoryPermission {
+        MemoryPermission_None      = 0,
+        MemoryPermission_ReadOnly  = (1u << 0),
+        MemoryPermission_WriteOnly = (1u << 1),
+
+        MemoryPermission_ReadWrite = MemoryPermission_ReadOnly | MemoryPermission_WriteOnly,
+    };
+
+}

libraries/libstratosphere/include/stratosphere/ddsf.hpp

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include <stratosphere/ddsf/ddsf_types.hpp>
+#include <stratosphere/ddsf/ddsf_i_castable.hpp>
+#include <stratosphere/ddsf/ddsf_i_session.hpp>
+#include <stratosphere/ddsf/ddsf_i_device.hpp>
+#include <stratosphere/ddsf/ddsf_i_driver.hpp>
+#include <stratosphere/ddsf/ddsf_device_code_entry.hpp>
+#include <stratosphere/ddsf/ddsf_device_code_entry_manager.hpp>
+#include <stratosphere/ddsf/ddsf_i_event_handler.hpp>
+#include <stratosphere/ddsf/ddsf_event_handler_manager.hpp>
+#include <stratosphere/ddsf/ddsf_memory_api.hpp>

libraries/libstratosphere/include/stratosphere/ddsf/ddsf_device_code_entry.hpp

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+
+namespace ams::ddsf {
+
+    class IDevice;
+
+    class DeviceCodeEntry {
+        NON_COPYABLE(DeviceCodeEntry);
+        NON_MOVEABLE(DeviceCodeEntry);
+        private:
+            ams::DeviceCode device_code = ams::InvalidDeviceCode;
+            IDevice *device = nullptr;
+        public:
+            constexpr DeviceCodeEntry(ams::DeviceCode dc, IDevice *dev) : device_code(dc), device(dev) {
+                AMS_ASSERT(dev != nullptr);
+            }
+
+            constexpr ams::DeviceCode GetDeviceCode() const {
+                return this->device_code;
+            }
+
+            constexpr IDevice &GetDevice() {
+                return *this->device;
+            }
+
+            constexpr const IDevice &GetDevice() const {
+                return *this->device;
+            }
+    };
+
+    class DeviceCodeEntryHolder {
+        NON_COPYABLE(DeviceCodeEntryHolder);
+        NON_MOVEABLE(DeviceCodeEntryHolder);
+        private:
+            util::IntrusiveListNode list_node;
+            TYPED_STORAGE(DeviceCodeEntry) entry_storage;
+            bool is_constructed;
+        public:
+            using ListTraits = util::IntrusiveListMemberTraitsDeferredAssert<&DeviceCodeEntryHolder::list_node>;
+            using List       = typename ListTraits::ListType;
+            friend class util::IntrusiveList<DeviceCodeEntryHolder, util::IntrusiveListMemberTraitsDeferredAssert<&DeviceCodeEntryHolder::list_node>>;
+        public:
+            DeviceCodeEntryHolder() : list_node(), entry_storage(), is_constructed(false) {
+                /* ... */
+            }
+
+            ~DeviceCodeEntryHolder() {
+                if (this->IsConstructed()) {
+                    this->Destroy();
+                }
+            }
+
+            void AddTo(List &list) {
+                list.push_back(*this);
+            }
+
+            void RemoveFrom(List list) {
+                list.erase(list.iterator_to(*this));
+            }
+
+            bool IsLinkedToList() const {
+                return this->list_node.IsLinked();
+            }
+
+            DeviceCodeEntry &Construct(DeviceCode dc, IDevice *dev) {
+                AMS_ASSERT(!this->IsConstructed());
+                DeviceCodeEntry *entry = new (GetPointer(this->entry_storage)) DeviceCodeEntry(dc, dev);
+                this->is_constructed = true;
+                return *entry;
+            }
+
+            bool IsConstructed() const {
+                return this->is_constructed;
+            }
+
+            void Destroy() {
+                AMS_ASSERT(this->IsConstructed());
+                GetReference(this->entry_storage).~DeviceCodeEntry();
+                this->is_constructed = false;
+            }
+
+            DeviceCodeEntry &Get() {
+                AMS_ASSERT(this->IsConstructed());
+                return GetReference(this->entry_storage);
+            }
+
+            const DeviceCodeEntry &Get() const {
+                AMS_ASSERT(this->IsConstructed());
+                return GetReference(this->entry_storage);
+            }
+    };
+    static_assert(DeviceCodeEntryHolder::ListTraits::IsValid());
+
+}

libraries/libstratosphere/include/stratosphere/ddsf/ddsf_device_code_entry_manager.hpp

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/ddsf/ddsf_types.hpp>
+#include <stratosphere/ddsf/impl/ddsf_for_each.hpp>
+#include <stratosphere/ddsf/ddsf_device_code_entry.hpp>
+
+namespace ams::ddsf {
+
+    class IDevice;
+
+    class DeviceCodeEntryManager {
+        private:
+            ams::MemoryResource *memory_resource;
+            ddsf::DeviceCodeEntryHolder::List entry_list;
+            mutable os::SdkMutex entry_list_lock;
+        private:
+            void DestroyAllEntries() {
+                auto it = this->entry_list.begin();
+                while (it != this->entry_list.end()) {
+                    ddsf::DeviceCodeEntryHolder *entry = std::addressof(*it);
+                    it = this->entry_list.erase(it);
+
+                    AMS_ASSERT(entry->IsConstructed());
+                    if (entry->IsConstructed()) {
+                        entry->Destroy();
+                    }
+
+                    this->memory_resource->Deallocate(entry, sizeof(*entry));
+                }
+            }
+        public:
+            DeviceCodeEntryManager(ams::MemoryResource *mr) : memory_resource(mr), entry_list(), entry_list_lock() { /* ... */ }
+
+            ~DeviceCodeEntryManager() {
+                this->DestroyAllEntries();
+            }
+
+            void Reset() {
+                std::scoped_lock lk(this->entry_list_lock);
+                this->DestroyAllEntries();
+            }
+
+            Result Add(DeviceCode device_code, IDevice *device);
+            bool Remove(DeviceCode device_code);
+
+            Result FindDeviceCodeEntry(DeviceCodeEntry **out, DeviceCode device_code);
+            Result FindDeviceCodeEntry(const DeviceCodeEntry **out, DeviceCode device_code) const;
+
+            Result FindDevice(IDevice **out, DeviceCode device_code);
+            Result FindDevice(const IDevice **out, DeviceCode device_code) const;
+
+            template<typename F>
+            int ForEachEntry(F f) {
+                return impl::ForEach(this->entry_list_lock, this->entry_list, [&](DeviceCodeEntryHolder &holder) -> bool {
+                    AMS_ASSERT(holder.IsConstructed());
+                    return f(holder.Get());
+                });
+            }
+
+            template<typename F>
+            int ForEachEntry(F f) const {
+                return impl::ForEach(this->entry_list_lock, this->entry_list, [&](const DeviceCodeEntryHolder &holder) -> bool {
+                    AMS_ASSERT(holder.IsConstructed());
+                    return f(holder.Get());
+                });
+            }
+    };
+
+}

libraries/libstratosphere/include/stratosphere/ddsf/ddsf_event_handler_manager.hpp

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/os.hpp>
+#include <stratosphere/ddsf/ddsf_i_event_handler.hpp>
+
+namespace ams::ddsf {
+
+    class EventHandlerManager;
+
+    class EventHandlerManager {
+        NON_COPYABLE(EventHandlerManager);
+        NON_MOVEABLE(EventHandlerManager);
+        private:
+            struct LoopControlCommandParameters;
+        private:
+            bool is_initialized;
+            bool is_looping;
+            os::SdkConditionVariable is_looping_cv;
+            os::WaitableManagerType waitable_manager;
+            os::ThreadType *loop_thread;
+            os::Event loop_control_event;
+            os::WaitableHolderType loop_control_event_holder;
+            LoopControlCommandParameters *loop_control_command_params;
+            os::Event loop_control_command_done_event; /* TODO: os::LightEvent, requires mesosphere for < 4.0.0 compat. */
+            os::SdkMutex loop_control_lock;
+        private:
+            void ProcessControlCommand(LoopControlCommandParameters *params);
+            void ProcessControlCommandImpl(LoopControlCommandParameters *params);
+        public:
+            EventHandlerManager()
+                : is_initialized(false), is_looping(false), is_looping_cv(), waitable_manager(),
+                  loop_thread(), loop_control_event(os::EventClearMode_AutoClear), loop_control_event_holder(),
+                  loop_control_command_params(), loop_control_command_done_event(os::EventClearMode_AutoClear),
+                  loop_control_lock()
+            {
+                this->Initialize();
+            }
+
+            ~EventHandlerManager() {
+                if (this->is_looping) {
+                    AMS_ASSERT(!this->IsRunningOnLoopThread());
+                    this->RequestStop();
+                }
+                if (this->is_initialized) {
+                    this->Finalize();
+                }
+            }
+
+            bool IsRunningOnLoopThread() const { return this->loop_thread == os::GetCurrentThread(); }
+            bool IsLooping() const { return this->is_looping; }
+
+            void Initialize();
+            void Finalize();
+
+            void RegisterHandler(IEventHandler *handler);
+            void UnregisterHandler(IEventHandler *handler);
+
+            void WaitLoopEnter();
+            void WaitLoopExit();
+            void RequestStop();
+
+            void LoopAuto();
+    };
+
+}

libraries/libstratosphere/include/stratosphere/ddsf/ddsf_i_castable.hpp

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/ddsf/ddsf_types.hpp>
+#include <stratosphere/ddsf/impl/ddsf_type_tag.hpp>
+
+namespace ams::ddsf {
+
+    #if defined(AMS_BUILD_FOR_DEBUGGING) || defined(AMS_BUILD_FOR_AUDITING)
+
+        #define AMS_DDSF_CASTABLE_TRAITS(__CLASS__, __BASE__)                                                                                           \
+            static_assert(std::convertible_to<__CLASS__ *, __BASE__ *>);                                                                                \
+            public:                                                                                                                                     \
+                static constexpr inline ::ams::ddsf::impl::TypeTag s_ams_ddsf_castable_type_tag{#__CLASS__, __BASE__::s_ams_ddsf_castable_type_tag};    \
+                constexpr virtual const ::ams::ddsf::impl::TypeTag &GetTypeTag() const override { return s_ams_ddsf_castable_type_tag; }
+
+    #else
+
+        #define AMS_DDSF_CASTABLE_TRAITS(__CLASS__, __BASE__)                                                                                           \
+            static_assert(std::convertible_to<__CLASS__ *, __BASE__ *>);                                                                                \
+            public:                                                                                                                                     \
+                static constexpr inline ::ams::ddsf::impl::TypeTag s_ams_ddsf_castable_type_tag{__BASE__::s_ams_ddsf_castable_type_tag};                \
+                constexpr virtual const ::ams::ddsf::impl::TypeTag &GetTypeTag() const override { return s_ams_ddsf_castable_type_tag; }
+
+    #endif
+
+    class ICastable {
+        private:
+            constexpr virtual const impl::TypeTag &GetTypeTag() const = 0;
+
+            template<typename T>
+            constexpr ALWAYS_INLINE void AssertCastableTo() const {
+                AMS_ASSERT(this->IsCastableTo<T>());
+            }
+        public:
+            template<typename T>
+            constexpr bool IsCastableTo() const {
+                return this->GetTypeTag().DerivesFrom(T::s_ams_ddsf_castable_type_tag);
+            }
+
+            template<typename T>
+            constexpr T &SafeCastTo() {
+                this->AssertCastableTo<T>();
+                return static_cast<T &>(*this);
+            }
+
+            template<typename T>
+            constexpr const T &SafeCastTo() const {
+                this->AssertCastableTo<T>();
+                return static_cast<const T &>(*this);
+            }
+
+            template<typename T>
+            constexpr T *SafeCastToPointer() {
+                this->AssertCastableTo<T>();
+                return static_cast<T *>(this);
+            }
+
+            template<typename T>
+            constexpr const T *SafeCastToPointer() const {
+                this->AssertCastableTo<T>();
+                return static_cast<const T *>(this);
+            }
+
+            #if defined(AMS_BUILD_FOR_AUDITING) || defined(AMS_BUILD_FOR_DEBUGGING)
+
+                constexpr const char *GetClassName() const {
+                    return this->GetTypeTag().GetClassName();
+                }
+
+            #endif
+    };
+
+}

libraries/libstratosphere/include/stratosphere/ddsf/ddsf_i_device.hpp

@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/os/os_sdk_mutex.hpp>
+#include <stratosphere/ddsf/ddsf_types.hpp>
+#include <stratosphere/ddsf/impl/ddsf_for_each.hpp>
+#include <stratosphere/ddsf/ddsf_i_castable.hpp>
+#include <stratosphere/ddsf/ddsf_i_session.hpp>
+
+namespace ams::ddsf {
+
+    class IDriver;
+
+    class IDevice : public ICastable {
+        friend Result OpenSession(IDevice *device, ISession *session, AccessMode mode);
+        friend void CloseSession(ISession *session);
+        friend class IDriver;
+        public:
+            AMS_DDSF_CASTABLE_ROOT_TRAITS(ams::ddsf::IDevice);
+        private:
+            util::IntrusiveListNode list_node;
+            IDriver *driver;
+            ISession::List session_list;
+            mutable os::SdkMutex session_list_lock;
+            bool is_exclusive_write;
+        public:
+            using ListTraits = util::IntrusiveListMemberTraitsDeferredAssert<&IDevice::list_node>;
+            using List       = typename ListTraits::ListType;
+            friend class util::IntrusiveList<IDevice, util::IntrusiveListMemberTraitsDeferredAssert<&IDevice::list_node>>;
+        private:
+            Result AttachSession(ISession *session) {
+                AMS_ASSERT(session != nullptr);
+                std::scoped_lock lk(this->session_list_lock);
+
+                /* Check if we're allowed to attach the session. */
+                if (this->is_exclusive_write && session->CheckExclusiveWrite()) {
+                    for (const auto &attached : this->session_list) {
+                        R_UNLESS(!attached.CheckAccess(AccessMode_Write), ddsf::ResultAccessModeDenied());
+                    }
+                }
+
+                /* Attach the session. */
+                this->session_list.push_back(*session);
+                return ResultSuccess();
+            }
+
+            void DetachSession(ISession *session) {
+                AMS_ASSERT(session != nullptr);
+                std::scoped_lock lk(this->session_list_lock);
+                this->session_list.erase(this->session_list.iterator_to(*session));
+            }
+
+            void AttachDriver(IDriver *drv) {
+                AMS_ASSERT(drv != nullptr);
+                AMS_ASSERT(!this->IsDriverAttached());
+                this->driver = drv;
+                AMS_ASSERT(this->IsDriverAttached());
+            }
+
+            void DetachDriver() {
+                AMS_ASSERT(this->IsDriverAttached());
+                this->driver = nullptr;
+                AMS_ASSERT(!this->IsDriverAttached());
+            }
+        public:
+            IDevice(bool exclusive_write) : list_node(), driver(nullptr), session_list(), session_list_lock(), is_exclusive_write(exclusive_write) {
+                this->session_list.clear();
+            }
+        protected:
+            ~IDevice() {
+                this->session_list.clear();
+            }
+        public:
+            void AddTo(List &list) {
+                list.push_back(*this);
+            }
+
+            void RemoveFrom(List list) {
+                list.erase(list.iterator_to(*this));
+            }
+
+            bool IsLinkedToList() const {
+                return this->list_node.IsLinked();
+            }
+
+            IDriver &GetDriver() {
+                AMS_ASSERT(this->IsDriverAttached());
+                return *this->driver;
+            }
+
+            const IDriver &GetDriver() const {
+                AMS_ASSERT(this->IsDriverAttached());
+                return *this->driver;
+            }
+
+            bool IsDriverAttached() const {
+                return this->driver != nullptr;
+            }
+
+            template<typename F>
+            Result ForEachSession(F f, bool return_on_fail) {
+                return impl::ForEach(this->session_list_lock, this->session_list, f, return_on_fail);
+            }
+
+            template<typename F>
+            Result ForEachSession(F f, bool return_on_fail) const {
+                return impl::ForEach(this->session_list_lock, this->session_list, f, return_on_fail);
+            }
+
+            template<typename F>
+            int ForEachSession(F f) {
+                return impl::ForEach(this->session_list_lock, this->session_list, f);
+            }
+
+            template<typename F>
+            int ForEachSession(F f) const {
+                return impl::ForEach(this->session_list_lock, this->session_list, f);
+            }
+
+            bool HasAnyOpenSession() const {
+                return !this->session_list.empty();
+            }
+    };
+    static_assert(IDevice::ListTraits::IsValid());
+
+}

libraries/libstratosphere/include/stratosphere/ddsf/ddsf_i_driver.hpp

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/os/os_sdk_mutex.hpp>
+#include <stratosphere/ddsf/ddsf_types.hpp>
+#include <stratosphere/ddsf/impl/ddsf_for_each.hpp>
+#include <stratosphere/ddsf/ddsf_i_castable.hpp>
+#include <stratosphere/ddsf/ddsf_i_device.hpp>
+
+namespace ams::ddsf {
+
+    class IDriver : public ICastable {
+        public:
+            AMS_DDSF_CASTABLE_ROOT_TRAITS(ams::ddsf::IDriver);
+        private:
+            util::IntrusiveListNode list_node;
+            IDevice::List device_list;
+            mutable os::SdkMutex device_list_lock;
+        public:
+            using ListTraits = util::IntrusiveListMemberTraitsDeferredAssert<&IDriver::list_node>;
+            using List       = typename ListTraits::ListType;
+            friend class util::IntrusiveList<IDriver, util::IntrusiveListMemberTraitsDeferredAssert<&IDriver::list_node>>;
+        private:
+        public:
+            IDriver() : list_node(), device_list(), device_list_lock() {
+                this->device_list.clear();
+            }
+        protected:
+            ~IDriver() {
+                this->device_list.clear();
+            }
+        public:
+            void AddTo(List &list) {
+                list.push_back(*this);
+            }
+
+            void RemoveFrom(List list) {
+                list.erase(list.iterator_to(*this));
+            }
+
+            bool IsLinkedToList() const {
+                return this->list_node.IsLinked();
+            }
+
+            bool HasAnyDevice() const {
+                return !this->device_list.empty();
+            }
+
+            void RegisterDevice(IDevice *dev) {
+                AMS_ASSERT(dev != nullptr);
+                std::scoped_lock lk(this->device_list_lock);
+                dev->AttachDriver(this);
+                this->device_list.push_back(*dev);
+            }
+
+            void UnregisterDevice(IDevice *dev) {
+                AMS_ASSERT(dev != nullptr);
+                std::scoped_lock lk(this->device_list_lock);
+                this->device_list.erase(this->device_list.iterator_to(*dev));
+                dev->DetachDriver();
+            }
+
+            template<typename F>
+            Result ForEachDevice(F f, bool return_on_fail) {
+                return impl::ForEach(this->device_list_lock, this->device_list, f, return_on_fail);
+            }
+
+            template<typename F>
+            Result ForEachDevice(F f, bool return_on_fail) const {
+                return impl::ForEach(this->device_list_lock, this->device_list, f, return_on_fail);
+            }
+
+            template<typename F>
+            int ForEachDevice(F f) {
+                return impl::ForEach(this->device_list_lock, this->device_list, f);
+            }
+
+            template<typename F>
+            int ForEachDevice(F f) const {
+                return impl::ForEach(this->device_list_lock, this->device_list, f);
+            }
+    };
+    static_assert(IDriver::ListTraits::IsValid());
+
+}

libraries/libstratosphere/include/stratosphere/ddsf/ddsf_i_event_handler.hpp

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/os.hpp>
+
+namespace ams::ddsf {
+
+    class EventHandlerManager;
+
+    class IEventHandler {
+        NON_COPYABLE(IEventHandler);
+        NON_MOVEABLE(IEventHandler);
+        friend class EventHandlerManager;
+        private:
+            os::WaitableHolderType holder;
+            uintptr_t user_data;
+            bool is_initialized;
+            bool is_registered;
+        private:
+            void Link(os::WaitableManagerType *manager) {
+                AMS_ASSERT(this->IsInitialized());
+                AMS_ASSERT(!this->IsRegistered());
+                AMS_ASSERT(manager != nullptr);
+                os::LinkWaitableHolder(manager, std::addressof(this->holder));
+            }
+
+            void Unlink() {
+                AMS_ASSERT(this->IsInitialized());
+                AMS_ASSERT(this->IsRegistered());
+                os::UnlinkWaitableHolder(std::addressof(this->holder));
+            }
+
+            static IEventHandler &ToEventHandler(os::WaitableHolderType *holder) {
+                AMS_ASSERT(holder != nullptr);
+                auto &event_handler = *reinterpret_cast<IEventHandler *>(os::GetWaitableHolderUserData(holder));
+                AMS_ASSERT(event_handler.IsInitialized());
+                return event_handler;
+            }
+        public:
+            IEventHandler() : holder(), user_data(0), is_initialized(false), is_registered(false) { /* ... */ }
+
+            ~IEventHandler() {
+                if (this->IsRegistered()) {
+                    this->Unlink();
+                }
+                if (this->IsInitialized()) {
+                    this->Finalize();
+                }
+            }
+
+            bool IsInitialized() const { return this->is_initialized; }
+            bool IsRegistered() const { return this->is_registered; }
+
+            uintptr_t GetUserData() const { return this->user_data; }
+            void SetUserData(uintptr_t d) { this->user_data = d; }
+
+            template<typename T>
+            void Initialize(T *object) {
+                AMS_ASSERT(object != nullptr);
+                AMS_ASSERT(!this->IsInitialized());
+                os::InitializeWaitableHolder(std::addressof(this->holder), object);
+                os::SetWaitableHolderUserData(std::addressof(this->holder), reinterpret_cast<uintptr_t>(this));
+                this->is_initialized = true;
+                this->is_registered  = false;
+            }
+
+            void Finalize() {
+                AMS_ASSERT(this->IsInitialized());
+                AMS_ASSERT(!this->IsRegistered());
+                os::FinalizeWaitableHolder(std::addressof(this->holder));
+                this->is_initialized = false;
+                this->is_registered  = false;
+            }
+        protected:
+            virtual void HandleEvent() = 0;
+    };
+
+}

libraries/libstratosphere/include/stratosphere/ddsf/ddsf_i_session.hpp

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/ddsf/ddsf_types.hpp>
+#include <stratosphere/ddsf/impl/ddsf_for_each.hpp>
+#include <stratosphere/ddsf/ddsf_i_castable.hpp>
+
+namespace ams::ddsf {
+
+    class ISession;
+    class IDevice;
+
+    Result OpenSession(IDevice *device, ISession *session, AccessMode access_mode);
+    void CloseSession(ISession *session);
+
+    class ISession : public ICastable {
+        friend Result OpenSession(IDevice *device, ISession *session, AccessMode mode);
+        friend void CloseSession(ISession *session);
+        public:
+            AMS_DDSF_CASTABLE_ROOT_TRAITS(ams::ddsf::IDevice);
+        private:
+            util::IntrusiveListNode list_node;
+            IDevice *device;
+            AccessMode access_mode;
+        public:
+            using ListTraits = util::IntrusiveListMemberTraitsDeferredAssert<&ISession::list_node>;
+            using List       = typename ListTraits::ListType;
+            friend class util::IntrusiveList<ISession, util::IntrusiveListMemberTraitsDeferredAssert<&ISession::list_node>>;
+        private:
+            void AttachDevice(IDevice *dev, AccessMode mode) {
+                AMS_ASSERT(dev != nullptr);
+                AMS_ASSERT(!this->IsOpen());
+                this->device      = dev;
+                this->access_mode = mode;
+                AMS_ASSERT(this->IsOpen());
+            }
+
+            void DetachDevice() {
+                AMS_ASSERT(this->IsOpen());
+                this->device      = nullptr;
+                this->access_mode = AccessMode_None;
+                AMS_ASSERT(!this->IsOpen());
+            }
+        public:
+            ISession() : list_node(), device(nullptr), access_mode() { /* ... */ }
+        protected:
+            ~ISession() { this->DetachDevice(); AMS_ASSERT(!this->IsOpen()); }
+        public:
+            void AddTo(List &list) {
+                list.push_back(*this);
+            }
+
+            void RemoveFrom(List list) {
+                list.erase(list.iterator_to(*this));
+            }
+
+            bool IsLinkedToList() const {
+                return this->list_node.IsLinked();
+            }
+
+            IDevice &GetDevice() {
+                AMS_ASSERT(this->IsOpen());
+                return *this->device;
+            }
+
+            const IDevice &GetDevice() const {
+                AMS_ASSERT(this->IsOpen());
+                return *this->device;
+            }
+
+            bool IsOpen() const {
+                return this->device != nullptr;
+            }
+
+            bool CheckAccess(AccessMode mode) const {
+                AMS_ASSERT(this->IsOpen());
+                return ((~this->access_mode) & mode) == 0;
+            }
+
+            bool CheckExclusiveWrite() const {
+                return this->CheckAccess(AccessMode_Write) && !this->CheckAccess(AccessMode_Shared);
+            }
+    };
+    static_assert(ISession::ListTraits::IsValid());
+
+}

libraries/libstratosphere/include/stratosphere/ddsf/ddsf_memory_api.hpp

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/ddsf/ddsf_device_code_entry.hpp>
+
+namespace ams::ddsf {
+
+    void SetMemoryResource(ams::MemoryResource *mr);
+    ams::MemoryResource *GetMemoryResource();
+
+    static constexpr size_t DeviceCodeEntryHolderSize = sizeof(DeviceCodeEntryHolder);
+
+    void SetDeviceCodeEntryHolderMemoryResource(ams::MemoryResource *mr);
+    ams::MemoryResource *GetDeviceCodeEntryHolderMemoryResource();
+
+}

libraries/libstratosphere/include/stratosphere/ddsf/ddsf_types.hpp

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include <vapours.hpp>
+
+namespace ams::ddsf {
+
+    enum AccessMode {
+        AccessMode_None   = (0u << 0),
+        AccessMode_Read   = (1u << 0),
+        AccessMode_Write  = (1u << 1),
+        AccessMode_Shared = (1u << 2),
+
+        AccessMode_ReadWrite       = AccessMode_Read  | AccessMode_Write,
+        AccessMode_WriteShared     = AccessMode_Write | AccessMode_Shared,
+        AccessMode_ReadWriteShared = AccessMode_Read  | AccessMode_WriteShared,
+    };
+
+}

libraries/libstratosphere/include/stratosphere/ddsf/impl/ddsf_for_each.hpp

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+
+namespace ams::ddsf::impl {
+
+    template<typename Lock, typename List, typename F>
+    inline Result ForEach(Lock &lock, List &list, F f, bool return_on_fail) {
+        std::scoped_lock lk(lock);
+
+        Result result = ResultSuccess();
+        for (auto && it : list) {
+            if (const auto cur_result = f(std::addressof(it)); R_FAILED(cur_result)) {
+                if (return_on_fail) {
+                    return cur_result;
+                } else if (R_SUCCEEDED(result)) {
+                    result = cur_result;
+                }
+            }
+        }
+        return result;
+    }
+
+    template<typename List, typename F, typename Lock>
+    inline int ForEach(Lock &lock, List &list, F f) {
+        std::scoped_lock lk(lock);
+
+        int success_count = 0;
+        for (auto && it : list) {
+            if (!f(it)) {
+                return success_count;
+            }
+            ++success_count;
+        }
+        return success_count;
+    }
+
+}

libraries/libstratosphere/include/stratosphere/ddsf/impl/ddsf_type_tag.hpp

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/ddsf/ddsf_types.hpp>
+
+namespace ams::ddsf::impl {
+
+    #if defined(AMS_BUILD_FOR_DEBUGGING) || defined(AMS_BUILD_FOR_AUDITING)
+
+        #define AMS_DDSF_CASTABLE_ROOT_TRAITS(__CLASS__)                                                                                    \
+            public:                                                                                                                         \
+                static constexpr inline ::ams::ddsf::impl::TypeTag s_ams_ddsf_castable_type_tag{#__CLASS__};                                \
+                constexpr virtual const ::ams::ddsf::impl::TypeTag &GetTypeTag() const override { return s_ams_ddsf_castable_type_tag; }
+
+    #else
+
+        #define AMS_DDSF_CASTABLE_ROOT_TRAITS(__CLASS__)                                                                                    \
+            public:                                                                                                                         \
+                static constexpr inline ::ams::ddsf::impl::TypeTag s_ams_ddsf_castable_type_tag{};                                          \
+                constexpr virtual const ::ams::ddsf::impl::TypeTag &GetTypeTag() const override { return s_ams_ddsf_castable_type_tag; }
+
+    #endif
+
+    class TypeTag {
+        private:
+            const char * const class_name;
+            const TypeTag * const base;
+        public:
+            #if !(defined(AMS_BUILD_FOR_DEBUGGING) || defined(AMS_BUILD_FOR_AUDITING))
+                constexpr TypeTag() : class_name(nullptr), base(nullptr) { /* ... */}
+                constexpr TypeTag(const TypeTag &b) : class_name(nullptr), base(std::addressof(b)) { AMS_ASSERT(this != this->base); }
+
+                constexpr TypeTag(const char *c) : class_name(nullptr), base(nullptr) { AMS_UNUSED(c); }
+                constexpr TypeTag(const char *c, const TypeTag &b) : class_name(nullptr), base(std::addressof(b)) { AMS_UNUSED(c); AMS_ASSERT(this != this->base); }
+            #else
+                constexpr TypeTag(const char *c) : class_name(c), base(nullptr) { /* ... */ }
+                constexpr TypeTag(const char *c, const TypeTag &b) : class_name(c), base(std::addressof(b)) { AMS_ASSERT(this != this->base); }
+            #endif
+
+            constexpr const char * GetClassName() const { return this->class_name; }
+
+            constexpr bool Is(const TypeTag &rhs) const { return this == std::addressof(rhs); }
+
+            constexpr bool DerivesFrom(const TypeTag &rhs) const {
+                const TypeTag * cur = this;
+                while (cur != nullptr) {
+                    if (cur == std::addressof(rhs)) {
+                        return true;
+                    }
+                    cur = cur->base;
+                }
+                return false;
+            }
+    };
+
+}

libraries/libstratosphere/include/stratosphere/gpio.hpp

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include <stratosphere/gpio/gpio_types.hpp>
+#include <stratosphere/gpio/sf/gpio_sf_i_pad_session.hpp>
+#include <stratosphere/gpio/sf/gpio_sf_i_manager.hpp>
+#include <stratosphere/gpio/gpio_api.hpp>
+#include <stratosphere/gpio/gpio_pad_api.hpp>
+#include <stratosphere/gpio/driver/gpio_select_driver_api.hpp>
+#include <stratosphere/gpio/driver/gpio_pad_accessor.hpp>
+#include <stratosphere/gpio/driver/impl/gpio_pad_session_impl.hpp>
+#include <stratosphere/gpio/server/gpio_server_api.hpp>

libraries/libstratosphere/include/stratosphere/gpio/driver/board/nintendo_nx/gpio_driver_api.hpp

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/gpio/gpio_types.hpp>
+#include <stratosphere/gpio/driver/gpio_i_gpio_driver.hpp>
+
+namespace ams::gpio::driver::board::nintendo_nx {
+
+    void Initialize(bool enable_interrupt_handlers);
+
+    void SetInitialGpioConfig();
+    void SetInitialWakePinConfig();
+
+}

libraries/libstratosphere/include/stratosphere/gpio/driver/gpio_driver_client_api.hpp

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/gpio/gpio_types.hpp>
+#include <stratosphere/gpio/driver/gpio_i_gpio_driver.hpp>
+
+namespace ams::gpio::driver {
+
+    void Initialize();
+    void Finalize();
+
+}

libraries/libstratosphere/include/stratosphere/gpio/driver/gpio_driver_service_api.hpp

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/gpio/gpio_types.hpp>
+#include <stratosphere/gpio/driver/gpio_i_gpio_driver.hpp>
+
+namespace ams::gpio::driver {
+
+    void RegisterDriver(IGpioDriver *driver);
+    void UnregisterDriver(IGpioDriver *driver);
+
+    Result RegisterDeviceCode(DeviceCode device_code, Pad *pad);
+    bool UnregisterDeviceCode(DeviceCode device_code);
+
+    void RegisterInterruptHandler(ddsf::IEventHandler *handler);
+    void UnregisterInterruptHandler(ddsf::IEventHandler *handler);
+
+    void SetInitialGpioConfig();
+    void SetInitialWakePinConfig();
+
+}

libraries/libstratosphere/include/stratosphere/gpio/driver/gpio_i_gpio_driver.hpp

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/gpio/gpio_types.hpp>
+#include <stratosphere/ddsf.hpp>
+
+namespace ams::gpio::driver {
+
+    class Pad;
+
+    class IGpioDriver : public ::ams::ddsf::IDriver {
+        NON_COPYABLE(IGpioDriver);
+        NON_MOVEABLE(IGpioDriver);
+        AMS_DDSF_CASTABLE_TRAITS(ams::gpio::driver::IGpioDriver, ::ams::ddsf::IDriver);
+        public:
+            IGpioDriver() : IDriver() { /* ... */ }
+            virtual ~IGpioDriver() { /* ... */ }
+
+            virtual void InitializeDriver() = 0;
+            virtual void FinalizeDriver()   = 0;
+
+            virtual Result InitializePad(Pad *pad) = 0;
+            virtual void FinalizePad(Pad *pad)     = 0;
+
+            virtual Result GetDirection(Direction *out, Pad *pad) const = 0;
+            virtual Result SetDirection(Pad *pad, Direction direction)  = 0;
+
+            virtual Result GetValue(GpioValue *out, Pad *pad) const = 0;
+            virtual Result SetValue(Pad *pad, GpioValue value)      = 0;
+
+            virtual Result GetInterruptMode(InterruptMode *out, Pad *pad) const = 0;
+            virtual Result SetInterruptMode(Pad *pad, InterruptMode mode)       = 0;
+
+            virtual Result SetInterruptEnabled(Pad *pad, bool en) = 0;
+
+            virtual Result GetInterruptStatus(InterruptStatus *out, Pad *pad) = 0;
+            virtual Result ClearInterruptStatus(Pad *pad)                     = 0;
+
+            virtual os::SdkMutex &GetInterruptControlMutex(const Pad &pad) const = 0;
+
+            virtual Result GetDebounceEnabled(bool *out, Pad *pad) const = 0;
+            virtual Result SetDebounceEnabled(Pad *pad, bool en)         = 0;
+
+            virtual Result GetDebounceTime(s32 *out_ms, Pad *pad) const = 0;
+            virtual Result SetDebounceTime(Pad *pad, s32 ms)            = 0;
+
+            virtual Result GetUnknown22(u32 *out) = 0;
+            virtual void Unknown23();
+
+            virtual Result SetValueForSleepState(Pad *pad, GpioValue value) = 0;
+            virtual Result IsWakeEventActive(bool *out, Pad *pad) const = 0;
+            virtual Result SetWakeEventActiveFlagSetForDebug(Pad *pad, bool en) = 0;
+            virtual Result SetWakePinDebugMode(WakePinDebugMode mode) = 0;
+
+            virtual Result Suspend()    = 0;
+            virtual Result SuspendLow() = 0;
+            virtual Result Resume()     = 0;
+            virtual Result ResumeLow()  = 0;
+    };
+
+}

libraries/libstratosphere/include/stratosphere/gpio/driver/gpio_pad.hpp

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/gpio/gpio_types.hpp>
+#include <stratosphere/ddsf.hpp>
+
+namespace ams::gpio::driver {
+
+    class Pad : public ::ams::ddsf::IDevice {
+        NON_COPYABLE(Pad);
+        NON_MOVEABLE(Pad);
+        AMS_DDSF_CASTABLE_TRAITS(ams::gpio::driver::Pad, ::ams::ddsf::IDevice);
+        private:
+            int pad_number;
+            bool is_interrupt_enabled;
+        public:
+            explicit Pad(int pad) : IDevice(true), pad_number(pad), is_interrupt_enabled(false) { /* ... */ }
+
+            Pad() : Pad(0) { /* ... */ }
+
+            virtual ~Pad() { /* ... */ }
+
+            int GetPadNumber() const {
+                return this->pad_number;
+            }
+
+            void SetPadNumber(int p) {
+                this->pad_number = p;
+            }
+
+            bool IsInterruptEnabled() const {
+                return this->is_interrupt_enabled;
+            }
+
+            void SetInterruptEnabled(bool en) {
+                this->is_interrupt_enabled = en;
+            }
+
+            bool IsInterruptRequiredForDriver() const {
+                return this->IsInterruptEnabled() && this->IsAnySessionBoundToInterrupt();
+            }
+
+            bool IsAnySessionBoundToInterrupt() const;
+            void SignalInterruptBoundEvent();
+    };
+
+}

libraries/libstratosphere/include/stratosphere/gpio/driver/gpio_pad_accessor.hpp

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/gpio/gpio_types.hpp>
+
+namespace ams::gpio::driver {
+
+    namespace impl {
+
+        constexpr inline size_t GpioPadSessionSize  = 0x60;
+        constexpr inline size_t GpioPadSessionAlign = 8;
+        struct alignas(GpioPadSessionAlign) GpioPadSessionImplPadded;
+
+    }
+
+    struct GpioPadSession {
+        util::TypedStorage<impl::GpioPadSessionImplPadded, impl::GpioPadSessionSize, impl::GpioPadSessionAlign> _impl;
+    };
+
+    Result OpenSession(GpioPadSession *out, DeviceCode device_code, ddsf::AccessMode access_mode);
+    void CloseSession(GpioPadSession *session);
+
+    Result SetDirection(GpioPadSession *session, gpio::Direction direction);
+    Result GetDirection(gpio::Direction *out, GpioPadSession *session);
+
+    Result SetValue(GpioPadSession *session, gpio::GpioValue value);
+    Result GetValue(gpio::GpioValue *out, GpioPadSession *session);
+
+    /* TODO */
+
+}

libraries/libstratosphere/include/stratosphere/gpio/driver/gpio_select_driver_api.hpp

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/gpio/gpio_types.hpp>
+#include <stratosphere/gpio/driver/gpio_i_gpio_driver.hpp>
+#include <stratosphere/gpio/driver/gpio_driver_service_api.hpp>
+#include <stratosphere/gpio/driver/gpio_driver_client_api.hpp>
+
+#if defined(ATMOSPHERE_BOARD_NINTENDO_NX)
+
+    #include <stratosphere/gpio/driver/board/nintendo_nx/gpio_driver_api.hpp>
+
+    namespace ams::gpio::driver::board {
+
+        using namespace ams::gpio::driver::board::nintendo_nx;
+
+    }
+
+#else
+
+    #error "Unknown board for ams::gpio::driver::"
+
+#endif
+

libraries/libstratosphere/include/stratosphere/gpio/driver/impl/gpio_event_holder.hpp

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/os.hpp>
+
+namespace ams::gpio::driver::impl {
+
+    class EventHolder {
+        NON_COPYABLE(EventHolder);
+        NON_MOVEABLE(EventHolder);
+        private:
+            os::SystemEventType *event;
+        public:
+            constexpr EventHolder() : event(nullptr) { /* ... */ }
+
+            void AttachEvent(os::SystemEventType *event) {
+                this->event = event;
+            }
+
+            os::SystemEventType *DetachEvent() {
+                auto ev = this->event;
+                this->event = nullptr;
+                return ev;
+            }
+
+            os::SystemEventType *GetSystemEvent() {
+                return this->event;
+            }
+
+            bool IsBound() const {
+                return this->event != nullptr;
+            }
+    };
+
+}

libraries/libstratosphere/include/stratosphere/gpio/driver/impl/gpio_pad_session_impl.hpp

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/gpio/gpio_types.hpp>
+#include <stratosphere/gpio/driver/gpio_pad_accessor.hpp>
+#include <stratosphere/gpio/driver/impl/gpio_event_holder.hpp>
+#include <stratosphere/ddsf.hpp>
+
+namespace ams::gpio::driver {
+
+    class Pad;
+
+}
+
+namespace ams::gpio::driver::impl {
+
+    class PadSessionImpl : public ::ams::ddsf::ISession {
+        NON_COPYABLE(PadSessionImpl);
+        NON_MOVEABLE(PadSessionImpl);
+        AMS_DDSF_CASTABLE_TRAITS(ams::gpio::driver::impl::PadSessionImpl, ::ams::ddsf::ISession);
+        private:
+            EventHolder event_holder;
+        private:
+            Result UpdateDriverInterruptEnabled();
+        public:
+            PadSessionImpl() : event_holder() { /* ... */ }
+
+            ~PadSessionImpl() {
+                this->Close();
+            }
+
+            bool IsInterruptBound() const {
+                return this->event_holder.IsBound();
+            }
+
+            Result Open(Pad *pad, ddsf::AccessMode access_mode);
+            void Close();
+
+            Result BindInterrupt(os::SystemEventType *event);
+            void UnbindInterrupt();
+
+            Result GetInterruptEnabled(bool *out) const;
+            Result SetInterruptEnabled(bool en);
+            void SignalInterruptBoundEvent();
+    };
+    static_assert( sizeof(PadSessionImpl) <= GpioPadSessionSize);
+    static_assert(alignof(PadSessionImpl) <= GpioPadSessionAlign);
+
+    struct alignas(GpioPadSessionAlign) GpioPadSessionImplPadded {
+        PadSessionImpl _impl;
+        u8 _padding[GpioPadSessionSize - sizeof(PadSessionImpl)];
+    };
+    static_assert( sizeof(GpioPadSessionImplPadded) == GpioPadSessionSize);
+    static_assert(alignof(GpioPadSessionImplPadded) == GpioPadSessionAlign);
+
+    ALWAYS_INLINE PadSessionImpl &GetPadSessionImpl(GpioPadSession &session) {
+        return GetReference(session._impl)._impl;
+    }
+
+    ALWAYS_INLINE const PadSessionImpl &GetPadSessionImpl(const GpioPadSession &session) {
+        return GetReference(session._impl)._impl;
+    }
+
+    ALWAYS_INLINE PadSessionImpl &GetOpenPadSessionImpl(GpioPadSession &session) {
+        auto &ref = GetReference(session._impl)._impl;
+        AMS_ASSERT(ref.IsOpen());
+        return ref;
+    }
+
+    ALWAYS_INLINE const PadSessionImpl &GetOpenPadSessionImpl(const GpioPadSession &session) {
+        const auto &ref = GetReference(session._impl)._impl;
+        AMS_ASSERT(ref.IsOpen());
+        return ref;
+    }
+
+}

libraries/libstratosphere/include/stratosphere/gpio/gpio_api.hpp

@@ -13,16 +13,16 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #pragma once
-#include <switch.h>
-#include <stratosphere.hpp>
+#include <vapours.hpp>
+#include <stratosphere/gpio/gpio_types.hpp>
+#include <stratosphere/gpio/sf/gpio_sf_i_manager.hpp>
 
 namespace ams::gpio {
 
-    /* GPIO Utilities. */
-    u32 Configure(u32 gpio_pad_name);
-    u32 SetDirection(u32 gpio_pad_name, GpioDirection dir);
-    u32 SetValue(u32 gpio_pad_name, GpioValue val);
+    void Initialize();
+    void Finalize();
+
+    void InitializeWith(std::shared_ptr<gpio::sf::IManager> &&sp);
 
 }

libraries/libstratosphere/include/stratosphere/gpio/gpio_pad_api.hpp

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/ddsf/ddsf_types.hpp>
+#include <stratosphere/gpio/gpio_types.hpp>
+#include <stratosphere/gpio/gpio_select_pad_name.hpp>
+#include <stratosphere/gpio/driver/gpio_pad.hpp>
+
+namespace ams::gpio {
+
+    struct GpioPadSession {
+        void *_session;
+        os::SystemEventType *_event;
+    };
+
+    Result OpenSession(GpioPadSession *out_session, ams::DeviceCode device_code);
+    void CloseSession(GpioPadSession *session);
+
+    Direction GetDirection(GpioPadSession *session);
+    void SetDirection(GpioPadSession *session, Direction direction);
+
+    GpioValue GetValue(GpioPadSession *session);
+    void SetValue(GpioPadSession *session, GpioValue value);
+
+    InterruptMode GetInterruptMode(GpioPadSession *session);
+    void SetInterruptMode(GpioPadSession *session, InterruptMode mode);
+
+    bool GetInterruptEnable(GpioPadSession *session);
+    void SetInterruptEnable(GpioPadSession *session, bool en);
+
+    InterruptStatus GetInterruptStatus(GpioPadSession *session);
+    void ClearInterruptStatus(GpioPadSession *session);
+
+    int GetDebounceTime(GpioPadSession *session);
+    void SetDebounceTime(GpioPadSession *session, int ms);
+
+    bool GetDebounceEnabled(GpioPadSession *session);
+    void SetDebounceEnabled(GpioPadSession *session, bool en);
+
+    Result BindInterrupt(os::SystemEventType *event, GpioPadSession *session);
+    void UnbindInterrupt(GpioPadSession *session);
+
+    Result IsWakeEventActive(bool *out_is_active, ams::DeviceCode device_code);
+
+}

libraries/libstratosphere/include/stratosphere/gpio/gpio_pad_name.board.nintendo_nx.hpp

@@ -0,0 +1,416 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <vapours.hpp>
+#include <stratosphere/gpio/gpio_types.hpp>
+
+namespace ams::gpio {
+
+    enum GpioPadName : u32 {
+        GpioPadName_CodecLdoEnTemp     = 1,
+        GpioPadName_PowSdEn            = 2,
+        GpioPadName_BtRst              = 3,
+        GpioPadName_RamCode3           = 4,
+        GpioPadName_GameCardReset      = 5,
+        GpioPadName_CodecAlert         = 6,
+        GpioPadName_PowGc              = 7,
+        GpioPadName_DebugControllerDet = 8,
+        GpioPadName_BattChgStatus      = 9,
+        GpioPadName_BattChgEnableN     = 10,
+        GpioPadName_FanTach            = 11,
+        GpioPadName_ExtconDetS         = 12,
+        GpioPadName_Vdd50AEn           = 13,
+        GpioPadName_SdevCoaxSel1       = 14,
+        GpioPadName_GameCardCd         = 15,
+        GpioPadName_ProdType0          = 16,
+        GpioPadName_ProdType1          = 17,
+        GpioPadName_ProdType2          = 18,
+        GpioPadName_ProdType3          = 19,
+        GpioPadName_TempAlert          = 20,
+        GpioPadName_CodecHpDetIrq      = 21,
+        GpioPadName_MotionInt          = 22,
+        GpioPadName_TpIrq              = 23,
+        GpioPadName_ButtonSleep2       = 24,
+        GpioPadName_ButtonVolUp        = 25,
+        GpioPadName_ButtonVolDn        = 26,
+        GpioPadName_BattMgicIrq        = 27,
+        GpioPadName_RecoveryKey        = 28,
+        GpioPadName_PowLcdBlEn         = 29,
+        GpioPadName_LcdReset           = 30,
+        GpioPadName_PdVconnEn          = 31,
+        GpioPadName_PdRstN             = 32,
+        GpioPadName_Bq24190Irq         = 33,
+        GpioPadName_SdevCoaxSel0       = 34,
+        GpioPadName_SdWp               = 35,
+        GpioPadName_TpReset            = 36,
+        GpioPadName_BtGpio2            = 37,
+        GpioPadName_BtGpio3            = 38,
+        GpioPadName_BtGpio4            = 39,
+        GpioPadName_CradleIrq          = 40,
+        GpioPadName_PowVcpuInt         = 41,
+        GpioPadName_Max77621GpuInt     = 42,
+        GpioPadName_ExtconChgU         = 43,
+        GpioPadName_ExtconChgS         = 44,
+        GpioPadName_WifiRfDisable      = 45,
+        GpioPadName_WifiReset          = 46,
+        GpioPadName_ApWakeBt           = 47,
+        GpioPadName_BtWakeAp           = 48,
+        GpioPadName_BtGpio5            = 49,
+        GpioPadName_PowLcdVddPEn       = 50,
+        GpioPadName_PowLcdVddNEn       = 51,
+        GpioPadName_ExtconDetU         = 52,
+        GpioPadName_RamCode2           = 53,
+        GpioPadName_Vdd50BEn           = 54,
+        GpioPadName_WifiWakeHost       = 55,
+        GpioPadName_SdCd               = 56,
+        GpioPadName_OtgFet1ForSdev     = 57,
+        GpioPadName_OtgFet2ForSdev     = 58,
+        GpioPadName_ExtConWakeU        = 59,
+        GpioPadName_ExtConWakeS        = 60,
+        GpioPadName_PmuIrq             = 61,
+        GpioPadName_ExtUart2Cts        = 62,
+        GpioPadName_ExtUart3Cts        = 63,
+        GpioPadName_5VStepDownEn       = 64,
+        GpioPadName_UsbSwitchB2Oc      = 65,
+        GpioPadName_5VStepDownPg       = 66,
+        GpioPadName_UsbSwitchAEn       = 67,
+        GpioPadName_UsbSwitchAFlag     = 68,
+        GpioPadName_UsbSwitchB3Oc      = 69,
+        GpioPadName_UsbSwitchB3En      = 70,
+        GpioPadName_UsbSwitchB2En      = 71,
+        GpioPadName_Hdmi5VEn           = 72,
+        GpioPadName_UsbSwitchB1En      = 73,
+        GpioPadName_HdmiPdTrEn         = 74,
+        GpioPadName_FanEn              = 75,
+        GpioPadName_UsbSwitchB1Oc      = 76,
+        GpioPadName_PwmFan             = 77,
+        GpioPadName_HdmiHpd            = 78,
+        GpioPadName_Max77812Irq        = 79,
+        GpioPadName_Debug0             = 80,
+        GpioPadName_Debug1             = 81,
+        GpioPadName_Debug2             = 82,
+        GpioPadName_Debug3             = 83,
+        GpioPadName_NfcIrq             = 84,
+        GpioPadName_NfcRst             = 85,
+        GpioPadName_McuIrq             = 86,
+        GpioPadName_McuBoot            = 87,
+        GpioPadName_McuRst             = 88,
+        GpioPadName_Vdd5V3En           = 89,
+        GpioPadName_McuPor             = 90,
+        GpioPadName_LcdGpio1           = 91,
+        GpioPadName_NfcEn              = 92,
+    };
+
+    /* TODO: Better place for this? */
+    constexpr inline const DeviceCode DeviceCode_CodecLdoEnTemp     = 0x33000002;
+    constexpr inline const DeviceCode DeviceCode_PowSdEn            = 0x3C000001;
+    constexpr inline const DeviceCode DeviceCode_BtRst              = 0x37000002;
+    constexpr inline const DeviceCode DeviceCode_RamCode3           = 0xC9000402;
+    constexpr inline const DeviceCode DeviceCode_GameCardReset      = 0x3C000402;
+    constexpr inline const DeviceCode DeviceCode_CodecAlert         = 0x33000003;
+    constexpr inline const DeviceCode DeviceCode_PowGc              = 0x3C000401;
+    constexpr inline const DeviceCode DeviceCode_DebugControllerDet = 0x350000CA;
+    constexpr inline const DeviceCode DeviceCode_BattChgStatus      = 0x39000407;
+    constexpr inline const DeviceCode DeviceCode_BattChgEnableN     = 0x39000003;
+    constexpr inline const DeviceCode DeviceCode_FanTach            = 0x3D000002;
+    constexpr inline const DeviceCode DeviceCode_ExtconDetS         = 0x3500040B;
+    constexpr inline const DeviceCode DeviceCode_Vdd50AEn           = 0x39000401;
+    constexpr inline const DeviceCode DeviceCode_SdevCoaxSel1       = 0xCA000402;
+    constexpr inline const DeviceCode DeviceCode_GameCardCd         = 0x3C000403;
+    constexpr inline const DeviceCode DeviceCode_ProdType0          = 0xC900040B;
+    constexpr inline const DeviceCode DeviceCode_ProdType1          = 0xC900040C;
+    constexpr inline const DeviceCode DeviceCode_ProdType2          = 0xC900040D;
+    constexpr inline const DeviceCode DeviceCode_ProdType3          = 0xC900040E;
+    constexpr inline const DeviceCode DeviceCode_TempAlert          = 0x3E000002;
+    constexpr inline const DeviceCode DeviceCode_CodecHpDetIrq      = 0x33000004;
+    constexpr inline const DeviceCode DeviceCode_MotionInt          = 0x35000041;
+    constexpr inline const DeviceCode DeviceCode_TpIrq              = 0x35000036;
+    constexpr inline const DeviceCode DeviceCode_ButtonSleep2       = 0x35000001;
+    constexpr inline const DeviceCode DeviceCode_ButtonVolUp        = 0x35000002;
+    constexpr inline const DeviceCode DeviceCode_ButtonVolDn        = 0x35000003;
+    constexpr inline const DeviceCode DeviceCode_BattMgicIrq        = 0x39000034;
+    constexpr inline const DeviceCode DeviceCode_RecoveryKey        = 0x35000004;
+    constexpr inline const DeviceCode DeviceCode_PowLcdBlEn         = 0x3400003E;
+    constexpr inline const DeviceCode DeviceCode_LcdReset           = 0x34000033;
+    constexpr inline const DeviceCode DeviceCode_PdVconnEn          = 0x040000CC;
+    constexpr inline const DeviceCode DeviceCode_PdRstN             = 0x040000CA;
+    constexpr inline const DeviceCode DeviceCode_Bq24190Irq         = 0x39000002;
+    constexpr inline const DeviceCode DeviceCode_SdevCoaxSel0       = 0xCA000401;
+    constexpr inline const DeviceCode DeviceCode_SdWp               = 0x3C000003;
+    constexpr inline const DeviceCode DeviceCode_TpReset            = 0x35000035;
+    constexpr inline const DeviceCode DeviceCode_BtGpio2            = 0x37000401;
+    constexpr inline const DeviceCode DeviceCode_BtGpio3            = 0x37000402;
+    constexpr inline const DeviceCode DeviceCode_BtGpio4            = 0x37000403;
+    constexpr inline const DeviceCode DeviceCode_CradleIrq          = 0x040000CB;
+    constexpr inline const DeviceCode DeviceCode_PowVcpuInt         = 0x3E000003;
+    constexpr inline const DeviceCode DeviceCode_Max77621GpuInt     = 0x3E000004;
+    constexpr inline const DeviceCode DeviceCode_ExtconChgU         = 0x35000402;
+    constexpr inline const DeviceCode DeviceCode_ExtconChgS         = 0x3500040C;
+    constexpr inline const DeviceCode DeviceCode_WifiRfDisable      = 0x38000003;
+    constexpr inline const DeviceCode DeviceCode_WifiReset          = 0x38000002;
+    constexpr inline const DeviceCode DeviceCode_ApWakeBt           = 0x37000003;
+    constexpr inline const DeviceCode DeviceCode_BtWakeAp           = 0x37000004;
+    constexpr inline const DeviceCode DeviceCode_BtGpio5            = 0x37000404;
+    constexpr inline const DeviceCode DeviceCode_PowLcdVddPEn       = 0x34000034;
+    constexpr inline const DeviceCode DeviceCode_PowLcdVddNEn       = 0x34000035;
+    constexpr inline const DeviceCode DeviceCode_ExtconDetU         = 0x35000401;
+    constexpr inline const DeviceCode DeviceCode_RamCode2           = 0xC9000401;
+    constexpr inline const DeviceCode DeviceCode_Vdd50BEn           = 0x39000402;
+    constexpr inline const DeviceCode DeviceCode_WifiWakeHost       = 0x38000004;
+    constexpr inline const DeviceCode DeviceCode_SdCd               = 0x3C000002;
+    constexpr inline const DeviceCode DeviceCode_OtgFet1ForSdev     = 0x39000404;
+    constexpr inline const DeviceCode DeviceCode_OtgFet2ForSdev     = 0x39000405;
+    constexpr inline const DeviceCode DeviceCode_ExtConWakeU        = 0x35000403;
+    constexpr inline const DeviceCode DeviceCode_ExtConWakeS        = 0x3500040D;
+    constexpr inline const DeviceCode DeviceCode_PmuIrq             = 0x39000406;
+    constexpr inline const DeviceCode DeviceCode_ExtUart2Cts        = 0x35000404;
+    constexpr inline const DeviceCode DeviceCode_ExtUart3Cts        = 0x3500040E;
+    constexpr inline const DeviceCode DeviceCode_5VStepDownEn       = 0x39000408;
+    constexpr inline const DeviceCode DeviceCode_UsbSwitchB2Oc      = 0x04000401;
+    constexpr inline const DeviceCode DeviceCode_5VStepDownPg       = 0x39000409;
+    constexpr inline const DeviceCode DeviceCode_UsbSwitchAEn       = 0x04000402;
+    constexpr inline const DeviceCode DeviceCode_UsbSwitchAFlag     = 0x04000403;
+    constexpr inline const DeviceCode DeviceCode_UsbSwitchB3Oc      = 0x04000404;
+    constexpr inline const DeviceCode DeviceCode_UsbSwitchB3En      = 0x04000405;
+    constexpr inline const DeviceCode DeviceCode_UsbSwitchB2En      = 0x04000406;
+    constexpr inline const DeviceCode DeviceCode_Hdmi5VEn           = 0x34000004;
+    constexpr inline const DeviceCode DeviceCode_UsbSwitchB1En      = 0x04000407;
+    constexpr inline const DeviceCode DeviceCode_HdmiPdTrEn         = 0x34000005;
+    constexpr inline const DeviceCode DeviceCode_FanEn              = 0x3D000003;
+    constexpr inline const DeviceCode DeviceCode_UsbSwitchB1Oc      = 0x04000408;
+    constexpr inline const DeviceCode DeviceCode_PwmFan             = 0x3D000001;
+    constexpr inline const DeviceCode DeviceCode_HdmiHpd            = 0x34000006;
+    constexpr inline const DeviceCode DeviceCode_Max77812Irq        = 0x3E000003;
+    constexpr inline const DeviceCode DeviceCode_Debug0             = 0xCA000001;
+    constexpr inline const DeviceCode DeviceCode_Debug1             = 0xCA000002;
+    constexpr inline const DeviceCode DeviceCode_Debug2             = 0xCA000003;
+    constexpr inline const DeviceCode DeviceCode_Debug3             = 0xCA000004;
+    constexpr inline const DeviceCode DeviceCode_NfcIrq             = 0x36000004;
+    constexpr inline const DeviceCode DeviceCode_NfcRst             = 0x36000003;
+    constexpr inline const DeviceCode DeviceCode_McuIrq             = 0x35000415;
+    constexpr inline const DeviceCode DeviceCode_McuBoot            = 0x35000416;
+    constexpr inline const DeviceCode DeviceCode_McuRst             = 0x35000417;
+    constexpr inline const DeviceCode DeviceCode_Vdd5V3En           = 0x39000403;
+    constexpr inline const DeviceCode DeviceCode_McuPor             = 0x35000418;
+    constexpr inline const DeviceCode DeviceCode_LcdGpio1           = 0x35000005;
+    constexpr inline const DeviceCode DeviceCode_NfcEn              = 0x36000002;
+    constexpr inline const DeviceCode DeviceCode_ExtUart2Rts        = 0x35000406;
+    constexpr inline const DeviceCode DeviceCode_ExtUart3Rts        = 0x35000410;
+    constexpr inline const DeviceCode DeviceCode_GpioPortC7         = 0x3500041B;
+    constexpr inline const DeviceCode DeviceCode_GpioPortD0         = 0x3500041C;
+    constexpr inline const DeviceCode DeviceCode_GpioPortC5         = 0x3500041D;
+    constexpr inline const DeviceCode DeviceCode_GpioPortC6         = 0x3500041E;
+    constexpr inline const DeviceCode DeviceCode_GpioPortY7         = 0x35000065;
+    constexpr inline const DeviceCode DeviceCode_GpioPortF1         = 0x04000409;
+    constexpr inline const DeviceCode DeviceCode_GpioPortH0         = 0x34000401;
+
+    constexpr inline GpioPadName ConvertToGpioPadName(DeviceCode dc) {
+        switch (dc.GetInternalValue()) {
+            case DeviceCode_CodecLdoEnTemp    .GetInternalValue(): return GpioPadName_CodecLdoEnTemp;
+            case DeviceCode_PowSdEn           .GetInternalValue(): return GpioPadName_PowSdEn;
+            case DeviceCode_BtRst             .GetInternalValue(): return GpioPadName_BtRst;
+            case DeviceCode_RamCode3          .GetInternalValue(): return GpioPadName_RamCode3;
+            case DeviceCode_GameCardReset     .GetInternalValue(): return GpioPadName_GameCardReset;
+            case DeviceCode_CodecAlert        .GetInternalValue(): return GpioPadName_CodecAlert;
+            case DeviceCode_PowGc             .GetInternalValue(): return GpioPadName_PowGc;
+            case DeviceCode_DebugControllerDet.GetInternalValue(): return GpioPadName_DebugControllerDet;
+            case DeviceCode_BattChgStatus     .GetInternalValue(): return GpioPadName_BattChgStatus;
+            case DeviceCode_BattChgEnableN    .GetInternalValue(): return GpioPadName_BattChgEnableN;
+            case DeviceCode_FanTach           .GetInternalValue(): return GpioPadName_FanTach;
+            case DeviceCode_ExtconDetS        .GetInternalValue(): return GpioPadName_ExtconDetS;
+            case DeviceCode_Vdd50AEn          .GetInternalValue(): return GpioPadName_Vdd50AEn;
+            case DeviceCode_SdevCoaxSel1      .GetInternalValue(): return GpioPadName_SdevCoaxSel1;
+            case DeviceCode_GameCardCd        .GetInternalValue(): return GpioPadName_GameCardCd;
+            case DeviceCode_ProdType0         .GetInternalValue(): return GpioPadName_ProdType0;
+            case DeviceCode_ProdType1         .GetInternalValue(): return GpioPadName_ProdType1;
+            case DeviceCode_ProdType2         .GetInternalValue(): return GpioPadName_ProdType2;
+            case DeviceCode_ProdType3         .GetInternalValue(): return GpioPadName_ProdType3;
+            case DeviceCode_TempAlert         .GetInternalValue(): return GpioPadName_TempAlert;
+            case DeviceCode_CodecHpDetIrq     .GetInternalValue(): return GpioPadName_CodecHpDetIrq;
+            case DeviceCode_MotionInt         .GetInternalValue(): return GpioPadName_MotionInt;
+            case DeviceCode_TpIrq             .GetInternalValue(): return GpioPadName_TpIrq;
+            case DeviceCode_ButtonSleep2      .GetInternalValue(): return GpioPadName_ButtonSleep2;
+            case DeviceCode_ButtonVolUp       .GetInternalValue(): return GpioPadName_ButtonVolUp;
+            case DeviceCode_ButtonVolDn       .GetInternalValue(): return GpioPadName_ButtonVolDn;
+            case DeviceCode_BattMgicIrq       .GetInternalValue(): return GpioPadName_BattMgicIrq;
+            case DeviceCode_RecoveryKey       .GetInternalValue(): return GpioPadName_RecoveryKey;
+            case DeviceCode_PowLcdBlEn        .GetInternalValue(): return GpioPadName_PowLcdBlEn;
+            case DeviceCode_LcdReset          .GetInternalValue(): return GpioPadName_LcdReset;
+            case DeviceCode_PdVconnEn         .GetInternalValue(): return GpioPadName_PdVconnEn;
+            case DeviceCode_PdRstN            .GetInternalValue(): return GpioPadName_PdRstN;
+            case DeviceCode_Bq24190Irq        .GetInternalValue(): return GpioPadName_Bq24190Irq;
+            case DeviceCode_SdevCoaxSel0      .GetInternalValue(): return GpioPadName_SdevCoaxSel0;
+            case DeviceCode_SdWp              .GetInternalValue(): return GpioPadName_SdWp;
+            case DeviceCode_TpReset           .GetInternalValue(): return GpioPadName_TpReset;
+            case DeviceCode_BtGpio2           .GetInternalValue(): return GpioPadName_BtGpio2;
+            case DeviceCode_BtGpio3           .GetInternalValue(): return GpioPadName_BtGpio3;
+            case DeviceCode_BtGpio4           .GetInternalValue(): return GpioPadName_BtGpio4;
+            case DeviceCode_CradleIrq         .GetInternalValue(): return GpioPadName_CradleIrq;
+         /* case DeviceCode_PowVcpuInt        .GetInternalValue(): return GpioPadName_PowVcpuInt; */
+            case DeviceCode_Max77621GpuInt    .GetInternalValue(): return GpioPadName_Max77621GpuInt;
+            case DeviceCode_ExtconChgU        .GetInternalValue(): return GpioPadName_ExtconChgU;
+            case DeviceCode_ExtconChgS        .GetInternalValue(): return GpioPadName_ExtconChgS;
+            case DeviceCode_WifiRfDisable     .GetInternalValue(): return GpioPadName_WifiRfDisable;
+            case DeviceCode_WifiReset         .GetInternalValue(): return GpioPadName_WifiReset;
+            case DeviceCode_ApWakeBt          .GetInternalValue(): return GpioPadName_ApWakeBt;
+            case DeviceCode_BtWakeAp          .GetInternalValue(): return GpioPadName_BtWakeAp;
+            case DeviceCode_BtGpio5           .GetInternalValue(): return GpioPadName_BtGpio5;
+            case DeviceCode_PowLcdVddPEn      .GetInternalValue(): return GpioPadName_PowLcdVddPEn;
+            case DeviceCode_PowLcdVddNEn      .GetInternalValue(): return GpioPadName_PowLcdVddNEn;
+            case DeviceCode_ExtconDetU        .GetInternalValue(): return GpioPadName_ExtconDetU;
+            case DeviceCode_RamCode2          .GetInternalValue(): return GpioPadName_RamCode2;
+            case DeviceCode_Vdd50BEn          .GetInternalValue(): return GpioPadName_Vdd50BEn;
+            case DeviceCode_WifiWakeHost      .GetInternalValue(): return GpioPadName_WifiWakeHost;
+            case DeviceCode_SdCd              .GetInternalValue(): return GpioPadName_SdCd;
+            case DeviceCode_OtgFet1ForSdev    .GetInternalValue(): return GpioPadName_OtgFet1ForSdev;
+            case DeviceCode_OtgFet2ForSdev    .GetInternalValue(): return GpioPadName_OtgFet2ForSdev;
+            case DeviceCode_ExtConWakeU       .GetInternalValue(): return GpioPadName_ExtConWakeU;
+            case DeviceCode_ExtConWakeS       .GetInternalValue(): return GpioPadName_ExtConWakeS;
+            case DeviceCode_PmuIrq            .GetInternalValue(): return GpioPadName_PmuIrq;
+            case DeviceCode_ExtUart2Cts       .GetInternalValue(): return GpioPadName_ExtUart2Cts;
+            case DeviceCode_ExtUart3Cts       .GetInternalValue(): return GpioPadName_ExtUart3Cts;
+            case DeviceCode_5VStepDownEn      .GetInternalValue(): return GpioPadName_5VStepDownEn;
+            case DeviceCode_UsbSwitchB2Oc     .GetInternalValue(): return GpioPadName_UsbSwitchB2Oc;
+            case DeviceCode_5VStepDownPg      .GetInternalValue(): return GpioPadName_5VStepDownPg;
+            case DeviceCode_UsbSwitchAEn      .GetInternalValue(): return GpioPadName_UsbSwitchAEn;
+            case DeviceCode_UsbSwitchAFlag    .GetInternalValue(): return GpioPadName_UsbSwitchAFlag;
+            case DeviceCode_UsbSwitchB3Oc     .GetInternalValue(): return GpioPadName_UsbSwitchB3Oc;
+            case DeviceCode_UsbSwitchB3En     .GetInternalValue(): return GpioPadName_UsbSwitchB3En;
+            case DeviceCode_UsbSwitchB2En     .GetInternalValue(): return GpioPadName_UsbSwitchB2En;
+            case DeviceCode_Hdmi5VEn          .GetInternalValue(): return GpioPadName_Hdmi5VEn;
+            case DeviceCode_UsbSwitchB1En     .GetInternalValue(): return GpioPadName_UsbSwitchB1En;
+            case DeviceCode_HdmiPdTrEn        .GetInternalValue(): return GpioPadName_HdmiPdTrEn;
+            case DeviceCode_FanEn             .GetInternalValue(): return GpioPadName_FanEn;
+            case DeviceCode_UsbSwitchB1Oc     .GetInternalValue(): return GpioPadName_UsbSwitchB1Oc;
+            case DeviceCode_PwmFan            .GetInternalValue(): return GpioPadName_PwmFan;
+            case DeviceCode_HdmiHpd           .GetInternalValue(): return GpioPadName_HdmiHpd;
+            case DeviceCode_Max77812Irq       .GetInternalValue(): return GpioPadName_Max77812Irq;
+            case DeviceCode_Debug0            .GetInternalValue(): return GpioPadName_Debug0;
+            case DeviceCode_Debug1            .GetInternalValue(): return GpioPadName_Debug1;
+            case DeviceCode_Debug2            .GetInternalValue(): return GpioPadName_Debug2;
+            case DeviceCode_Debug3            .GetInternalValue(): return GpioPadName_Debug3;
+            case DeviceCode_NfcIrq            .GetInternalValue(): return GpioPadName_NfcIrq;
+            case DeviceCode_NfcRst            .GetInternalValue(): return GpioPadName_NfcRst;
+            case DeviceCode_McuIrq            .GetInternalValue(): return GpioPadName_McuIrq;
+            case DeviceCode_McuBoot           .GetInternalValue(): return GpioPadName_McuBoot;
+            case DeviceCode_McuRst            .GetInternalValue(): return GpioPadName_McuRst;
+            case DeviceCode_Vdd5V3En          .GetInternalValue(): return GpioPadName_Vdd5V3En;
+            case DeviceCode_McuPor            .GetInternalValue(): return GpioPadName_McuPor;
+            case DeviceCode_LcdGpio1          .GetInternalValue(): return GpioPadName_LcdGpio1;
+            case DeviceCode_NfcEn             .GetInternalValue(): return GpioPadName_NfcEn;
+            AMS_UNREACHABLE_DEFAULT_CASE();
+        }
+    }
+
+    constexpr inline DeviceCode ConvertToDeviceCode(GpioPadName gpn) {
+        switch (gpn) {
+            case GpioPadName_CodecLdoEnTemp:     return DeviceCode_CodecLdoEnTemp;
+            case GpioPadName_PowSdEn:            return DeviceCode_PowSdEn;
+            case GpioPadName_BtRst:              return DeviceCode_BtRst;
+            case GpioPadName_RamCode3:           return DeviceCode_RamCode3;
+            case GpioPadName_GameCardReset:      return DeviceCode_GameCardReset;
+            case GpioPadName_CodecAlert:         return DeviceCode_CodecAlert;
+            case GpioPadName_PowGc:              return DeviceCode_PowGc;
+            case GpioPadName_DebugControllerDet: return DeviceCode_DebugControllerDet;
+            case GpioPadName_BattChgStatus:      return DeviceCode_BattChgStatus;
+            case GpioPadName_BattChgEnableN:     return DeviceCode_BattChgEnableN;
+            case GpioPadName_FanTach:            return DeviceCode_FanTach;
+            case GpioPadName_ExtconDetS:         return DeviceCode_ExtconDetS;
+            case GpioPadName_Vdd50AEn:           return DeviceCode_Vdd50AEn;
+            case GpioPadName_SdevCoaxSel1:       return DeviceCode_SdevCoaxSel1;
+            case GpioPadName_GameCardCd:         return DeviceCode_GameCardCd;
+            case GpioPadName_ProdType0:          return DeviceCode_ProdType0;
+            case GpioPadName_ProdType1:          return DeviceCode_ProdType1;
+            case GpioPadName_ProdType2:          return DeviceCode_ProdType2;
+            case GpioPadName_ProdType3:          return DeviceCode_ProdType3;
+            case GpioPadName_TempAlert:          return DeviceCode_TempAlert;
+            case GpioPadName_CodecHpDetIrq:      return DeviceCode_CodecHpDetIrq;
+            case GpioPadName_MotionInt:          return DeviceCode_MotionInt;
+            case GpioPadName_TpIrq:              return DeviceCode_TpIrq;
+            case GpioPadName_ButtonSleep2:       return DeviceCode_ButtonSleep2;
+            case GpioPadName_ButtonVolUp:        return DeviceCode_ButtonVolUp;
+            case GpioPadName_ButtonVolDn:        return DeviceCode_ButtonVolDn;
+            case GpioPadName_BattMgicIrq:        return DeviceCode_BattMgicIrq;
+            case GpioPadName_RecoveryKey:        return DeviceCode_RecoveryKey;
+            case GpioPadName_PowLcdBlEn:         return DeviceCode_PowLcdBlEn;
+            case GpioPadName_LcdReset:           return DeviceCode_LcdReset;
+            case GpioPadName_PdVconnEn:          return DeviceCode_PdVconnEn;
+            case GpioPadName_PdRstN:             return DeviceCode_PdRstN;
+            case GpioPadName_Bq24190Irq:         return DeviceCode_Bq24190Irq;
+            case GpioPadName_SdevCoaxSel0:       return DeviceCode_SdevCoaxSel0;
+            case GpioPadName_SdWp:               return DeviceCode_SdWp;
+            case GpioPadName_TpReset:            return DeviceCode_TpReset;
+            case GpioPadName_BtGpio2:            return DeviceCode_BtGpio2;
+            case GpioPadName_BtGpio3:            return DeviceCode_BtGpio3;
+            case GpioPadName_BtGpio4:            return DeviceCode_BtGpio4;
+            case GpioPadName_CradleIrq:          return DeviceCode_CradleIrq;
+            case GpioPadName_PowVcpuInt:         return DeviceCode_PowVcpuInt;
+            case GpioPadName_Max77621GpuInt:     return DeviceCode_Max77621GpuInt;
+            case GpioPadName_ExtconChgU:         return DeviceCode_ExtconChgU;
+            case GpioPadName_ExtconChgS:         return DeviceCode_ExtconChgS;
+            case GpioPadName_WifiRfDisable:      return DeviceCode_WifiRfDisable;
+            case GpioPadName_WifiReset:          return DeviceCode_WifiReset;
+            case GpioPadName_ApWakeBt:           return DeviceCode_ApWakeBt;
+            case GpioPadName_BtWakeAp:           return DeviceCode_BtWakeAp;
+            case GpioPadName_BtGpio5:            return DeviceCode_BtGpio5;
+            case GpioPadName_PowLcdVddPEn:       return DeviceCode_PowLcdVddPEn;
+            case GpioPadName_PowLcdVddNEn:       return DeviceCode_PowLcdVddNEn;
+            case GpioPadName_ExtconDetU:         return DeviceCode_ExtconDetU;
+            case GpioPadName_RamCode2:           return DeviceCode_RamCode2;
+            case GpioPadName_Vdd50BEn:           return DeviceCode_Vdd50BEn;
+            case GpioPadName_WifiWakeHost:       return DeviceCode_WifiWakeHost;
+            case GpioPadName_SdCd:               return DeviceCode_SdCd;
+            case GpioPadName_OtgFet1ForSdev:     return DeviceCode_OtgFet1ForSdev;
+            case GpioPadName_OtgFet2ForSdev:     return DeviceCode_OtgFet2ForSdev;
+            case GpioPadName_ExtConWakeU:        return DeviceCode_ExtConWakeU;
+            case GpioPadName_ExtConWakeS:        return DeviceCode_ExtConWakeS;
+            case GpioPadName_PmuIrq:             return DeviceCode_PmuIrq;
+            case GpioPadName_ExtUart2Cts:        return DeviceCode_ExtUart2Cts;
+            case GpioPadName_ExtUart3Cts:        return DeviceCode_ExtUart3Cts;
+            case GpioPadName_5VStepDownEn:       return DeviceCode_5VStepDownEn;
+            case GpioPadName_UsbSwitchB2Oc:      return DeviceCode_UsbSwitchB2Oc;
+            case GpioPadName_5VStepDownPg:       return DeviceCode_5VStepDownPg;
+            case GpioPadName_UsbSwitchAEn:       return DeviceCode_UsbSwitchAEn;
+            case GpioPadName_UsbSwitchAFlag:     return DeviceCode_UsbSwitchAFlag;
+            case GpioPadName_UsbSwitchB3Oc:      return DeviceCode_UsbSwitchB3Oc;
+            case GpioPadName_UsbSwitchB3En:      return DeviceCode_UsbSwitchB3En;
+            case GpioPadName_UsbSwitchB2En:      return DeviceCode_UsbSwitchB2En;
+            case GpioPadName_Hdmi5VEn:           return DeviceCode_Hdmi5VEn;
+            case GpioPadName_UsbSwitchB1En:      return DeviceCode_UsbSwitchB1En;
+            case GpioPadName_HdmiPdTrEn:         return DeviceCode_HdmiPdTrEn;
+            case GpioPadName_FanEn:              return DeviceCode_FanEn;
+            case GpioPadName_UsbSwitchB1Oc:      return DeviceCode_UsbSwitchB1Oc;
+            case GpioPadName_PwmFan:             return DeviceCode_PwmFan;
+            case GpioPadName_HdmiHpd:            return DeviceCode_HdmiHpd;
+            case GpioPadName_Max77812Irq:        return DeviceCode_Max77812Irq;
+            case GpioPadName_Debug0:             return DeviceCode_Debug0;
+            case GpioPadName_Debug1:             return DeviceCode_Debug1;
+            case GpioPadName_Debug2:             return DeviceCode_Debug2;
+            case GpioPadName_Debug3:             return DeviceCode_Debug3;
+            case GpioPadName_NfcIrq:             return DeviceCode_NfcIrq;
+            case GpioPadName_NfcRst:             return DeviceCode_NfcRst;
+            case GpioPadName_McuIrq:             return DeviceCode_McuIrq;
+            case GpioPadName_McuBoot:            return DeviceCode_McuBoot;
+            case GpioPadName_McuRst:             return DeviceCode_McuRst;
+            case GpioPadName_Vdd5V3En:           return DeviceCode_Vdd5V3En;
+            case GpioPadName_McuPor:             return DeviceCode_McuPor;
+            case GpioPadName_LcdGpio1:           return DeviceCode_LcdGpio1;
+            case GpioPadName_NfcEn:              return DeviceCode_NfcEn;
+            AMS_UNREACHABLE_DEFAULT_CASE();
+        }
+    }
+
+}