Merge upstream Horizon-OC main into Horizon-OC-pro.

This reverts commit 88ca2e8688.

.clang-format

@@ -7,28 +7,41 @@ BasedOnStyle: LLVM
 IndentWidth: 4
 UseTab: Never
 
-BreakBeforeBraces: Linux
+# === Struct/Union/Class member indentation ===
+# These options control indentation of struct members to ensure consistent
+# 4-space indentation for all struct/union/class members
+IndentAccessModifiers: false
+AccessModifierOffset: 0
+NamespaceIndentation: All
+IndentPPDirectives: BeforeHash
+
+BreakBeforeBraces: Attach
 BraceWrapping:
   AfterControlStatement: false
-  AfterFunction: true
+  AfterFunction: false
   AfterClass: false
   AfterStruct: false
+  # AfterStruct: false keeps struct opening brace on same line (K&R style)
+  # Struct members will still be indented with IndentWidth: 4
   AfterUnion: false
   AfterNamespace: false
   AfterEnum: false
   BeforeCatch: false
   BeforeElse: false
   IndentBraces: false
+  # IndentBraces: false ensures braces themselves are not indented,
+  # but content inside braces respects IndentWidth setting
 
-ContinuationIndentWidth: 0
-AlignAfterOpenBracket: false
 AllowShortIfStatementsOnASingleLine: false
 AllowShortLoopsOnASingleLine: false
 AllowShortBlocksOnASingleLine: Always
-IndentCaseLabels: false
-SpaceAfterCStyleCast: true
+# AllowShortFunctionsOnASingleLine: None enforces function bodies
+# to always be on separate lines, following K&R convention
 AllowShortFunctionsOnASingleLine: None
-ColumnLimit: 80
+
+IndentCaseLabels: true
+SpaceAfterCStyleCast: false
+ColumnLimit: 150
 MaxEmptyLinesToKeep: 1
 Cpp11BracedListStyle: false
 AlignTrailingComments: true
@@ -39,7 +52,9 @@ IncludeBlocks: Regroup
 IncludeCategories:
   - Regex:           '<[[:alnum:].]+>'
     Priority:        1
+    # System headers (angle brackets) have highest priority
   - Regex:           '.*'
     Priority:        2
+    # Project headers (quotes) have lower priority
 SortIncludes: CaseSensitive
 AlignEscapedNewlines: Left

.github/workflows/build.yml

@@ -12,7 +12,7 @@ jobs:
 
     # Minimal devkitA64 container
     container:
-      image: devkitpro/devkita64:20251231
+      image: devkitpro/devkita64:20260219
 
     steps:
       - name: Checkout repository and submodules # needed for hoc-clk
@@ -54,6 +54,9 @@ jobs:
           echo $SHORT_SHA > dist/.commit
           echo $GITHUB_SHA >> dist/.commit
 
+      - name: Clone Libnx
+        run: git clone https://github.com/switchbrew/libnx.git --depth=1 --single-branch -b v4.12.0
+
       - name: Clone Atmosphere
         run: git clone --depth=1 --single-branch https://github.com/Atmosphere-NX/Atmosphere.git atmosphere -b $(cat ams_ver.txt)
 
@@ -67,29 +70,46 @@ jobs:
           cp -rf Source/Atmosphere/stratosphere/loader/source/* build/stratosphere/loader/source/
 
       - name: Cache ccache
-        uses: actions/cache@v5.0.3
+        uses: actions/cache@v5.0.5
         with:
-          path: /root/.cache/ccache
-          key: ccache-${{ runner.os }}-devkitpro-ams-${{ hashFiles('ams_ver.txt') }} # last key was utter garbage, stick to ams versions, 
+          path: .ccache
+          key: ccache-${{ runner.os }}-devkitpro-ams-${{ hashFiles('ams_ver.txt') }}
           restore-keys: |
             ccache-${{ runner.os }}-devkitpro-
 
       - name: Configure ccache
         run: |
-          export CCACHE_DIR=/root/.cache/ccache
-          echo "CCACHE_DIR=/root/.cache/ccache" >> $GITHUB_ENV
+          export CCACHE_DIR="$GITHUB_WORKSPACE/.ccache"
+          export CCACHE_COMPILERCHECK=content
+          export CCACHE_NOHASHDIR=true
+          echo "CCACHE_DIR=$GITHUB_WORKSPACE/.ccache" >> $GITHUB_ENV
+          echo "CCACHE_BASEDIR=$GITHUB_WORKSPACE" >> $GITHUB_ENV
+          echo "CCACHE_COMPILERCHECK=content" >> $GITHUB_ENV
+          echo "CCACHE_NOHASHDIR=true" >> $GITHUB_ENV
           ccache --set-config=max_size=10G
           ccache --set-config=compiler_check=content
-          ccache --zero-stats
-          
+          ccache --set-config=hash_dir=false
+          ccache -s
+          ls -lah "$GITHUB_WORKSPACE/.ccache"
+
+      - name: Build Libnx
+        shell: bash
+        run: |
+          export CC="ccache aarch64-none-elf-gcc"
+          export CXX="ccache aarch64-none-elf-g++"
+          pushd libnx
+          make -j$(($(nproc) * 4)) install CXX="ccache aarch64-none-elf-g++" CC="ccache aarch64-none-elf-gcc"
+          popd
+
       - name: Build hoc-clk sysmodule and overlay
         shell: bash
         run: |
           export CC="ccache aarch64-none-elf-gcc"
           export CXX="ccache aarch64-none-elf-g++"
 
-          ROOT_DIR="$GITHUB_WORKSPACE/Source/sys-clk"
+          ROOT_DIR="$GITHUB_WORKSPACE/Source/hoc-clk"
           DIST_DIR="$ROOT_DIR/dist"
+          echo "DIST_DIR="$ROOT_DIR/dist"" >> $GITHUB_ENV
           
           mkdir -p "$DIST_DIR"
 
@@ -101,13 +121,14 @@ jobs:
           echo "TITLE_ID: $TITLE_ID"
 
           pushd "$ROOT_DIR/sysmodule"
+          git config --global --add safe.directory "$GITHUB_WORKSPACE"
           make -j$(($(nproc) * 2)) CXX="ccache aarch64-none-elf-g++" CC="ccache aarch64-none-elf-gcc"
           popd
 
           mkdir -p "$DIST_DIR/atmosphere/contents/$TITLE_ID/flags"
 
           cp -vf \
-            "$ROOT_DIR/sysmodule/out/horizon-oc.nsp" \
+            "$ROOT_DIR/sysmodule/out/hoc-clk.nsp" \
             "$DIST_DIR/atmosphere/contents/$TITLE_ID/exefs.nsp"
 
           : >"$DIST_DIR/atmosphere/contents/$TITLE_ID/flags/boot2.flag"
@@ -149,8 +170,11 @@ jobs:
           hactool -t kip1 out/nintendo_nx_arm64_armv8a/release/loader.kip --uncompress=hoc.kip
           cp hoc.kip ../../../dist/atmosphere/kips/hoc.kip
           
-      - name: ccache stats
-        run: ccache --show-stats
+      - name: ccache stat
+        run: |
+             ccache --show-stats
+             ccache -s
+             ccache --show-config
 
       # -------------------------------------------------
       # Upload ZIP artifact
@@ -159,5 +183,5 @@ jobs:
         uses: actions/upload-artifact@v6
         with:
           name: horizon-oc-zeus-dist
-          path: dist/
-          compression-level: 3
+          path: $DIST_DIR
+          compression-level: 6

.gitignore

@@ -4,3 +4,7 @@
 build/
 __pycache__/
 build
+*.dksh
+Source/hekate
+dist/*
+!dist/.gitignore

.gitmodules

@@ -1,9 +1,4 @@
-[submodule "Source/Horizon-OC-Monitor/lib/Atmosphere-libs"]
-	path = Source/Horizon-OC-Monitor/lib/Atmosphere-libs
-	url = https://github.com/Atmosphere-NX/Atmosphere-libs
-[submodule "Source/Horizon-OC-Monitor/lib/libultrahand"]
-	path = Source/Horizon-OC-Monitor/lib/libultrahand
+[submodule "Source/hoc-clk/overlay/lib/libultrahand"]
+	path = Source/hoc-clk/overlay/lib/libultrahand
 	url = https://github.com/ppkantorski/libultrahand
-[submodule "Source/sys-clk/overlay/lib/libultrahand"]
-	path = Source/sys-clk/overlay/lib/libultrahand
-	url = https://github.com/ppkantorski/libultrahand
+	branch = main

COMPILING.md

@@ -1,12 +1,8 @@
-Horizon OC Zeus Compilation Instructions
+Horizon OC Compilation Instructions
 
 1. Install devkitpro (https://devkitpro.org/wiki/Getting_Started) with switch-dev
 2. Set up a development enviorment for compiling Atmosphere (https://github.com/Atmosphere-NX/Atmosphere/blob/master/docs/building.md)
-3. Install GNU make and ENSURE THAT YOUR ENVIORMENT HAS A PYTHON3 COMMAND AVAILABLE!
-4. Git clone atmosphere (git clone https://github.com/Atmosphere-NX/Atmosphere.git)
-5. Clone the Horizon OC develop branch (git clone -b develop --single-branch https://github.com/Horizon-OC/Horizon-OC.git)
-6. Create a new folder named "build" in the horizon oc repo
-7. Copy atmosphere files into that build folder
-8. Copy Source/Atmosphere/stratosphere/loader/source/ldr_process_creation.cpp to build/stratosphere/loader/source/ldr_process_creation.cpp, replacing any files if prompted
-9. Grab a copy of libultrahand (https://github.com/ppkantorski/libultrahand) and place it into Source/sys-clk/overlay/lib/libultrahand
-10. Run ./build.sh in the root directory
+3. Clone the Horizon OC develop branch (``git clone https://github.com/Horizon-OC/Horizon-OC.git --recurse-submodules``)
+4. Run ``./build.sh`` in the root directory
+ - If you want to compile with extensions, append ``--ext``
+ - Installing ``ccache`` is optional; if it is on your PATH it is used automatically to speed up rebuilds

README.md

@@ -11,7 +11,7 @@
 ![VSCode](https://img.shields.io/badge/VSCode-0078D4?style=for-the-badge\&logo=visual%20studio%20code\&logoColor=white)
 ![Made with Notepad++](assets/np++.png?raw=true)
 ![C++](https://img.shields.io/badge/C%2B%2B-00599C?style=for-the-badge\&logo=c%2B%2B\&logoColor=white)
-![Downloads](https://img.shields.io/github/downloads/souldbminersmwc/Horizon-OC/total.svg?style=for-the-badge)
+![Downloads](https://img.shields.io/github/downloads/Horizon-OC/Horizon-OC/total.svg?style=for-the-badge)
 
 ---
 
@@ -21,7 +21,7 @@
 
 > **THIS TOOL CAN BE DANGEROUS IF MISUSED. PROCEED WITH CAUTION.**
 > Due to the design of Horizon OS, **overclocking RAM can cause NAND OR SD CORRUPTION.**
-> Ensure you have a **full NAND, PROINFO, EMUMMC and SD backup** before proceeding.
+> Ensure you have a **full NAND, PRODINFO, EMUMMC and SD backup** before proceeding.
 
 ---
 
@@ -32,7 +32,7 @@ It enables advanced CPU, GPU, and RAM tuning with user-friendly configuration to
 
 ---
 
-## Features
+## Default clocks
 
 * **CPU:** Up to 1963MHz (Mariko) / 1785MHz (Erista)
 * **GPU:** Up to 1075MHz (Mariko) / 921MHz (Erista)
@@ -56,6 +56,7 @@ It enables advanced CPU, GPU, and RAM tuning with user-friendly configuration to
 
    ```
    kip1=atmosphere/kips/hoc.kip
+   secmon=atmosphere/exosphere.bin
    ```
 
    *(No changes needed if using fusee.)*
@@ -71,6 +72,12 @@ It enables advanced CPU, GPU, and RAM tuning with user-friendly configuration to
 
 ---
 
+## Donating
+
+We don't accept donations. Put your spare cash into a charity instead :)
+
+---
+
 ## Building from Source
 
 Refer to COMPILATION.md
@@ -78,22 +85,66 @@ Refer to COMPILATION.md
 ---
 ## Clock table
 
-### MEM clocks
+### MEM clocks (mhz)
+
 * 3200 → max on mariko, JEDEC.
+* 3166
+* 3133
+* 3100
+* 3066
+* 3033
+* 3000
+* 2966
 * 2933 → JEDEC.
+* 2900
+* 2866
+* 2833
+* 2800
+* 2766
+* 2733
+* 2700
 * 2666 → JEDEC.
+* 2633
+* 2600
+* 2566
+* 2533
+* 2500
+* 2466
+* 2433
 * 2400 → max on erista, JEDEC.
-* 2133 → mariko safe max (4266 Modules), JEDEC.
-* 1996 → JEDEC.
-* 1866 → mariko safe max (3733 Modules), JEDEC.
-* 1600 → official docked, boost mode, erista safe max, JEDEC.
+* 2366
+* 2333
+* 2300
+* 2266
+* 2233
+* 2200
+* 2166
+* 2133 → Mariko JEDEC standard max (4266 Modules)
+* 2100
+* 2066
+* 2033
+* 2000
+* 1996 → JEDEC standard
+* 1966
+* 1933
+* 1900
+* 1866 → Mariko JEDEC standard max (3733 Modules)
+* 1833
+* 1800
+* 1766
+* 1733
+* 1700
+* 1666
+* 1633
+* 1600 → official docked, boost mode, Erista JEDEC standard max (3200 Modules), JEDEC.
 * 1331 → official handheld, JEDEC.
 * 1065
 * 800
 * 665
 
-### CPU clocks
-* 2601 → mariko absolute max, very dangerous
+### CPU clocks (mhz)
+* 2703 → mariko absolute max, dangerous
+* 2601 → unsafe
 * 2499
 * 2397 → mariko safe max with UV (low speedo)
 * 2295
@@ -113,21 +164,18 @@ Refer to COMPILATION.md
 * 816
 * 714
 * 612 → sleep mode
-  
-**Notes:**
-1. On Erista, CPU in handheld is capped to 1581MHz
 
-### GPU clocks
-* 1536 → absolute max clock on mariko. very dangerous
-* 1459
-* 1382
+### GPU clocks (mhz)
+* 1536 → absolute max clock on mariko. Dangerous
+* 1497 → max mariko unsafe clock 
+* 1382 → Max mariko "safe" clock
 * 1305
-* 1267 → NVIDIA T214 rating
-* 1228 → mariko HiOPT safe clock
-* 1152 → mariko SLT max clock
-* 1075 → mariko no UV max clock. absolute max clock on erista. very dangerous
-* 998 → NVIDIA T210 rating
-* 960 (erista only) → erista slt/hiopt safe max clock
+* 1267 → NVIDIA T214(mariko) rating
+* 1228 → mariko High UV safe clock
+* 1152 → mariko hiOpt-15mV max clock
+* 1075 → mariko hiOpt max clock. absolute max clock on erista. very dangerous
+* 998 → NVIDIA T210 (erista) rating
+* 960 (erista only) → erista high uv/hiOpt-15mV safe max clock
 * 921 → erista no UV max clock
 * 844
 * 768 → official docked
@@ -142,27 +190,33 @@ Refer to COMPILATION.md
 * 76 → boost mode
 
 **Notes:**
-1. GPU overclock is capped at 460MHz on erista in handheld
-2. On Mariko, cap with No uv is 614MHz, with SLT it is 691MHz and with HiOPT it's 768MHz
-3. Clocks higher than 768MHz on erista need the official charger is plugged in.
-4. On Mariko, cap with No uv is 844MHz, with SLT it is 921MHz and with HiOPT it's 998MHz
+1. On Erista, CPU in handheld is capped to 1581MHz
+2. GPU overclock is capped at 460MHz on erista in handheld
+3. On Mariko, cap with hiOpt is 614MHz, with hiOpt-15mV it is 691MHz and with High UV it's 768MHz
+4. Clocks higher than 768MHz on erista need the official charger is plugged in.
 
 ---
 
 ## Credits
 * **Lightos's Cat** - Cat
-
-* **Souldbminer** – hoc-clk and loader development
-* **Lightos** – loader patches development
+* **Souldbminer** - hoc-clk and loader development
+* **Lightos** - Loader patches development, hoc-clk development, guides
+* **TDRR** - HOC Logo Design
+* **tetetete-ctrl** - Website design
 * **SciresM** - Atmosphere CFW
-* **CTCaer** - L4T, Hekate, perfect ram timings
-* **KazushiMe** – Switch OC Suite
-* **hanai3bi (meha)** – Switch OC Suite, EOS, sys-clk-eos
-* **NaGaa95** – L4T-OC-kernel
-* **B3711 (halop)** – EOS
-* **sys-clk team (m4xw, p-sam, natinusala)** – sys-clk
-* **b0rd2death** – Ultrahand sys-clk & Status Monitor fork
+* **CTCaer** - L4T, Hekate, proper RAM timings
+* **KazushiMe** - Switch OC Suite
+* **Hanai3bi (Meha)** - Switch OC Suite, EOS, sys-clk-eos
+* **NaGaa95** - L4T-OC kernel, Status Monitor fork
+* **B3711 (halop)** - EOS, contributions
+* **sys-clk team (m4xw, p-sam, natinusala)** - sys-clk
+* **Dominatorul** - Soctherm driver, guides, general help
+* **ppkantorski** - Ultrahand sys-clk & Status Monitor fork
 * **MasaGratoR and ZachyCatGames** - General help
-* **MasaGratoR** - Status Monitor & Display Refresh Rate Driver
-* **Dom, Samybigio, Arcdelta, Miki, Happy, Flopsider, Winnerboi77, Blaise, Alvise, TDRR, agjeococh, frost, letum00 and Xenshen** - Testing
-* **Samybigio2011** - Italian translations
+* **MasaGratoR** - Status Monitor & Display Refresh Rate driver
+* **Dominatorul, Samybigio, Arcdelta, Miki, Happy, Winnerboi77, Blaise, Alvise, agjeococh, frost, letum00, and Xenshen** - Testing
+* **Samybigio2011, Miki** - Italian translations
+* **angelblaster** - Korean translations
+* **q1332348216-glitch** - Chinese translations
+* **th3-ne0undr5c0r** - French translations
+* **Nvidia** - [Tegra X1 Technical Reference Manual](https://developer.nvidia.com/embedded/dlc/tegra-x1-technical-reference-manual), soctherm driver, L4T

SECURITY.md

@@ -4,8 +4,9 @@
 
 | Version | Supported          |
 | ------- | ------------------ |
-| 1.x     | :white_check_mark: |
-| 0.x     | Not supported |
+| 2.x.x     | :white_check_mark: |
+| 1.x.x     | Not supported |
+| 0.x.x     | Not supported |
 
 ## Reporting a Vulnerability
 

Source/Atmosphere-Patches/secmon_define_emc1_access_table.inc

@@ -1,25 +0,0 @@
-/*
- * Copyright (c) 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/>.
- */
-
-#define __ACCESS_TABLE_NAME__    EmcAccessTable1
-#define __ACCESS_TABLE_ADDRESS__ MemoryRegionPhysicalDeviceExternalMemoryController1.GetAddress()
-#define __ACCESS_TABLE_INC__     "secmon_emc_access_table_data.inc"
-
-#include "secmon_define_access_table.inc"
-
-#undef __ACCESS_TABLE_INC__
-#undef __ACCESS_TABLE_ADDRESS__
-#undef __ACCESS_TABLE_NAME__

Source/Atmosphere-Patches/secmon_define_rtc_pmc_access_table.inc

@@ -14,9 +14,9 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#define __ACCESS_TABLE_NAME__    SocthermAccessTable
-#define __ACCESS_TABLE_ADDRESS__ MemoryRegionPhysicalDeviceSoctherm.GetAddress()
-#define __ACCESS_TABLE_INC__     "secmon_soctherm_access_table_data.inc"
+#define __ACCESS_TABLE_NAME__    RtcPmcAccessTable
+#define __ACCESS_TABLE_ADDRESS__ MemoryRegionPhysicalDeviceRtcPmc.GetAddress()
+#define __ACCESS_TABLE_INC__     "secmon_rtc_pmc_access_table_data.inc"
 
 #include "secmon_define_access_table.inc"
 

Source/Atmosphere-Patches/secmon_memory_layout.hpp

@@ -123,7 +123,7 @@ namespace ams::secmon {
     constexpr inline const MemoryRegion MemoryRegionPhysicalIramBootCode = MemoryRegion(UINT64_C(0x40020000), 0x20000);
     static_assert(MemoryRegionPhysicalIram.Contains(MemoryRegionPhysicalIramBootCode));
 
-    constexpr inline const MemoryRegion MemoryRegionVirtualDevice = MemoryRegion(UINT64_C(0x1F0040000), UINT64_C(0x40000 + 0x2000));
+    constexpr inline const MemoryRegion MemoryRegionVirtualDevice = MemoryRegion(UINT64_C(0x1F0040000), UINT64_C(0x40000));
     static_assert(MemoryRegionVirtual.Contains(MemoryRegionVirtualDevice));
 
     constexpr inline const MemoryRegion MemoryRegionVirtualDeviceEmpty = MemoryRegion(MemoryRegionVirtualDevice.GetStartAddress(), 0);
@@ -155,9 +155,6 @@ namespace ams::secmon {
         HANDLER(Disp1,                                         Sdmmc, UINT64_C(0x54200000), UINT64_C(0x3000), true, ## __VA_ARGS__) \
         HANDLER(Dsi,                                           Disp1, UINT64_C(0x54300000), UINT64_C(0x1000), true, ## __VA_ARGS__) \
         HANDLER(MipiCal,                                         Dsi, UINT64_C(0x700E3000), UINT64_C(0x1000), true, ## __VA_ARGS__) \
-        HANDLER(Soctherm,                                    MipiCal, UINT64_C(0x700E2000), UINT64_C(0x1000), true, ## __VA_ARGS__) \
-        HANDLER(ExternalMemoryController1,                  Soctherm, UINT64_C(0x7001e000), UINT64_C(0x1000), true, ## __VA_ARGS__) \
-        HANDLER(ExternalMemoryController2, ExternalMemoryController1, UINT64_C(0x7001f000), UINT64_C(0x1000), true, ## __VA_ARGS__) \
 
     #define DEFINE_DEVICE_REGION(_NAME_, _PREV_, _ADDRESS_, _SIZE_, _SECURE_)                                                                                      \
         constexpr inline const MemoryRegion MemoryRegionVirtualDevice##_NAME_  = MemoryRegion(MemoryRegionVirtualDevice##_PREV_.GetEndAddress() + 0x1000, _SIZE_); \

Source/Atmosphere-Patches/secmon_smc_handler.cpp

@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) 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>
+#include "../secmon_error.hpp"
+#include "../secmon_misc.hpp"
+#include "secmon_smc_common.hpp"
+#include "secmon_smc_handler.hpp"
+#include "secmon_smc_aes.hpp"
+#include "secmon_smc_carveout.hpp"
+#include "secmon_smc_device_unique_data.hpp"
+#include "secmon_smc_error.hpp"
+#include "secmon_smc_info.hpp"
+#include "secmon_smc_memory_access.hpp"
+#include "secmon_smc_power_management.hpp"
+#include "secmon_smc_random.hpp"
+#include "secmon_smc_register_access.hpp"
+#include "secmon_smc_result.hpp"
+#include "secmon_smc_rsa.hpp"
+
+namespace ams::secmon::smc {
+
+    namespace {
+
+        struct HandlerInfo {
+            u32 function_id;
+            u32 restriction_mask;
+            SmcHandler handler;
+        };
+
+        struct HandlerTable {
+            const HandlerInfo *entries;
+            size_t count;
+        };
+
+        enum HandlerType : int {
+            HandlerType_User  = 0,
+            HandlerType_Kern  = 1,
+            HandlerType_Count = 2,
+        };
+
+        enum Restriction {
+            Restriction_None                       = (0 << 0),
+            Restriction_Normal                     = (1 << 0),
+            Restriction_DeviceUniqueDataNotAllowed = (1 << 1),
+            Restriction_SafeModeNotAllowed         = (1 << 2),
+        };
+
+        enum SmcCallRange {
+            SmcCallRange_ArmArch    = 0,
+            SmcCallRange_Cpu        = 1,
+            SmcCallRange_Sip        = 2,
+            SmcCallRange_Oem        = 3,
+            SmcCallRange_Standard   = 4,
+
+            SmcCallRange_TrustedApp = 0x30,
+        };
+
+        enum SmcArgumentType {
+            ArgumentType_Integer = 0,
+            ArgumentType_Pointer = 1,
+        };
+
+        enum SmcConvention {
+            Convention_Smc32 = 0,
+            Convention_Smc64 = 1,
+        };
+
+        enum SmcCallType {
+            SmcCallType_YieldingCall = 0,
+            SmcCallType_FastCall     = 1,
+        };
+
+        struct SmcFunctionId {
+            using FunctionId    = util::BitPack64::Field< 0,  8, u32>;
+            using ArgumentType0 = util::BitPack64::Field< 8,  1, SmcArgumentType>;
+            using ArgumentType1 = util::BitPack64::Field< 9,  1, SmcArgumentType>;
+            using ArgumentType2 = util::BitPack64::Field<10,  1, SmcArgumentType>;
+            using ArgumentType3 = util::BitPack64::Field<11,  1, SmcArgumentType>;
+            using ArgumentType4 = util::BitPack64::Field<12,  1, SmcArgumentType>;
+            using ArgumentType5 = util::BitPack64::Field<13,  1, SmcArgumentType>;
+            using ArgumentType6 = util::BitPack64::Field<14,  1, SmcArgumentType>;
+            using ArgumentType7 = util::BitPack64::Field<15,  1, SmcArgumentType>;
+            using Reserved      = util::BitPack64::Field<16,  8, u32>;
+            using CallRange     = util::BitPack64::Field<24,  6, SmcCallRange>;
+            using Convention    = util::BitPack64::Field<30,  1, SmcConvention>;
+            using CallType      = util::BitPack64::Field<31,  1, SmcCallType>;
+            using Reserved2     = util::BitPack64::Field<32, 32, u32>;
+        };
+
+        constinit HandlerInfo g_user_handlers[] = {
+            { 0x00000000, Restriction_SafeModeNotAllowed,         nullptr                            },
+            { 0xC3000401, Restriction_SafeModeNotAllowed,         SmcSetConfig                       },
+            { 0xC3000002, Restriction_Normal,                     SmcGetConfigUser                   },
+            { 0xC3000003, Restriction_Normal,                     SmcGetResult                       },
+            { 0xC3000404, Restriction_Normal,                     SmcGetResultData                   },
+            { 0xC3000E05, Restriction_SafeModeNotAllowed,         SmcModularExponentiate             },
+            { 0xC3000006, Restriction_Normal,                     SmcGenerateRandomBytes             },
+            { 0xC3000007, Restriction_Normal,                     SmcGenerateAesKek                  },
+            { 0xC3000008, Restriction_Normal,                     SmcLoadAesKey                      },
+            { 0xC3000009, Restriction_Normal,                     SmcComputeAes                      },
+            { 0xC300000A, Restriction_Normal,                     SmcGenerateSpecificAesKey          },
+            { 0xC300040B, Restriction_Normal,                     SmcComputeCmac                     },
+            { 0xC300D60C, Restriction_Normal,                     SmcReencryptDeviceUniqueData       },
+            { 0xC300100D, Restriction_DeviceUniqueDataNotAllowed, SmcDecryptDeviceUniqueData         },
+            { 0xC300000E, Restriction_SafeModeNotAllowed,         nullptr                            },
+            { 0xC300060F, Restriction_DeviceUniqueDataNotAllowed, SmcModularExponentiateByStorageKey },
+            { 0xC3000610, Restriction_SafeModeNotAllowed,         SmcPrepareEsDeviceUniqueKey        },
+            { 0xC3000011, Restriction_SafeModeNotAllowed,         SmcLoadPreparedAesKey              },
+            { 0xC3000012, Restriction_SafeModeNotAllowed,         SmcPrepareEsCommonTitleKey         }
+        };
+
+        /* Deprecated handlerss. */
+        constexpr inline const HandlerInfo DecryptAndImportEsDeviceKeyHandlerInfo = {
+              0xC300100C, Restriction_Normal, SmcDecryptAndImportEsDeviceKey
+        };
+
+        constexpr inline const HandlerInfo DecryptAndImportLotusKeyHandlerInfo = {
+              0xC300100E, Restriction_SafeModeNotAllowed, SmcDecryptAndImportLotusKey
+        };
+
+        constinit HandlerInfo g_kern_handlers[] = {
+            { 0x00000000, Restriction_SafeModeNotAllowed, nullptr },
+            { 0xC4000001, Restriction_SafeModeNotAllowed, SmcSuspendCpu                     },
+            { 0x84000002, Restriction_SafeModeNotAllowed, SmcPowerOffCpu                    },
+            { 0xC4000003, Restriction_SafeModeNotAllowed, SmcPowerOnCpu                     },
+            { 0xC3000004, Restriction_Normal,             SmcGetConfigKern                  },
+            { 0xC3000005, Restriction_Normal,             SmcGenerateRandomBytesNonBlocking },
+            { 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[] = {
+            { 0x00000000, Restriction_SafeModeNotAllowed, nullptr              },
+            { 0xF0000201, Restriction_None,               SmcIramCopy          },
+            { 0xF0000002, Restriction_None,               SmcReadWriteRegister },
+            { 0xF0000003, Restriction_None,               SmcWriteAddress      },
+            { 0xF0000404, Restriction_None,               SmcGetEmummcConfig   },
+            { 0xF0000005, Restriction_None,               SmcShowError         },
+        };
+
+        constexpr const HandlerInfo GetSecureDataHandlerInfo = {
+            0x67891234, Restriction_None, SmcGetSecureData
+        };
+
+        constinit HandlerTable g_handler_tables[] = {
+            { g_user_handlers, util::size(g_user_handlers) },
+            { g_kern_handlers, util::size(g_kern_handlers) },
+        };
+
+        constinit HandlerTable g_ams_handler_table = {
+            g_ams_handlers,  util::size(g_ams_handlers)
+        };
+
+        NORETURN void InvalidSmcError(u64 id) {
+            SetError(pkg1::ErrorInfo_UnknownSmc);
+            AMS_ABORT("Invalid SMC: %lx", id);
+        }
+
+        const HandlerTable &GetHandlerTable(HandlerType type, u64 id) {
+            /* Ensure we have a valid handler type. */
+            if (AMS_UNLIKELY(!(0 <= type && type < HandlerType_Count))) {
+                InvalidSmcError(id);
+            }
+
+            /* Provide support for legacy SmcGetSecureData. */
+            if (id == GetSecureDataHandlerInfo.function_id) {
+                return g_handler_tables[HandlerType_User];
+            }
+
+            /* Check if we're a user SMC. */
+            if (type == HandlerType_User) {
+                /* Nintendo uses OEM SMCs. */
+                /* We will assign Atmosphere extension SMCs the TrustedApplication range. */
+                if (util::BitPack64{id}.Get<SmcFunctionId::CallRange>() == SmcCallRange_TrustedApp) {
+                    return g_ams_handler_table;
+                }
+
+                /* If we're not performing an atmosphere extension smc, require that we're being invoked by spl on core 3. */
+                if (AMS_UNLIKELY(hw::GetCurrentCoreId() != 3)) {
+                    InvalidSmcError(id);
+                }
+            }
+
+            return g_handler_tables[type];
+        }
+
+        const HandlerInfo &GetHandlerInfo(const HandlerTable &table, u64 id) {
+            /* Provide support for legacy SmcGetSecureData. */
+            if (id == GetSecureDataHandlerInfo.function_id) {
+                return GetSecureDataHandlerInfo;
+            }
+
+            /* Get and check the index. */
+            const auto index = util::BitPack64{id}.Get<SmcFunctionId::FunctionId>();
+            if (AMS_UNLIKELY(index >= table.count)) {
+                InvalidSmcError(id);
+            }
+
+            /* Get and check the handler info. */
+            const auto &handler_info = table.entries[index];
+
+            /* Check that the handler isn't null. */
+            if (AMS_UNLIKELY(handler_info.handler == nullptr)) {
+                InvalidSmcError(id);
+            }
+
+            /* Check that the handler's id matches. */
+            if (AMS_UNLIKELY(handler_info.function_id != id)) {
+                InvalidSmcError(id);
+            }
+
+            return handler_info;
+        }
+
+        bool IsHandlerRestricted(const HandlerInfo &info) {
+            return (info.restriction_mask & secmon::GetRestrictedSmcMask()) != 0;
+        }
+
+        SmcResult InvokeSmcHandler(const HandlerInfo &info, SmcArguments &args) {
+            /* Check if the smc is restricted. */
+            if (GetTargetFirmware() >= TargetFirmware_8_0_0 && AMS_UNLIKELY(IsHandlerRestricted(info))) {
+                return SmcResult::NotPermitted;
+            }
+
+            /* Invoke the smc. */
+            return info.handler(args);
+        }
+
+    }
+
+    void ConfigureSmcHandlersForTargetFirmware() {
+        const auto target_fw = GetTargetFirmware();
+
+        if (target_fw < TargetFirmware_5_0_0) {
+            g_user_handlers[DecryptAndImportEsDeviceKeyHandlerInfo.function_id & 0xFF] = DecryptAndImportEsDeviceKeyHandlerInfo;
+            g_user_handlers[DecryptAndImportLotusKeyHandlerInfo.function_id & 0xFF]    = DecryptAndImportLotusKeyHandlerInfo;
+        }
+    }
+
+    void HandleSmc(int type, SmcArguments &args) {
+        /* Get the table. */
+        const auto &table = GetHandlerTable(static_cast<HandlerType>(type), args.r[0]);
+
+        /* Get the handler info. */
+        const auto &info = GetHandlerInfo(table, args.r[0]);
+
+        /* Set the invocation result. */
+        args.r[0] = static_cast<u64>(InvokeSmcHandler(info, args));
+    }
+
+}

Source/Atmosphere-Patches/secmon_smc_register_access.cpp

@@ -99,20 +99,16 @@ namespace ams::secmon::smc {
         #include "secmon_define_pmc_access_table.inc"
         #include "secmon_define_mc_access_table.inc"
         #include "secmon_define_emc_access_table.inc"
-        #include "secmon_define_emc1_access_table.inc"
-        #include "secmon_define_emc2_access_table.inc"
-        #include "secmon_define_soctherm_access_table.inc"
+        #include "secmon_define_rtc_pmc_access_table.inc"
         #include "secmon_define_mc01_access_table.inc"
 
         constexpr const AccessTableEntry AccessTables[] = {
-            { PmcAccessTable::ReducedAccessTable.data(),      MemoryRegionVirtualDevicePmc.GetAddress(),                                          PmcAccessTable::Address,                                                             PmcAccessTable::Size,      },
-            { McAccessTable::ReducedAccessTable.data(),       MemoryRegionVirtualDeviceMemoryController.GetAddress(),                             McAccessTable::Address,                                                              McAccessTable::Size,       },
-            { EmcAccessTable::ReducedAccessTable.data(),      MemoryRegionVirtualDeviceExternalMemoryController.GetAddress(),                     EmcAccessTable::Address,                                                             EmcAccessTable::Size,      },
-            { EmcAccessTable1::ReducedAccessTable.data(),      MemoryRegionVirtualDeviceExternalMemoryController1.GetAddress(),                     EmcAccessTable1::Address,                                                             EmcAccessTable1::Size,      },
-            { EmcAccessTable2::ReducedAccessTable.data(),      MemoryRegionVirtualDeviceExternalMemoryController2.GetAddress(),                     EmcAccessTable2::Address,                                                             EmcAccessTable2::Size,      },
-            { SocthermAccessTable::ReducedAccessTable.data(), MemoryRegionVirtualDeviceSoctherm.GetAddress(),                                     SocthermAccessTable::Address,                                                        SocthermAccessTable::Size, },
-            { Mc01AccessTable::ReducedAccessTable.data(),     Mc01AccessTable::Address + MemoryRegionVirtualDeviceMemoryController0.GetAddress(), Mc01AccessTable::Address + MemoryRegionPhysicalDeviceMemoryController0.GetAddress(), Mc01AccessTable::Size,     },
-            { Mc01AccessTable::ReducedAccessTable.data(),     Mc01AccessTable::Address + MemoryRegionVirtualDeviceMemoryController1.GetAddress(), Mc01AccessTable::Address + MemoryRegionPhysicalDeviceMemoryController1.GetAddress(), Mc01AccessTable::Size,     },
+            { PmcAccessTable::ReducedAccessTable.data(),    MemoryRegionVirtualDevicePmc.GetAddress(),                                          PmcAccessTable::Address,                                                             PmcAccessTable::Size,    },
+            { McAccessTable::ReducedAccessTable.data(),     MemoryRegionVirtualDeviceMemoryController.GetAddress(),                             McAccessTable::Address,                                                              McAccessTable::Size,     },
+            { EmcAccessTable::ReducedAccessTable.data(),    MemoryRegionVirtualDeviceExternalMemoryController.GetAddress(),                     EmcAccessTable::Address,                                                             EmcAccessTable::Size,    },
+            { RtcPmcAccessTable::ReducedAccessTable.data(), MemoryRegionVirtualDeviceRtcPmc.GetAddress(),                                       RtcPmcAccessTable::Address,                                                          RtcPmcAccessTable::Size, },
+            { Mc01AccessTable::ReducedAccessTable.data(),   Mc01AccessTable::Address + MemoryRegionVirtualDeviceMemoryController0.GetAddress(), Mc01AccessTable::Address + MemoryRegionPhysicalDeviceMemoryController0.GetAddress(), Mc01AccessTable::Size,   },
+            { Mc01AccessTable::ReducedAccessTable.data(),   Mc01AccessTable::Address + MemoryRegionVirtualDeviceMemoryController1.GetAddress(), Mc01AccessTable::Address + MemoryRegionPhysicalDeviceMemoryController1.GetAddress(), Mc01AccessTable::Size,   },
         };
 
         constexpr bool IsAccessAllowed(const AccessTableEntry &entry, uintptr_t address) {

Source/Atmosphere/stratosphere/loader/loader.json

@@ -0,0 +1,88 @@
+{
+    "name": "Loader",
+    "title_id": "0x0100000000000001",
+    "main_thread_stack_size": "0x4000",
+    "main_thread_priority": 49,
+    "default_cpu_id": 3,
+    "process_category": 1,
+    "use_secure_memory": true,
+    "immortal": true,
+    "kernel_capabilities": [
+        {
+            "type": "handle_table_size",
+            "value": 128
+        },
+        {
+            "type": "syscalls",
+            "value": {
+                "svcSetHeapSize"                     : "0x01",
+                "svcSetMemoryPermission"             : "0x02",
+                "svcSetMemoryAttribute"              : "0x03",
+                "svcMapMemory"                       : "0x04",
+                "svcUnmapMemory"                     : "0x05",
+                "svcQueryMemory"                     : "0x06",
+                "svcExitProcess"                     : "0x07",
+                "svcCreateThread"                    : "0x08",
+                "svcStartThread"                     : "0x09",
+                "svcExitThread"                      : "0x0A",
+                "svcSleepThread"                     : "0x0B",
+                "svcGetThreadPriority"               : "0x0C",
+                "svcSetThreadPriority"               : "0x0D",
+                "svcGetThreadCoreMask"               : "0x0E",
+                "svcSetThreadCoreMask"               : "0x0F",
+                "svcGetCurrentProcessorNumber"       : "0x10",
+                "svcSignalEvent"                     : "0x11",
+                "svcClearEvent"                      : "0x12",
+                "svcMapSharedMemory"                 : "0x13",
+                "svcUnmapSharedMemory"               : "0x14",
+                "svcCreateTransferMemory"            : "0x15",
+                "svcCloseHandle"                     : "0x16",
+                "svcResetSignal"                     : "0x17",
+                "svcWaitSynchronization"             : "0x18",
+                "svcCancelSynchronization"           : "0x19",
+                "svcArbitrateLock"                   : "0x1A",
+                "svcArbitrateUnlock"                 : "0x1B",
+                "svcWaitProcessWideKeyAtomic"        : "0x1C",
+                "svcSignalProcessWideKey"            : "0x1D",
+                "svcGetSystemTick"                   : "0x1E",
+                "svcConnectToNamedPort"              : "0x1F",
+                "svcSendSyncRequestLight"            : "0x20",
+                "svcSendSyncRequest"                 : "0x21",
+                "svcSendSyncRequestWithUserBuffer"   : "0x22",
+                "svcSendAsyncRequestWithUserBuffer"  : "0x23",
+                "svcGetProcessId"                    : "0x24",
+                "svcGetThreadId"                     : "0x25",
+                "svcBreak"                           : "0x26",
+                "svcOutputDebugString"               : "0x27",
+                "svcReturnFromException"             : "0x28",
+                "svcGetInfo"                         : "0x29",
+                "svcWaitForAddress"                  : "0x34",
+                "svcSignalToAddress"                 : "0x35",
+                "svcSynchronizePreemptionState"      : "0x36",
+                "svcCreateSession"                   : "0x40",
+                "svcAcceptSession"                   : "0x41",
+                "svcReplyAndReceiveLight"            : "0x42",
+                "svcReplyAndReceive"                 : "0x43",
+                "svcReplyAndReceiveWithUserBuffer"   : "0x44",
+                "svcCreateEvent"                     : "0x45",
+                "svcReadWriteRegister"               : "0x4E",
+                "svcQueryIoMapping"                  : "0x55",
+                "svcSetProcessMemoryPermission"      : "0x73",
+                "svcMapProcessMemory"                : "0x74",
+                "svcUnmapProcessMemory"              : "0x75",
+                "svcMapProcessCodeMemory"            : "0x77",
+                "svcUnmapProcessCodeMemory"          : "0x78",
+                "svcCreateProcess"                   : "0x79",
+                "svcCallSecureMonitor"               : "0x7F"
+            }
+        }, {
+			"type":	"map",
+			"value":	{
+				"address":	"0x7000F000",
+				"is_ro":	false,
+				"size":	"0x00001000",
+				"is_io":	true
+			}
+        }
+    ]
+}

Source/Atmosphere/stratosphere/loader/source/ldr_process_creation.cpp

@@ -1,8 +1,6 @@
 /*
  * Copyright (c) Atmosphère-NX
  *
- * Copyright (c) Souldbminer, Lightos_ and Horizon OC Contributors
- *
  * 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.
@@ -95,6 +93,8 @@ namespace ams::ldr {
 
         struct ProcessInfo {
             os::NativeHandle process_handle;
+            uintptr_t code_address;
+            size_t    total_size;
             uintptr_t args_address;
             size_t    args_size;
             uintptr_t nso_address[Nso_Count];
@@ -106,7 +106,16 @@ namespace ams::ldr {
             bool has_main;
             bool has_sdk;
             bool has_subsdk;
-            bool has_nso[Nso_Count];
+            s8   nso_indices[Nso_Count];
+        };
+
+        struct AutoLoadModuleContext {
+            NsoHeader *headers;
+            int        nso_count;
+            int        rtld_idx;
+            int        main_nso_idx;
+            int        sdk_nso_idx;
+            AutoLoadModuleInfo ali;
         };
 
         /* Global NSO header cache. */
@@ -116,6 +125,10 @@ namespace ams::ldr {
         bool g_is_pcv;
         bool g_is_ptm;
 
+        /* Global Zstd decompression context. */
+        constexpr size_t ZstdDctxWorkspaceSize = 0x176E8;
+        alignas(8) u8 g_zstd_dctx_workspace[ZstdDctxWorkspaceSize];
+
         Result ValidateProgramVersion(ncm::ProgramId program_id, u32 version) {
             /* No version verification is done before 8.1.0. */
             R_SUCCEED_IF(hos::GetVersion() < hos::Version_8_1_0);
@@ -176,10 +189,15 @@ namespace ams::ldr {
             return static_cast<Acid::PoolPartition>((meta->acid->flags & Acid::AcidFlag_PoolPartitionMask) >> Acid::AcidFlag_PoolPartitionShift);
         }
 
-        Result LoadAutoLoadHeaders(NsoHeader *nso_headers, AutoLoadModuleInfo *ali, u32 acid_flags) {
+        Result LoadAutoLoadHeaders(AutoLoadModuleContext &ctx, u32 acid_flags) {
             /* Clear NSOs. */
-            std::memset(nso_headers, 0, sizeof(*nso_headers) * Nso_Count);
-            *ali = {};
+            std::memset(g_nso_headers, 0, sizeof(g_nso_headers));
+            ctx.headers      = g_nso_headers;
+            ctx.nso_count    = 0;
+            ctx.rtld_idx     = -1;
+            ctx.main_nso_idx = -1;
+            ctx.sdk_nso_idx  = -1;
+            ctx.ali          = {};
 
             for (size_t i = 0; i < Nso_Count; i++) {
                 /* Only load browser DLLs if acid flags say to do so. */
@@ -206,16 +224,18 @@ namespace ams::ldr {
 
                     /* Read NSO header. */
                     size_t read_size;
-                    R_TRY(fs::ReadFile(std::addressof(read_size), file, 0, nso_headers + i, sizeof(*nso_headers)));
-                    R_UNLESS(read_size == sizeof(*nso_headers), ldr::ResultInvalidNso());
+                    R_TRY(fs::ReadFile(std::addressof(read_size), file, 0, g_nso_headers + ctx.nso_count, sizeof(NsoHeader)));
+                    R_UNLESS(read_size == sizeof(NsoHeader), ldr::ResultInvalidNso());
 
                     /* Note nso is present. */
                     switch (i) {
                         case Nso_Rtld:
-                            ali->has_rtld = true;
+                            ctx.rtld_idx = ctx.nso_count;
+                            ctx.ali.has_rtld = true;
                             break;
                         case Nso_Main:
-                            ali->has_main = true;
+                            ctx.main_nso_idx = ctx.nso_count;
+                            ctx.ali.has_main = true;
                             break;
                         case Nso_SubSdk0:
                         case Nso_SubSdk1:
@@ -227,64 +247,65 @@ namespace ams::ldr {
                         case Nso_SubSdk7:
                         case Nso_SubSdk8:
                         case Nso_SubSdk9:
-                            ali->has_subsdk = true;
+                            ctx.ali.has_subsdk = true;
                             break;
                         case Nso_Sdk:
-                            ali->has_sdk = true;
+                            ctx.sdk_nso_idx = ctx.nso_count;
+                            ctx.ali.has_sdk = true;
                             break;
                     }
-                    ali->has_nso[i] = true;
+                    ctx.ali.nso_indices[ctx.nso_count] = static_cast<s8>(i);
+                    ctx.nso_count++;
                 }
             }
 
             R_SUCCEED();
         }
 
-        Result CheckAutoLoad(const NsoHeader *nso_headers, const AutoLoadModuleInfo *ali, u32 acid_flags) {
+        Result CheckAutoLoad(const AutoLoadModuleContext &ctx, u32 acid_flags) {
             /* We must always have a main. */
-            R_UNLESS(ali->has_main, ldr::ResultInvalidNso());
+            R_UNLESS(ctx.ali.has_main, ldr::ResultInvalidNso());
 
-            /* All NSOs must not be --X. */
-            /* This is "probably" not checked on Ounce? */
-            for (size_t i = 0; i < Nso_Count; ++i) {
-                R_UNLESS((nso_headers[i].flags & NsoHeader::Flag_PreventCodeReads) == 0, ldr::ResultInvalidNso());
-            }
+            /* Validate flags and extents for all present NSOs. */
+            for (int i = 0; i < ctx.nso_count; ++i) {
+                const auto &hdr = ctx.headers[i];
 
-            /* If we don't have an RTLD, we must only have a main. */
-            const bool has_browser_dll = (acid_flags & Acid::AcidFlag_LoadBrowserCoreDll) != 0;
-            if (!ali->has_rtld) {
-                /* If don't have rtld, we must also not have sdk. */
-                R_UNLESS(!ali->has_sdk, ldr::ResultInvalidNso());
+                /* All NSOs must not be --X. */
+                /* This is "probably" not checked on Ounce? */
+                R_UNLESS((hdr.flags & NsoHeader::Flag_PreventCodeReads) == 0, ldr::ResultInvalidNso());
 
-                /* We must also not have both subsdk and browser dll. */
-                R_UNLESS(!(ali->has_subsdk && has_browser_dll), ldr::ResultInvalidNso());
-            } else {
-                /* If we have rtld, we must not have browser core dll. */
-                R_UNLESS(!has_browser_dll, ldr::ResultInvalidNso());
-            }
-
-            /* Check NSO extents. */
-            for (size_t i = 0; i < Nso_Count; i++) {
-                /* Only validate the nsos we have. */
-                if (!ali->has_nso[i]) {
-                    continue;
+                /* Zstd compression only allowed on main, and only when both rtld+sdk are present. */
+                if (i != ctx.main_nso_idx || ctx.rtld_idx < 0 || ctx.sdk_nso_idx < 0) {
+                    R_UNLESS((hdr.flags & NsoHeader::Flag_UseZbicCompression) == 0, ldr::ResultInvalidNso());
                 }
 
                 /* NSOs must have page-aligned segments. */
-                R_UNLESS(util::IsAligned(nso_headers[i].text_dst_offset, os::MemoryPageSize), ldr::ResultInvalidNso());
-                R_UNLESS(util::IsAligned(nso_headers[i].ro_dst_offset,   os::MemoryPageSize), ldr::ResultInvalidNso());
-                R_UNLESS(util::IsAligned(nso_headers[i].rw_dst_offset,   os::MemoryPageSize), ldr::ResultInvalidNso());
+                R_UNLESS(util::IsAligned(hdr.text_dst_offset, os::MemoryPageSize), ldr::ResultInvalidNso());
+                R_UNLESS(util::IsAligned(hdr.ro_dst_offset,   os::MemoryPageSize), ldr::ResultInvalidNso());
+                R_UNLESS(util::IsAligned(hdr.rw_dst_offset,   os::MemoryPageSize), ldr::ResultInvalidNso());
 
                 /* NSOs must have zero text offset. */
-                R_UNLESS(nso_headers[i].text_dst_offset == 0, ldr::ResultInvalidNso());
+                R_UNLESS(hdr.text_dst_offset == 0, ldr::ResultInvalidNso());
 
                 /* NSO .text must precede .rodata. */
-                const size_t text_end = static_cast<size_t>(nso_headers[i].text_dst_offset) + static_cast<size_t>(nso_headers[i].text_size);
-                R_UNLESS(text_end <= static_cast<size_t>(nso_headers[i].ro_dst_offset), ldr::ResultInvalidNso());
+                const size_t text_end = static_cast<size_t>(hdr.text_dst_offset) + static_cast<size_t>(hdr.text_size);
+                R_UNLESS(text_end <= static_cast<size_t>(hdr.ro_dst_offset), ldr::ResultInvalidNso());
 
                 /* NSO .rodata must precede .rwdata. */
-                const size_t ro_end   = static_cast<size_t>(nso_headers[i].ro_dst_offset)   + static_cast<size_t>(nso_headers[i].ro_size);
-                R_UNLESS(ro_end <= static_cast<size_t>(nso_headers[i].rw_dst_offset), ldr::ResultInvalidNso());
+                const size_t ro_end = static_cast<size_t>(hdr.ro_dst_offset) + static_cast<size_t>(hdr.ro_size);
+                R_UNLESS(ro_end <= static_cast<size_t>(hdr.rw_dst_offset), ldr::ResultInvalidNso());
+            }
+
+            const bool has_browser_dll = (acid_flags & Acid::AcidFlag_LoadBrowserCoreDll) != 0;
+            if (ctx.ali.has_rtld || ctx.ali.has_sdk) {
+                /* If we have sdk we must have rtld. */
+                R_UNLESS(ctx.ali.has_rtld, ldr::ResultInvalidNso());
+
+                /* If we have rtld, we must not have browser core dll. */
+                R_UNLESS(!has_browser_dll, ldr::ResultInvalidNso());
+            } else {
+                /* We must not have both subsdk and browser dll. */
+                R_UNLESS(!(ctx.ali.has_subsdk && has_browser_dll), ldr::ResultInvalidNso());
             }
 
             R_SUCCEED();
@@ -300,8 +321,8 @@ namespace ams::ldr {
             { 0x010049900F546001 }, /* Super Mario 3D All-Stars: Super Mario 64 */
             { 0x010057D00ECE4000 }, /* Nintendo Switch Online (Nintendo 64) [for Japan] */
             { 0x01006F8002326000 }, /* Animal Crossing: New Horizons */
-            { 0x01006FB00F50E000 }, /* [???] */
-            { 0x010070300F50C000 }, /* [???] */
+            { 0x01006FB00F50E000 }, /* 宝可梦 走吧！伊布 [Pokemon: Let's Go, Eevee! for China] */
+            { 0x010070300F50C000 }, /* 宝可梦 走吧！皮卡丘 [Pokemon: Let's Go, Pikachu! for China] */
             { 0x010075100E8EC000 }, /* 马力欧卡丁车8 豪华版 [Mario Kart 8 Deluxe for China] */
             { 0x01008DB008C2C000 }, /* Pokemon Shield */
             { 0x01009AD008C4C000 }, /* Pokemon: Let's Go, Pikachu! [Kiosk] */
@@ -525,7 +546,7 @@ namespace ams::ldr {
             return rand % (max + 1);
         }
 
-        Result DecideAddressSpaceLayout(ProcessInfo *out, svc::CreateProcessParameter *out_param, const NsoHeader *nso_headers, const AutoLoadModuleInfo *ali, const ArgumentStore::Entry *argument) {
+        Result DecideAddressSpaceLayout(ProcessInfo *out, svc::CreateProcessParameter *out_param, const AutoLoadModuleContext &ctx, const ArgumentStore::Entry *argument) {
             /* Clear output. */
             out->args_address = 0;
             out->args_size = 0;
@@ -536,35 +557,38 @@ namespace ams::ldr {
             bool argument_allocated = false;
 
             /* Calculate base offsets. */
-            for (size_t i = 0; i < Nso_Count; i++) {
-                if (ali->has_nso[i]) {
-                    out->nso_address[i] = total_size;
-                    const size_t text_end = static_cast<size_t>(nso_headers[i].text_dst_offset) + static_cast<size_t>(nso_headers[i].text_size);
-                    const size_t ro_end   = static_cast<size_t>(nso_headers[i].ro_dst_offset)   + static_cast<size_t>(nso_headers[i].ro_size);
-                    const size_t rw_end   = static_cast<size_t>(nso_headers[i].rw_dst_offset)   + static_cast<size_t>(nso_headers[i].rw_size);
-                    out->nso_size[i] = text_end;
-                    out->nso_size[i] = std::max(out->nso_size[i], ro_end);
-                    out->nso_size[i] = std::max(out->nso_size[i], rw_end);
-                    out->nso_size[i] += static_cast<size_t>(nso_headers[i].bss_size);
+            for (int i = 0; i < ctx.nso_count; i++) {
+                out->nso_address[i] = total_size;
+                const size_t text_end = static_cast<size_t>(ctx.headers[i].text_dst_offset) + static_cast<size_t>(ctx.headers[i].text_size);
+                const size_t ro_end   = static_cast<size_t>(ctx.headers[i].ro_dst_offset)   + static_cast<size_t>(ctx.headers[i].ro_size);
+                const size_t rw_end   = static_cast<size_t>(ctx.headers[i].rw_dst_offset)   + static_cast<size_t>(ctx.headers[i].rw_size);
+                out->nso_size[i] = text_end;
+                out->nso_size[i] = std::max(out->nso_size[i], ro_end);
+                out->nso_size[i] = std::max(out->nso_size[i], rw_end);
+                out->nso_size[i] += static_cast<size_t>(ctx.headers[i].bss_size);
 
-                    const size_t aligned_up_size = util::AlignUp(out->nso_size[i], os::MemoryPageSize) & (AutoLoadModuleSizeMax - 1);
-                    R_UNLESS(out->nso_size[i] <= aligned_up_size, ldr::ResultInvalidNso());
-                    R_UNLESS(aligned_up_size > 0,                 ldr::ResultInvalidNso());
+                /* Reserve hook arena memory past pcv's bss. */
+                if (g_is_pcv && i == ctx.main_nso_idx) {
+                    out->nso_size[i] = util::AlignUp(out->nso_size[i], os::MemoryPageSize) + hoc::pcv::PcvDataArenaSize;
+                }
 
-                    out->nso_size[i] = aligned_up_size;
+                const size_t aligned_up_size = util::AlignUp(out->nso_size[i], os::MemoryPageSize) & (AutoLoadModuleSizeMax - 1);
+                R_UNLESS(out->nso_size[i] <= aligned_up_size, ldr::ResultInvalidNso());
+                R_UNLESS(aligned_up_size > 0,                 ldr::ResultInvalidNso());
 
-                    R_UNLESS(util::CanAddWithoutOverflow(total_size, out->nso_size[i]), ldr::ResultInvalidNso());
-                    total_size += out->nso_size[i];
+                out->nso_size[i] = aligned_up_size;
 
-                    if (!argument_allocated && argument != nullptr) {
-                        out->args_address = total_size;
-                        out->args_size    = util::AlignUp(2 * sizeof(u32) + argument->argument_size * 2 + ArgumentStore::ArgumentBufferSize, os::MemoryPageSize);
+                R_UNLESS(util::CanAddWithoutOverflow(total_size, out->nso_size[i]), ldr::ResultInvalidNso());
+                total_size += out->nso_size[i];
 
-                        R_UNLESS(util::CanAddWithoutOverflow(total_size, out->args_size), ldr::ResultInvalidNso());
-                        total_size += out->args_size;
+                if (!argument_allocated && argument != nullptr) {
+                    out->args_address = total_size;
+                    out->args_size    = util::AlignUp(2 * sizeof(u32) + argument->argument_size * 2 + ArgumentStore::ArgumentBufferSize, os::MemoryPageSize);
 
-                        argument_allocated = true;
-                    }
+                    R_UNLESS(util::CanAddWithoutOverflow(total_size, out->args_size), ldr::ResultInvalidNso());
+                    total_size += out->args_size;
+
+                    argument_allocated = true;
                 }
             }
 
@@ -609,11 +633,9 @@ namespace ams::ldr {
 
             /* Set out. */
             aslr_start += aslr_slide;
-            for (size_t i = 0; i < Nso_Count; i++) {
-                if (ali->has_nso[i]) {
-                    R_UNLESS(util::CanAddWithoutOverflow(out->nso_address[i], aslr_start), ldr::ResultInvalidNso());
-                    out->nso_address[i] += aslr_start;
-                }
+            for (int i = 0; i < ctx.nso_count; i++) {
+                R_UNLESS(util::CanAddWithoutOverflow(out->nso_address[i], aslr_start), ldr::ResultInvalidNso());
+                out->nso_address[i] += aslr_start;
             }
             if (out->args_address) {
                 R_UNLESS(util::CanAddWithoutOverflow(out->args_address, aslr_start), ldr::ResultInvalidNso());
@@ -622,69 +644,91 @@ namespace ams::ldr {
 
             out_param->code_address   = aslr_start;
             out_param->code_num_pages = total_size >> 12;
+            out->total_size = total_size;
 
             R_SUCCEED();
         }
 
-        Result LoadAutoLoadModuleSegment(fs::FileHandle file, const NsoHeader::SegmentInfo *segment, size_t file_size, const u8 *file_hash, bool is_compressed, bool check_hash, uintptr_t map_base, uintptr_t map_end) {
+        Result LoadAutoLoadModuleSegment(fs::FileHandle file, size_t file_offset, size_t compressed_size, size_t segment_size, bool is_compressed, bool is_zstd, uintptr_t map_base, uintptr_t map_end) {
             /* Select read size based on compression. */
-            if (!is_compressed) {
-                file_size = segment->size;
-            }
+            size_t file_size = is_compressed ? compressed_size : segment_size;
 
             /* Validate size. */
-            R_UNLESS(file_size <= segment->size,                       ldr::ResultInvalidNso());
-            R_UNLESS(segment->size <= std::numeric_limits<s32>::max(), ldr::ResultInvalidNso());
+            R_UNLESS(file_size <= segment_size,                       ldr::ResultInvalidNso());
+            R_UNLESS(file_size    <= std::numeric_limits<s32>::max(), ldr::ResultInvalidNso());
+            R_UNLESS(segment_size <= std::numeric_limits<s32>::max(), ldr::ResultInvalidNso());
 
             /* Load data from file. */
-            uintptr_t load_address = is_compressed ? map_end - file_size : map_base;
+            uintptr_t load_address = is_compressed ? map_end - compressed_size : map_base;
             size_t read_size;
-            R_TRY(fs::ReadFile(std::addressof(read_size), file, segment->file_offset, reinterpret_cast<void *>(load_address), file_size));
+            R_TRY(fs::ReadFile(std::addressof(read_size), file, file_offset, reinterpret_cast<void *>(load_address), file_size));
             R_UNLESS(read_size == file_size, ldr::ResultInvalidNso());
 
             /* Uncompress if necessary. */
-            if (is_compressed) {
-                bool decompressed = (util::DecompressLZ4(reinterpret_cast<void *>(map_base), segment->size, reinterpret_cast<const void *>(load_address), file_size) == static_cast<int>(segment->size));
+            R_SUCCEED_IF(!is_compressed);
+
+            auto compressed_data_buf = reinterpret_cast<const void *>(load_address);
+
+            if (is_zstd) {
+                bool decompressed = util::DecompressZstdForLoader(reinterpret_cast<void *>(g_zstd_dctx_workspace), ZstdDctxWorkspaceSize, reinterpret_cast<void *>(map_base), static_cast<size_t>(map_end - map_base), segment_size, compressed_data_buf, file_size);
+                R_UNLESS(decompressed, ldr::ResultInvalidNso());
+            } else {
+                bool decompressed = (util::DecompressLZ4(reinterpret_cast<void *>(map_base), segment_size, compressed_data_buf, file_size) == static_cast<int>(segment_size));
                 R_UNLESS(decompressed, ldr::ResultInvalidNso());
-            }
-
-            /* Check hash if necessary. */
-            if (check_hash) {
-                u8 hash[crypto::Sha256Generator::HashSize];
-                crypto::GenerateSha256(hash, sizeof(hash), reinterpret_cast<void *>(map_base), segment->size);
-
-                R_UNLESS(std::memcmp(hash, file_hash, sizeof(hash)) == 0, ldr::ResultInvalidNso());
             }
 
             R_SUCCEED();
         }
 
-        Result LoadAutoLoadModule(os::NativeHandle process_handle, fs::FileHandle file, const NsoHeader *nso_header, uintptr_t nso_address, size_t nso_size) {
+        Result CheckSegmentHash(const NsoHeader *nso_header, uintptr_t map_address, NsoHeader::Segment segment) {
+            if ((nso_header->flags & (NsoHeader::Flag_CheckHashText << segment)) == 0) {
+                R_SUCCEED();
+            }
+
+            u8 hash[crypto::Sha256Generator::HashSize];
+            crypto::GenerateSha256(hash, sizeof(hash),
+                reinterpret_cast<void *>(map_address + nso_header->segments[segment].dst_offset),
+                nso_header->segments[segment].size);
+            R_UNLESS(std::memcmp(hash, nso_header->segment_hashes[segment], sizeof(hash)) == 0, ldr::ResultInvalidNso());
+            R_SUCCEED();
+        }
+
+        Result LoadAutoLoadModule(os::NativeHandle process_handle, fs::FileHandle file, const NsoHeader *nso_header, uintptr_t nso_address, size_t nso_size, size_t map_size) {
+            const bool is_zstd = (nso_header->flags & NsoHeader::Flag_UseZbicCompression) != 0;
+
+            const size_t module_size = static_cast<size_t>(nso_header->rw_dst_offset) + util::AlignUp(nso_header->rw_size + nso_header->bss_size, os::MemoryPageSize);
+            const size_t arena_size  = (nso_size > module_size) ? (nso_size - module_size) : 0;
+
             /* Map and read data from file. */
             {
                 /* Map the process memory. */
                 void *mapped_memory = nullptr;
-                R_TRY(os::MapProcessMemory(std::addressof(mapped_memory), process_handle, nso_address, nso_size, GenerateSecureRandom));
-                ON_SCOPE_EXIT { os::UnmapProcessMemory(mapped_memory, process_handle, nso_address, nso_size); };
+                R_TRY(os::MapProcessMemory(std::addressof(mapped_memory), process_handle, nso_address, map_size, GenerateSecureRandom));
+                ON_SCOPE_EXIT { os::UnmapProcessMemory(mapped_memory, process_handle, nso_address, map_size); };
 
                 const uintptr_t map_address = reinterpret_cast<uintptr_t>(mapped_memory);
+                const uintptr_t map_end     = map_address + map_size;
 
                 /* Load NSO segments. */
-                R_TRY(LoadAutoLoadModuleSegment(file, std::addressof(nso_header->segments[NsoHeader::Segment_Text]), nso_header->text_compressed_size, nso_header->text_hash, (nso_header->flags & NsoHeader::Flag_CompressedText) != 0,
-                                                      (nso_header->flags & NsoHeader::Flag_CheckHashText) != 0, map_address + nso_header->text_dst_offset, map_address + nso_size));
-                R_TRY(LoadAutoLoadModuleSegment(file, std::addressof(nso_header->segments[NsoHeader::Segment_Ro]), nso_header->ro_compressed_size, nso_header->ro_hash, (nso_header->flags & NsoHeader::Flag_CompressedRo) != 0,
-                                                      (nso_header->flags & NsoHeader::Flag_CheckHashRo) != 0, map_address + nso_header->ro_dst_offset, map_address + nso_size));
-                R_TRY(LoadAutoLoadModuleSegment(file, std::addressof(nso_header->segments[NsoHeader::Segment_Rw]), nso_header->rw_compressed_size, nso_header->rw_hash, (nso_header->flags & NsoHeader::Flag_CompressedRw) != 0,
-                                                      (nso_header->flags & NsoHeader::Flag_CheckHashRw) != 0, map_address + nso_header->rw_dst_offset, map_address + nso_size));
+                R_TRY(LoadAutoLoadModuleSegment(file, nso_header->segments[NsoHeader::Segment_Text].file_offset, nso_header->text_compressed_size, nso_header->text_size,
+                                                      (nso_header->flags & NsoHeader::Flag_CompressedText) != 0, is_zstd, map_address + nso_header->text_dst_offset, map_end));
+                R_TRY(LoadAutoLoadModuleSegment(file, nso_header->segments[NsoHeader::Segment_Ro].file_offset, nso_header->ro_compressed_size, nso_header->ro_size,
+                                                      (nso_header->flags & NsoHeader::Flag_CompressedRo) != 0, is_zstd, map_address + nso_header->ro_dst_offset, map_end));
+                R_TRY(LoadAutoLoadModuleSegment(file, nso_header->segments[NsoHeader::Segment_Rw].file_offset, nso_header->rw_compressed_size, nso_header->rw_size,
+                                                      (nso_header->flags & NsoHeader::Flag_CompressedRw) != 0, is_zstd, map_address + nso_header->rw_dst_offset, map_end));
 
                 /* Clear unused space to zero. */
                 const size_t text_end = static_cast<size_t>(nso_header->text_dst_offset) + static_cast<size_t>(nso_header->text_size);
                 const size_t ro_end   = static_cast<size_t>(nso_header->ro_dst_offset)   + static_cast<size_t>(nso_header->ro_size);
                 const size_t rw_end   = static_cast<size_t>(nso_header->rw_dst_offset)   + static_cast<size_t>(nso_header->rw_size);
-                std::memset(reinterpret_cast<void *>(map_address + 0),        0, nso_header->text_dst_offset);
                 std::memset(reinterpret_cast<void *>(map_address + text_end), 0, nso_header->ro_dst_offset - text_end);
                 std::memset(reinterpret_cast<void *>(map_address + ro_end),   0, nso_header->rw_dst_offset - ro_end);
-                std::memset(reinterpret_cast<void *>(map_address + rw_end),   0, nso_header->bss_size);
+                std::memset(reinterpret_cast<void *>(map_address + rw_end),   0, nso_size - rw_end);
+
+                /* Check segment hashes. */
+                R_TRY(CheckSegmentHash(nso_header, map_address, NsoHeader::Segment_Text));
+                R_TRY(CheckSegmentHash(nso_header, map_address, NsoHeader::Segment_Ro));
+                R_TRY(CheckSegmentHash(nso_header, map_address, NsoHeader::Segment_Rw));
 
                 /* Apply embedded patches. */
                 ApplyEmbeddedPatchesToModule(nso_header->module_id, map_address, nso_size);
@@ -694,7 +738,15 @@ namespace ams::ldr {
 
                 /* Apply PCV and PTM patches */
                 if (g_is_pcv) {
-                    hoc::pcv::Patch(map_address, nso_size);
+                    const size_t text_end  = static_cast<size_t>(nso_header->text_size);
+                    const size_t rx_end    = util::AlignUp(text_end, os::MemoryPageSize);
+                    const size_t ro_start  = static_cast<size_t>(nso_header->ro_dst_offset);
+                    const size_t cave_end  = (rx_end < ro_start) ? rx_end : ro_start;
+                    const uintptr_t cave   = map_address + text_end;
+                    const size_t cave_size = (cave_end > text_end) ? (cave_end - text_end) : 0;
+
+                    /* module_size is used rather than nso_size to exclude the extra data section. */
+                    hoc::pcv::Patch(map_address, module_size, cave, cave_size, nso_address, arena_size ? (map_address + module_size) : 0);
                 }
 
                 if (g_is_ptm) {
@@ -705,31 +757,36 @@ namespace ams::ldr {
             /* Set permissions. */
             const size_t text_size = util::AlignUp(nso_header->text_size, os::MemoryPageSize);
             const size_t ro_size   = util::AlignUp(nso_header->ro_size, os::MemoryPageSize);
-            const size_t rw_size   = util::AlignUp(nso_header->rw_size + nso_header->bss_size, os::MemoryPageSize);
+            const size_t rw_size   = util::AlignUp(nso_header->rw_size + nso_header->bss_size, os::MemoryPageSize) + arena_size;
             if (text_size) {
                 const bool prevent_code_reads = (nso_header->flags & NsoHeader::Flag_PreventCodeReads);
                 R_TRY(os::SetProcessMemoryPermission(process_handle, nso_address + nso_header->text_dst_offset, text_size, prevent_code_reads ? os::MemoryPermission_ExecuteOnly : os::MemoryPermission_ReadExecute));
             }
             if (ro_size) {
-                R_TRY(os::SetProcessMemoryPermission(process_handle, nso_address + nso_header->ro_dst_offset,   ro_size,   os::MemoryPermission_ReadOnly));
+                R_TRY(os::SetProcessMemoryPermission(process_handle, nso_address + nso_header->ro_dst_offset, ro_size, os::MemoryPermission_ReadOnly));
             }
             if (rw_size) {
-                R_TRY(os::SetProcessMemoryPermission(process_handle, nso_address + nso_header->rw_dst_offset,   rw_size,   os::MemoryPermission_ReadWrite));
+                R_TRY(os::SetProcessMemoryPermission(process_handle, nso_address + nso_header->rw_dst_offset, rw_size, os::MemoryPermission_ReadWrite));
             }
 
             R_SUCCEED();
         }
 
-        Result LoadAutoLoadModules(const ProcessInfo *process_info, const NsoHeader *nso_headers, const AutoLoadModuleInfo *ali, const ArgumentStore::Entry *argument) {
+        Result LoadAutoLoadModules(const ProcessInfo *process_info, const AutoLoadModuleContext &ctx, const ArgumentStore::Entry *argument) {
             /* Load each NSO. */
-            for (size_t i = 0; i < Nso_Count; i++) {
-                if (ali->has_nso[i]) {
-                    fs::FileHandle file;
-                    R_TRY(fs::OpenFile(std::addressof(file), GetNsoPath(i), fs::OpenMode_Read));
-                    ON_SCOPE_EXIT { fs::CloseFile(file); };
+            const uintptr_t total_end = process_info->code_address + process_info->total_size;
 
-                    R_TRY(LoadAutoLoadModule(process_info->process_handle, file, nso_headers + i, process_info->nso_address[i], process_info->nso_size[i]));
-                }
+            for (int i = 0; i < ctx.nso_count; i++) {
+                const NsoIndex nso_idx = static_cast<NsoIndex>(ctx.ali.nso_indices[i]);
+
+                fs::FileHandle file;
+                R_TRY(fs::OpenFile(std::addressof(file), GetNsoPath(nso_idx), fs::OpenMode_Read));
+                ON_SCOPE_EXIT { fs::CloseFile(file); };
+
+                const bool is_zstd    = (ctx.headers[i].flags & NsoHeader::Flag_UseZbicCompression) != 0;
+                const size_t map_size = is_zstd ? (total_end - process_info->nso_address[i]) : process_info->nso_size[i];
+
+                R_TRY(LoadAutoLoadModule(process_info->process_handle, file, ctx.headers + i, process_info->nso_address[i], process_info->nso_size[i], map_size));
             }
 
             /* Load arguments, if present. */
@@ -755,13 +812,19 @@ namespace ams::ldr {
             R_SUCCEED();
         }
 
-        Result CreateProcessAndLoadAutoLoadModules(ProcessInfo *out, const Meta *meta, const NsoHeader *nso_headers, const AutoLoadModuleInfo *ali, const ArgumentStore::Entry *argument, u32 flags, os::NativeHandle resource_limit) {
+        Result CreateProcessAndLoadAutoLoadModules(ProcessInfo *out, const Meta *meta, const AutoLoadModuleContext &ctx, const ArgumentStore::Entry *argument, u32 flags, os::NativeHandle resource_limit) {
+            /* Append extra .bss for 64LUT */
+            /* TODO: REMOVE THIS. */
+            if (g_is_pcv && ctx.main_nso_idx >= 0) {
+                g_nso_headers[ctx.main_nso_idx].bss_size += static_cast<u32>(hoc::pcv::HocPcvScratchSize);
+            }
+
             /* Get CreateProcessParameter. */
             svc::CreateProcessParameter param;
             R_TRY(GetCreateProcessParameter(std::addressof(param), meta, flags, resource_limit));
 
             /* Decide on an NSO layout. */
-            R_TRY(DecideAddressSpaceLayout(out, std::addressof(param), nso_headers, ali, argument));
+            R_TRY(DecideAddressSpaceLayout(out, std::addressof(param), ctx, argument));
 
             /* Actually create process. */
             svc::Handle process_handle;
@@ -769,10 +832,11 @@ namespace ams::ldr {
 
             /* Set the output handle, and ensure that if we fail after this point we clean it up. */
             out->process_handle = process_handle;
+            out->code_address   = param.code_address;
             ON_RESULT_FAILURE { svc::CloseHandle(process_handle); };
 
             /* Load all auto load modules. */
-            R_RETURN(LoadAutoLoadModules(out, nso_headers, ali, argument));
+            R_RETURN(LoadAutoLoadModules(out, ctx, argument));
         }
 
     }
@@ -813,13 +877,13 @@ namespace ams::ldr {
         }
 
         /* Load, validate NSO headers. */
-        AutoLoadModuleInfo auto_load_info = {};
-        R_TRY(LoadAutoLoadHeaders(g_nso_headers, std::addressof(auto_load_info), meta.acid->flags));
-        R_TRY(CheckAutoLoad(g_nso_headers, std::addressof(auto_load_info), meta.acid->flags));
+        AutoLoadModuleContext ctx;
+        R_TRY(LoadAutoLoadHeaders(ctx, meta.acid->flags));
+        R_TRY(CheckAutoLoad(ctx, meta.acid->flags));
 
         /* Actually create the process and load NSOs into process memory. */
         ProcessInfo info;
-        R_TRY(CreateProcessAndLoadAutoLoadModules(std::addressof(info), std::addressof(meta), g_nso_headers, std::addressof(auto_load_info), argument, flags, resource_limit));
+        R_TRY(CreateProcessAndLoadAutoLoadModules(std::addressof(info), std::addressof(meta), ctx, argument, flags, resource_limit));
 
         /* Register NSOs with the RoManager. */
         {
@@ -831,10 +895,8 @@ namespace ams::ldr {
             RoManager::GetInstance().RegisterProcess(pin_id, process_id, meta.aci->program_id, as_type == Npdm::AddressSpaceType_64Bit || as_type == Npdm::AddressSpaceType_64BitDeprecated);
 
             /* Register all NSOs. */
-            for (size_t i = 0; i < Nso_Count; i++) {
-                if (auto_load_info.has_nso[i]) {
-                    RoManager::GetInstance().AddNso(pin_id, g_nso_headers[i].module_id, info.nso_address[i], info.nso_size[i]);
-                }
+            for (int i = 0; i < ctx.nso_count; i++) {
+                RoManager::GetInstance().AddNso(pin_id, ctx.headers[i].module_id, info.nso_address[i], info.nso_size[i]);
             }
         }
 

Source/Atmosphere/stratosphere/loader/source/oc/Makefile

@@ -1,51 +0,0 @@
-TARGET_EXEC := test
-
-BUILD_DIR := ./build
-SRC_DIRS := ./
-
-# CXX := clang++ g++-12
-
-# Find all the C and C++ files we want to compile
-# Note the single quotes around the * expressions. Make will incorrectly expand these otherwise.
-SRCS := $(shell find $(SRC_DIRS) -name '*.cpp' -or -name '*.c' -or -name '*.s')
-
-# String substitution for every C/C++ file.
-# As an example, hello.cpp turns into ./build/hello.cpp.o
-OBJS := $(SRCS:%=$(BUILD_DIR)/%.o)
-
-# String substitution (suffix version without %).
-# As an example, ./build/hello.cpp.o turns into ./build/hello.cpp.d
-DEPS := $(OBJS:.o=.d)
-
-# Every folder in ./src will need to be passed to GCC so that it can find header files
-INC_DIRS := $(shell find $(SRC_DIRS) -type d)
-# Add a prefix to INC_DIRS. So moduleA would become -ImoduleA. GCC understands this -I flag
-INC_FLAGS := $(addprefix -I,$(INC_DIRS))
-
-CPPFLAGS := $(INC_FLAGS) -Wall -Werror -Wno-unused-result -std=c++20 -Og -g
-
-# The final build step.
-$(TARGET_EXEC): $(OBJS)
-	@echo "Linking $@"
-	@$(CXX) $(OBJS) -o $@ $(LDFLAGS)
-
-# Build step for C source
-$(BUILD_DIR)/%.c.o: %.c
-	@mkdir -p $(dir $@)
-	@echo "$<"
-	@$(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@
-
-# Build step for C++ source
-$(BUILD_DIR)/%.cpp.o: %.cpp
-	@mkdir -p $(dir $@)
-	@echo "$<"
-	@$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $< -o $@
-
-.PHONY: clean
-clean:
-	@rm -r $(BUILD_DIR) $(TARGET_EXEC)
-
-# Include the .d makefiles. The - at the front suppresses the errors of missing
-# Makefiles. Initially, all the .d files will be missing, and we don't want those
-# errors to show up.
--include $(DEPS)

Source/Atmosphere/stratosphere/loader/source/oc/customize.cpp

@@ -31,95 +31,101 @@
 namespace ams::ldr::hoc {
 
 volatile CustomizeTable C = {
+
 /* Disables RAM powerdown */
 .hpMode = DISABLED,
 
-.commonEmcMemVolt  = 1175000, /* LPDDR4X JEDEC Specification */
+.commonEmcMemVolt  = 1175000, /* LPDDR4(X) JEDEC Specification */
 .eristaEmcMaxClock = 1600000, /* Maximum HB-MGCH ram rating */
-.eristaEmcMaxClock1 = 1600000,
-.eristaEmcMaxClock2 = 1600000,
 
-.marikoEmcMaxClock = 1866000, /* 1866MHz @ 1866tWRL is guaranteed to work on all Mariko units */
-.marikoEmcVddqVolt = 600000, /* Micron: 600mV, other manafacturers: 640mV */
-.emcDvbShift = 0,
+/* Available: 33MHz step rate, 66MHz step rate, 100MHz step rate, 133MHz step rate and jedec. */
+/* Jedec freqs are 1333MHz, 1600MHz, 1866MHz, 2133MHz, 2400MHz, 2666MHz, 2933MHz, 3200MHz. */
+.stepMode = StepMode_33MHz,
 
-// Primary
-.t1_tRCD = 0,
-.t2_tRP  = 0,
-.t3_tRAS = 0,
-// Secondary
-.t4_tRRD  = 0,
-.t5_tRFC  = 0,
-.t6_tRTW  = 0,
-.t7_tWTR  = 0,
-.t8_tREFI = 0,
+.marikoEmcMaxClock = 2133000, /* Requires the EMC DVFS 63-entry patches (EMC DVFS Count / EMC SoC LUT). */
+.marikoEmcVddqVolt = 600000,
 
-/* You can mix and match different latencies if needed */
-/*
- *  Read:
- *   2133RL = 40
- *   1866RL = 36
- *   1600RL = 32
- *   1331RL = 28
- *  Write:
- *   2133WL = 18
- *   1866WL = 16
- *   1600WL = 14
- *   1331WL = 12
- */
+.emcDvbShift   = 0,
+.marikoSocVmax = 0, /* 0 = stock limits (1450 - 1597 is 1050mV, 1598-1708 is 1025mV, 1709+ is 1000mV). */
 
-.mem_burst_read_latency = RL_1866,
-.mem_burst_write_latency = WL_1866,
+/* Primary. */
+.t1_tRCD      = 0,
+.t2_tRP       = 0,
+.t3_tRAS      = 0,
+/* Secondary. */
+.t4_tRRD      = 0,
+.t5_tRFC      = 0,
+.t6_tRTW      = 0,
+.t7_tWTR      = 0,
+.t8_tREFI     = 0,
 
-.eristaCpuUV = 0,
-.eristaCpuVmin = 800,
+/* Frequency where non low timings gets used. */
+.timingEmcTbreak = DISABLED,
+.low_t1_tRCD  = 0,
+.low_t2_tRP   = 0,
+.low_t3_tRAS  = 0,
+.low_t4_tRRD  = 0,
+.low_t5_tRFC  = 0,
+.low_t6_tRTW  = 0,
+.low_t7_tWTR  = 0,
+.low_t8_tREFI = 0,
+
+.readLatency = {
+    /* 1333 */ 0,
+    /* 1600 */ 0,
+    /* 1866 */ 0,
+    /* 2133 */ 0,
+},
+
+.writeLatency = {
+    /* 1333 */ 0,
+    /* 1600 */ 0,
+    /* 1866 */ 0,
+    /* 2133 */ 0,
+},
+
+.eristaCpuUV      = 0,
+.eristaCpuVmin    = 825,
 .eristaCpuMaxVolt = 1200,
-/* Unlocks up to 2295 Mhz CPU, usage is not recommended. */
-.eristaCpuUnlock = DISABLED,
+/* Unlocks up to 2397 Mhz CPU, usage is not recommended. */
+.eristaCpuUnlock  = DISABLED,
 
-.marikoCpuUVLow = 0, // No undervolt
+.marikoCpuUVLow  = 0, // No undervolt
 .marikoCpuUVHigh = 0, // No undervolt
 
-.tableConf = TBREAK_1683,
-.marikoCpuLowVmin = 620,
+.tableConf         = TBREAK_1683,
+.marikoCpuLowVmin  = 620,
 .marikoCpuHighVmin = 750,
-/* 1120mV is NVIDIA rating */
-.marikoCpuMaxVolt = 1120,
 
-/* Supported values: 1963000, 2091000, 2193000, 2295000, 2397000, 2499000, 2601000, 2703000. */
-/* 1963000 is official rating of T214/Mariko, fully safe. */
+/* 1120mV is NVIDIA rating */
+.marikoCpuMaxVolt  = 1120,
+
+/* Supported values: 1963500, 2091000, 2193000, 2295000, 2397000, 2499000, 2601000, 2703000. */
+/* 1963500 is official rating of T214/Mariko, fully safe. */
 /* 2091000-2295000 is a slight OC which should work on all units, but no guarantees. */
 /* 2397000 is the max safe OC for most average units with tuned undervolt. */
 /* 2499000 should be used with caution. */
 /* 2601000 exceeds pmic limit on most consoles. */
 /* 2703000 is potentially dangerous and not advised. */
-.marikoCpuMaxClock = 1963000,
+.marikoCpuMaxClock = 1963500,
 
-.eristaCpuBoostClock = 1785000, // Default boost clock
-.marikoCpuBoostClock = 1963000, // Default boost clock
+.eristaCpuBoostClock = 1785000, /* Default boost clock */
+.marikoCpuBoostClock = 1963500, /* Default boost clock */
 
-.eristaGpuUV = 2,
+.eristaGpuUV   = 0,
 .eristaGpuVmin = 810,
 
-.marikoGpuUV = 0,
-
-/* For automatic vmin detection, set this to AUTO. */
-/* vmin past 795mV won't work due to HOS limitation */
-/* Vmin is automatically set to 800mV when SoC temperature is below 20C */
-.marikoGpuVmin = AUTO,
-
+.marikoGpuUV = 2,
+/* Vmin past 795mV won't work due boot voltage being 800mV. */
+.marikoGpuVmin = 610,
 .marikoGpuVmax = 800,
 
 .commonGpuVoltOffset = 0,
 
-/* Speedo is automatically set by hoc-clk on first boot */
-.gpuSpeedo = 1450,
-
 /* Setting DEACTIVATED_GPU_FREQ on any freq will disable it and all freqs greater than it. (the latter is a bug :/) */
 /* AUTO: Voltage is optimally chosen; with commonGpuVoltOffset applied. */
 /* AUTO only works up to 1305 GPU on Mariko and 998 GPU on Erista (it is reccomended to manually set your 998MHz voltage though) */
 /* You can overwrite auto with any voltage (in mv) of your choice - offset will not be applied. */
-
 .eristaGpuVoltArray = {
                         AUTO /*   76                       */,
                         AUTO /*  115                       */,
@@ -151,30 +157,62 @@ volatile CustomizeTable C = {
 },
 
 .marikoGpuVoltArray = {
-                    AUTO  /*   76                       */,
-                    AUTO  /*  153                       */,
-                    AUTO  /*  230                       */,
-                    AUTO  /*  307                       */,
-                    AUTO  /*  384                       */,
-                    AUTO  /*  460                       */,
-                    AUTO  /*  537                       */,
-                    AUTO  /*  614                       */,
-                    AUTO  /*  691                       */,
-                    AUTO  /*  768                       */,
-                    AUTO  /*  844                       */,
-                    AUTO  /*  921                       */,
-                    AUTO  /*  998                       */,
-                    AUTO  /* 1075                       */,
-                    AUTO  /* 1152 (SLT / HiOPT Only!)   */,
-                    AUTO  /* 1228 (HiOPT Only!)         */,
-    DEACTIVATED_GPU_FREQ  /* 1267 (Disabled by default) */,
-    DEACTIVATED_GPU_FREQ  /* 1305 (Disabled by default) */,
-    DEACTIVATED_GPU_FREQ  /* 1344 (Disabled by default) */,
-    DEACTIVATED_GPU_FREQ  /* 1382 (Disabled by default) */,
-    DEACTIVATED_GPU_FREQ  /* 1420 (Disabled by default) */,
-    DEACTIVATED_GPU_FREQ  /* 1459 (Disabled by default) */,
-    DEACTIVATED_GPU_FREQ  /* 1497 (Disabled by default) */,
-    DEACTIVATED_GPU_FREQ  /* 1536 (Disabled by default) */,
+                    AUTO  /*   76                         */,
+                    AUTO  /*  153                         */,
+                    AUTO  /*  230                         */,
+                    AUTO  /*  307                         */,
+                    AUTO  /*  384                         */,
+                    AUTO  /*  460                         */,
+                    AUTO  /*  537                         */,
+                    AUTO  /*  614                         */,
+                    AUTO  /*  691                         */,
+                    AUTO  /*  768                         */,
+                    AUTO  /*  844                         */,
+                    AUTO  /*  921                         */,
+                    AUTO  /*  998                         */,
+                    AUTO  /* 1075                         */,
+                    AUTO  /* 1152 (HioPT / High UV only!) */,
+                    AUTO  /* 1228 (High UV Only!)         */,
+                    AUTO  /* 1267 (High UV Only!)         */,
+                    AUTO  /* 1305 (High UV Only!)         */,
+    DEACTIVATED_GPU_FREQ  /* 1344 (Disabled by default)   */,
+    DEACTIVATED_GPU_FREQ  /* 1382 (Disabled by default)   */,
+    DEACTIVATED_GPU_FREQ  /* 1420 (Disabled by default)   */,
+    DEACTIVATED_GPU_FREQ  /* 1459 (Disabled by default)   */,
+    DEACTIVATED_GPU_FREQ  /* 1497 (Disabled by default)   */,
+    DEACTIVATED_GPU_FREQ  /* 1536 (Disabled by default)   */,
+},
+
+/* Override soc voltage brackets. */
+.marikoSocVoltArray = {
+    0 /* >= 1866 */,
+    0 /* >= 2000 */,
+    0 /* >= 2133 */,
+    0 /* >= 2200 */,
+    0 /* >= 2266 */,
+    0 /* >= 2333 */,
+    0 /* >= 2400 */,
+    0 /* >= 2433 */,
+    0 /* >= 2466 */,
+    0 /* >= 2533 */,
+    0 /* >= 2566 */,
+    0 /* >= 2600 */,
+    0 /* >= 2666 */,
+    0 /* >= 2700 */,
+    0 /* >= 2733 */,
+    0 /* >= 2766 */,
+    0 /* >= 2800 */,
+    0 /* >= 2833 */,
+    0 /* >= 2900 */,
+    0 /* >= 2933 */,
+    0 /* >= 3000 */,
+    0 /* >= 3033 */,
+    0 /* >= 3100 */,
+    0 /* >= 3133 */,
+    0 /* >= 3166 */,
+    0 /* >= 3200 */,
+    0 /* >= 3266 */,
+    0 /* >= 3333 */,
 },
 
 /* Advanced. */
@@ -199,9 +237,9 @@ volatile CustomizeTable C = {
     { 1581000, { 1130000, }, {  2889664, -122173,  1834, } },
     { 1683000, { 1168000, }, {  5100873, -279186,  4747, } },
     { 1785000, { 1225000, }, {  5100873, -279186,  4747, } },
-   // { 1887000, { 1225000, }, {  5100873, -279186,  4747, } },
-   // { 1989000, { 1227500, }, {  5100873, -279186,  4747, } },
-   // { 2091000, { 1256250, }, {  5100873, -279186,  4747, } },
+    { 1887000, { 1225000, }, {  5100873, -279186,  4747, } },
+    { 1989000, { 1227500, }, {  5100873, -279186,  4747, } },
+    { 2091000, { 1256250, }, {  5100873, -279186,  4747, } },
 },
 
 .eristaCpuDvfsTableSLT = {
@@ -222,7 +260,7 @@ volatile CustomizeTable C = {
     { 1683000, { 1168000, }, {  5100873, -279186,  4747, } },
     { 1785000, { 1225000, }, {  5100873, -279186,  4747, } },
     { 1887000, { 1225000, }, {  5100873, -279186,  4747, } },
-    { 1963500, { 1227500, }, {  5100873, -279186,  4747, } },
+    { 1989000, { 1227500, }, {  5100873, -279186,  4747, } },
     { 2091000, { 1227500, }, {  5100873, -279186,  4747, } },
     { 2193000, { 1227500, }, {  5100873, -279186,  4747, } },
     { 2295000, { 1256250, }, {  5100873, -279186,  4747, } },
@@ -394,30 +432,33 @@ volatile CustomizeTable C = {
 },
 
 .eristaGpuDvfsTableSLT = {
-    {  76800, { }, {  814294, 8144, -940, 0, 0, 226, } },
-    { 115200, { }, {  856185, 8144, -940, 0, 0, 226, } },
-    { 153600, { }, {  856185, 8144, -940, 0, 0, 226, } },
-    { 192000, { }, {  908077, 8144, -940, 0, 0, 226, } },
-    { 230400, { }, {  908077, 8144, -940, 0, 0, 226, } },
-    { 268800, { }, {  934968, 8144, -940, 0, 0, 226, } },
-    { 307200, { }, {  934968, 8144, -940, 0, 0, 226, } },
-    { 345600, { }, {  952860, 8144, -940, 0, 0, 226, } },
-    { 384000, { }, {  952860, 8144, -940, 0, 0, 226, } },
-    { 422400, { }, {  978751, 8144, -940, 0, 0, 226, } },
-    { 460800, { }, {  978751, 8144, -940, 0, 0, 226, } },
-    { 499200, { }, {  990642, 8144, -940, 0, 0, 226, } },
-    { 537600, { }, {  990642, 8144, -940, 0, 0, 226, } },
-    { 576000, { }, { 1017534, 8144, -940, 0, 0, 226, } },
-    { 614400, { }, { 1017534, 8144, -940, 0, 0, 226, } },
-    { 652800, { }, { 1042425, 8144, -940, 0, 0, 226, } },
-    { 691200, { }, { 1042425, 8144, -940, 0, 0, 226, } },
-    { 729600, { }, { 1066317, 8144, -940, 0, 0, 226, } },
-    { 768000, { }, { 1066317, 8144, -940, 0, 0, 226, } },
-    { 806400, { }, { 1093208, 8144, -940, 0, 0, 226, } },
-    { 844800, { }, { 1093208, 8144, -940, 0, 0, 226, } },
-    { 883200, { }, { 1118100, 8144, -940, 0, 0, 226, } },
-    { 921600, { }, { 1118100, 8144, -940, 0, 0, 226, } },
-    { 960000, { }, { 1156991, 8144, -940, 0, 0, 226, } },
+    {   76800, { }, { 700000, } },
+    {  153600, { }, { 700000, } },
+    {  192000, { }, { 705000, } },
+    {  230400, { }, { 710000, } },
+    {  268800, { }, { 720000, } },
+    {  307200, { }, { 730000, } },
+    {  345600, { }, { 740000, } },
+    {  384000, { }, { 750000, } },
+    {  422400, { }, { 760000, } },
+    {  460800, { }, { 770000, } },
+    {  499200, { }, { 780000, } },
+    {  537600, { }, { 790000, } },
+    {  576000, { }, { 800000, } },
+    {  614400, { }, { 810000, } },
+    {  652800, { }, { 820000, } },
+    {  691200, { }, { 830000, } },
+    {  729600, { }, { 850000, } },
+    {  768000, { }, { 860000, } },
+    {  806400, { }, { 875000, } },
+    {  844800, { }, { 885000, } },
+    {  883200, { }, { 900000, } },
+    {  921600, { }, { 910000, } },
+    {  960000, { }, { 930000, } },
+    // {  998400, { }, { 945000, } },
+    // { 1036800, { }, {          } },
+    // { 1152000, { }, {          } },
+    // { 1075200, { }, {          } },
 },
 
 .eristaGpuDvfsTableHiOPT = {
@@ -452,6 +493,47 @@ volatile CustomizeTable C = {
 },
 
 .marikoGpuDvfsTable = {
+    {   76800, {}, {  610000,                                 } },
+    {  153600, {}, {  610000,                                 } },
+    {  230400, {}, {  610000,                                 } },
+    {  307200, {}, {  610000,                                 } },
+    {  384000, {}, {  610000,                                 } },
+    {  460800, {}, {  610000,                                 } },
+    {  537600, {}, {  801688, -10900, -163,  298, -10599, 162 } },
+    {  614400, {}, {  824214,  -5743, -452,  238,  -6325,  81 } },
+    {  691200, {}, {  848830,  -3903, -552,  119,  -4030,  -2 } },
+    {  768000, {}, {  891575,  -4409, -584,    0,  -2849,  39 } },
+    {  844800, {}, {  940071,  -5367, -602,  -60,    -63, -93 } },
+    {  921600, {}, {  986765,  -6637, -614, -179,   1905, -13 } },
+    {  998400, {}, { 1098475, -13529, -497, -179,   3626,   9 } },
+    // { 1075200, {}, { 1163644, -12688, -648,    0,   1077,  40 } },
+    // { 1152000, {}, { 1204812,  -9908, -830,    0,   1469, 110 } },
+    // { 1228800, {}, { 1277303, -11675, -859,    0,   3722, 313 } },
+    // { 1267200, {}, { 1335531, -12567, -867,    0,   3681, 559 } },
+    // { 1305600, {}, { 1374130, -13725, -859,    0,   4442, 576 } },
+},
+
+.marikoGpuDvfsTableSLT = {
+    {   76800, {}, {  590000,                                         } },
+	{  153600, {}, {  590000,                                         } },
+	{  230400, {}, {  590000,                                         } },
+	{  307200, {}, {  590000,                                         } },
+	{  384000, {}, {  590000,                                         } },
+	{  460800, {}, {  795089, -11096,   -163,    298,  -10421,    162 } },
+	{  537600, {}, {  795089, -11096,   -163,    298,  -10421,    162 } },
+	{  614400, {}, {  820606,  -6285,   -452,    238,   -6182,     81 } },
+	{  691200, {}, {  846289,  -4565,   -552,    119,   -3958,     -2 } },
+	{  768000, {}, {  888720,  -5110,   -584,      0,   -2849,     39 } },
+	{  844800, {}, {  936634,  -6089,   -602,    -60,     -99,    -93 } },
+	{  921600, {}, {  982562,  -7373,   -614,   -179,    1797,    -13 } },
+	{  998400, {}, { 1090179, -14125,   -497,   -179,    3518,      9 } },
+	{ 1075200, {}, { 1155798, -13465,   -648,      0,    1077,     40 } },
+	// { 1152000, {}, { 1198568, -10904,   -830,      0,    1469,    110 } },
+	// { 1228800, {}, { 1269988, -12707,   -859,      0,    3722,    313 } },
+	// { 1267200, {}, { 1308155, -13694,   -867,      0,    3681,    559 } },
+},
+
+.marikoGpuDvfsTableHiOPT = {
     {   76800, { }, {  GPU_MIN_MIN_VOLT,                    } },
     {  153600, { }, {  GPU_MIN_MIN_VOLT,                    } },
     {  230400, { }, {  GPU_MIN_MIN_VOLT,                    } },
@@ -466,12 +548,12 @@ volatile CustomizeTable C = {
     {  921600, { }, {  970060,-10108, -614,-179,  1508, -13 } },
     {  998400, { }, { 1065665,-16075, -497,-179,  3213,   9 } },
     { 1075200, { }, { 1132576,-16093, -648,   0,  1077,  40 } },
-//  { 1152000, { }, { 1180029,-14534, -830,   0,  1469, 110 } },
+    { 1152000, { }, { 1180029,-14534, -830,   0,  1469, 110 } },
 //  { 1228800, { }, { 1248293,-16383, -859,   0,  3722, 313 } },
 //  { 1267200, { }, { 1286399,-17475, -867,   0,  3681, 559 } },
 },
 
-.marikoGpuDvfsTableSLT = {
+.marikoGpuDvfsTableHiOPT15 = {
     {   76800, { }, {  GPU_MIN_MIN_VOLT,                      } },
     {  153600, { }, {  GPU_MIN_MIN_VOLT,                      } },
     {  230400, { }, {  GPU_MIN_MIN_VOLT,                      } },
@@ -488,10 +570,17 @@ volatile CustomizeTable C = {
     { 1075200, { }, { 1132576, -16093, -648,    0,  1077,  40 } },
     { 1152000, { }, { 1180029, -14534, -830,    0,  1469, 110 } },
     { 1228800, { }, { 1238293, -16383, -859,    0,  3722, 313 } },
-//  { 1267200, { }, { 1276399, -17475, -867,    0,  3681, 559 } },
+    { 1267200, { }, { 1276399, -17475, -867,    0,  3681, 559 } },
+    { 1305600, { }, {                                         } },
+    { 1344000, { }, {                                         } },
+    { 1382400, { }, {                                         } },
+    { 1420800, { }, {                                         } },
+    { 1459200, { }, {                                         } },
+    { 1497600, { }, {                                         } },
+    { 1536000, { }, {                                         } },
 },
 
-.marikoGpuDvfsTableHiOPT = {
+.marikoGpuDvfsTableHighUV = {
     {   76800, { }, {  GPU_MIN_MIN_VOLT,                      } },
     {  153600, { }, {  GPU_MIN_MIN_VOLT,                      } },
     {  230400, { }, {  GPU_MIN_MIN_VOLT,                      } },

Source/Atmosphere/stratosphere/loader/source/oc/customize.hpp

@@ -20,34 +20,28 @@
 
 #pragma once
 
-#define CUST_REV 1
+#define CUST_REV 7
+#define KIP_VERSION 300
 
 #include "oc_common.hpp"
 #include "pcv/pcv_common.hpp"
 
 namespace ams::ldr::hoc {
 
-#include "mtc_timing_table.hpp"
-
 enum TableConfig: u32 {
     DEFAULT_TABLE = 1,
-    TBREAK_1581 = 2,
-    TBREAK_1683 = 3,
+    TBREAK_1581   = 2,
+    TBREAK_1683   = 3,
     EXTREME_TABLE = 4,
 };
 
-/*
- *  Read:
- *   2133RL = 40
- *   1866RL = 36
- *   1600RL = 32
- *   1331RL = 28
- *  Write:
- *   2133WL = 18
- *   1866WL = 16
- *   1600WL = 14
- *   1331WL = 12
- */
+enum StepMode: u32 {
+    StepMode_66MHz  = 0,
+    StepMode_100MHz = 1,
+    StepMode_Jedec  = 2,
+    StepMode_133MHz = 3,
+    StepMode_33MHz  = 4,
+};
 
 enum ReadLatency: u32 {
     RL_2133 = 40,
@@ -68,23 +62,21 @@ using CustomizeGpuDvfsTable = pcv::cvb_entry_t[pcv::DvfsTableEntryLimit];
 static_assert(sizeof(CustomizeCpuDvfsTable) == sizeof(CustomizeGpuDvfsTable));
 static_assert(sizeof(CustomizeCpuDvfsTable) == sizeof(pcv::cvb_entry_t) * pcv::DvfsTableEntryLimit);
 
-constexpr uint32_t ERISTA_MTC_MAGIC = 0x43544D45; // EMTC
-constexpr uint32_t MARIKO_MTC_MAGIC = 0x43544D4D; // MMTC
+struct CustomizeTable {
+    u8  cust[4]    = {'C', 'U', 'S', 'T'};
+    u32 custRev    = CUST_REV;
+    u32 kipVersion = KIP_VERSION;
 
-typedef struct CustomizeTable {
-    u8  cust[4] = {'C', 'U', 'S', 'T'};
-    u32 custRev = CUST_REV;
-
-    u32 placeholder;
     u32 hpMode;
 
     u32 commonEmcMemVolt;
     u32 eristaEmcMaxClock;
-    u32 eristaEmcMaxClock1;
-    u32 eristaEmcMaxClock2;
+
+    StepMode stepMode;
     u32 marikoEmcMaxClock;
     u32 marikoEmcVddqVolt;
-    u32 emcDvbShift;
+    s32 emcDvbShift;
+    u32 marikoSocVmax;
     // advanced config
     u32 t1_tRCD;
     u32 t2_tRP;
@@ -95,8 +87,18 @@ typedef struct CustomizeTable {
     u32 t7_tWTR;
     u32 t8_tREFI;
 
-    u32 mem_burst_read_latency;
-    u32 mem_burst_write_latency;
+    u32 timingEmcTbreak;
+    u32 low_t1_tRCD;
+    u32 low_t2_tRP;
+    u32 low_t3_tRAS;
+    u32 low_t4_tRRD;
+    u32 low_t5_tRFC;
+    u32 low_t6_tRTW;
+    u32 low_t7_tWTR;
+    u32 low_t8_tREFI;
+
+    u32 readLatency[4];
+    u32 writeLatency[4];
 
     u32 eristaCpuUV;
     u32 eristaCpuVmin;
@@ -121,12 +123,11 @@ typedef struct CustomizeTable {
     u32 marikoGpuVmin;
     u32 marikoGpuVmax;
 
-    u32 commonGpuVoltOffset;
-
-    u32 gpuSpeedo;
+    s32 commonGpuVoltOffset;
 
     u32 eristaGpuVoltArray[27];
     u32 marikoGpuVoltArray[24];
+    s32 marikoSocVoltArray[28];
 
     u32 fineTune_t6_tRTW;
     u32 fineTune_t7_tWTR;
@@ -149,8 +150,10 @@ typedef struct CustomizeTable {
     CustomizeGpuDvfsTable marikoGpuDvfsTable;
     CustomizeGpuDvfsTable marikoGpuDvfsTableSLT;
     CustomizeGpuDvfsTable marikoGpuDvfsTableHiOPT;
+    CustomizeGpuDvfsTable marikoGpuDvfsTableHiOPT15;
+    CustomizeGpuDvfsTable marikoGpuDvfsTableHighUV;
 
-} CustomizeTable;
+};
 
 extern volatile CustomizeTable C;
 

Source/Atmosphere/stratosphere/loader/source/oc/erista/calculate_timings_erista.cpp

@@ -1,34 +0,0 @@
-/*
- * Copyright (c) Lightos_
- *
- * 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 "../oc_common.hpp"
-#include "../mtc_timing_value.hpp"
-
-namespace ams::ldr::hoc::pcv::erista {
-
-    void CalculateTimings(double tCK_avg) {
-        tR2W    = FLOOR(FLOOR((5.0 / tCK_avg) + ((FLOOR(48.0 / WL) - 0.478) * 3.0)) / 1.501) + RL - (C.t6_tRTW * 3) + finetRTW;
-        tWTPDEN = CEIL(((1.803 / tCK_avg) + MAX(RL + (2.694 / tCK_avg), static_cast<double>(tW2P))) + (BL / 2));
-        tW2R    = FLOOR(MAX((5.020 / tCK_avg) + 1.130, WL - MAX(-CEIL(0.258 * (WL - RL)), 1.964)) * 1.964) + WL - CEIL(tWTR / tCK_avg) + finetWTR;
-
-        pdex2rw  = CEIL((CEIL(12.335 - tCK_avg) + (7.430 / tCK_avg) - CEIL(tCK_avg * 11.361)));
-        tCLKSTOP = FLOOR(MIN(8.488 / tCK_avg, 23.0)) + 8.0;
-
-        const double tMMRI = tRCD + (tCK_avg * 3);
-        pdex2mrr           = tMMRI + 10;
-    }
-
-}

Source/Atmosphere/stratosphere/loader/source/oc/mariko/calculate_timings.cpp

@@ -1,67 +0,0 @@
-/*
- * Copyright (c) Lightos_
- *
- * 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 "../oc_common.hpp"
-#include "../mtc_timing_value.hpp"
-#include "timing_tables.hpp"
-
-namespace ams::ldr::hoc::pcv::mariko {
-
-    void GetRext() {
-        if (auto r = FindRext()) {
-            rext = r->rext;
-            return;
-        }
-
-        /* Fallback. */
-        rext = 0x1A;
-    }
-
-    void CalculateMrw2() {
-        static const u8 rlMapDBI[8] = {
-            6, 12, 16, 22, 28, 32, 36, 40
-        };
-
-        static const u8 wlMapSetA[8] = {
-            4, 6, 8, 10, 12, 14, 16, 18
-        };
-
-        u32 rlIndex = 0;
-        u32 wlIndex = 0;
-
-        for (u32 i = 0; i < std::size(rlMapDBI); ++i) {
-            if (rlMapDBI[i] == RL) {
-                rlIndex = i;
-                break;
-            }
-        }
-
-        for (u32 i = 0; i < std::size(wlMapSetA); ++i) {
-            if (wlMapSetA[i] == WL) {
-                wlIndex = i;
-                break;
-            }
-        }
-
-        mrw2 = static_cast<u8>(((rlIndex & 0x7) | ((wlIndex & 0x7) << 3) | ((0 & 0x1) << 6)));
-    }
-
-    void CalculateTimings() {
-        GetRext();
-        CalculateMrw2();
-    }
-
-}

Source/Atmosphere/stratosphere/loader/source/oc/mtc_timing_value.hpp

@@ -33,10 +33,6 @@ namespace ams::ldr::hoc {
     /* Burst latency, not to be confused with base latency (tWRL). */
     const u32 BL = 16;
 
-    /* Base latency for read and write (tWRL). */
-    const u32 RL = C.mem_burst_read_latency;
-    const u32 WL = C.mem_burst_write_latency;
-
     /* Precharge to Precharge Delay. (tCK) */
     const u32 tPPD = 4;
 
@@ -87,19 +83,30 @@ namespace ams::ldr::hoc {
         const u32 tFAW     = static_cast<u32>(tRRD * 4.0);
         const double tRPab = tRPpb + 3;
 
-        const u32 tR2P   = CEIL((RL * 0.426) - 2.0);
+        inline u32 RL;
+        inline u32 WL;
+
+        inline u32 tR2P;
         inline u32 tR2W;
         inline u32 rext;
 
-        const u32 tW2P = (CEIL(WL * 1.7303) * 2) - 5;
+        inline u32 tW2P;
         inline u32 tWTPDEN;
         inline u32 tW2R;
 
+        inline u32 wdv;
+        inline u32 wsv;
+        inline u32 wev;
+
+        inline u32 obdly;
+
         inline u32 pdex2rw;
 
         inline u32 tCLKSTOP;
 
         inline double pdex2mrr;
+
+        inline u8 mrw2;
     }
 
     namespace pcv::mariko {
@@ -111,60 +118,56 @@ namespace ams::ldr::hoc {
         const std::array<u32,      10>  tWTR_values   = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
         const std::array<u32,       6>  tREFpb_values = { 3900, 5850, 7800, 11700, 15600, 99999 };
 
-        const double tCK_avg = 1000'000.0 / C.marikoEmcMaxClock;
+        inline u32 tRCD;
+        inline u32 tRPpb;
+        inline u32 tRAS;
+        inline double tRRD;
+        inline u32 tRFCpb;
 
-        const u32 tRCD    = tRCD_values[C.t1_tRCD];
-        const u32 tRPpb   = tRP_values[C.t2_tRP];
-        const u32 tRAS    = tRAS_values[C.t3_tRAS];
-        const double tRRD = tRRD_values[C.t4_tRRD];
-        const u32 tRFCpb  = tRFC_values[C.t5_tRFC];
-        const u32 tWTR    = 10 - tWTR_values[C.t7_tWTR];
-        const s32 finetRTW = C.fineTune_t6_tRTW;
-        const s32 finetWTR = C.fineTune_t7_tWTR;
+        inline u32 tRC;
+        inline u32 tRFCab;
+        inline double tXSR;
+        inline u32 tFAW;
+        inline double tRPab;
 
-        const u32 tRC      = tRAS + tRPpb;
-        const u32 tRFCab   = tRFCpb * 2;
-        const double tXSR  = static_cast<double>(tRFCab + 7.5);
-        const u32 tFAW     = static_cast<u32>(tRRD * 4.0);
-        const double tRPab = tRPpb + 3;
+        inline u32 refresh_raw;
 
-        const u32 tR2P   = CEIL((RL * 0.426) - 2.0);
-        const u32 tR2W = FLOOR(FLOOR((5.0 / tCK_avg) + ((FLOOR(48.0 / WL) - 0.478) * 3.0)) / 1.501) + RL - (C.t6_tRTW * 3) + finetRTW;
-        const u32 tRTM   = FLOOR((10.0 + RL) + (3.502 / tCK_avg)) + FLOOR(7.489 / tCK_avg);
-        const u32 tRATM  = CEIL((tRTM - 10.0) + (RL * 0.426));
+        inline u32 RL;
+        inline u32 WL;
+
+        inline u32 tR2P;
+        inline u32 tR2W;
+        inline u32 tRTM;
+        inline u32 tRATM;
         inline u32 rext;
 
-        const u32 rdv             = RL + FLOOR((5.105 / tCK_avg) + 17.017);
-        const u32 qpop            = rdv - 14;
-        const u32 quse_width      = CEIL(((4.897 / tCK_avg) - FLOOR(2.538 / tCK_avg)) + 3.782);
-        const u32 quse            = FLOOR(RL + ((5.082 / tCK_avg) + FLOOR(2.560 / tCK_avg))) - CEIL(4.820 / tCK_avg);
-        const u32 einput_duration = FLOOR(9.936 / tCK_avg) + 5.0 + quse_width;
-        const u32 einput          = quse - CEIL(9.928 / tCK_avg);
-        const u32 qrst_duration   = FLOOR(8.399 - tCK_avg);
-        const u32 qrstLow         = MAX(static_cast<s32>(einput - qrst_duration - 2), static_cast<s32>(0));
-        const u32 qrst            = PACK_U32(qrst_duration, qrstLow);
-        const u32 ibdly           = PACK_U32_NIBBLE_HIGH_BYTE_LOW(1, quse - qrst_duration - 2.0);
-        const u32 qsafe           = (einput_duration + 3) + MAX(MIN(qrstLow * rdv, qrst_duration + qrst_duration), einput);
-        const u32 tW2P            = (CEIL(WL * 1.7303) * 2) - 5;
-        const u32 tWTPDEN         = CEIL(((1.803 / tCK_avg) + MAX(RL + (2.694 / tCK_avg), static_cast<double>(tW2P))) + (BL / 2));
-        const u32 tW2R            = FLOOR(MAX((5.020 / tCK_avg) + 1.130, WL - MAX(-CEIL(0.258 * (WL - RL)), 1.964)) * 1.964) + WL - CEIL(tWTR / tCK_avg) + finetWTR;
-        const u32 tWTM            = CEIL(WL + ((7.570 / tCK_avg) + 8.753));
-        const u32 tWATM           = (tWTM + (FLOOR(WL / 0.816) * 2.0)) - 4.0;
+        inline u32 rdv;
+        inline u32 qpop;
+        inline u32 quse_width;
+        inline u32 quse;
+        inline u32 einput_duration;
+        inline u32 einput;
+        inline u32 qrst;
+        inline u32 ibdly;
+        inline u32 qsafe;
 
-        const u32 wdv = WL;
-        const u32 wsv = WL - 2;
-        const u32 wev = 0xA + (WL - 14);
+        inline u32 tW2P;
+        inline u32 tWTPDEN;
+        inline u32 tW2R;
+        inline u32 tWTM;
+        inline u32 tWATM;
 
-        const u32 obdlyHigh = 3 / FLOOR(MIN(static_cast<double>(2), tCK_avg * (WL - 7)));
-        const u32 obdlyLow = MAX(WL - FLOOR((126.0 / CEIL(tCK_avg + 8.601))), 0.0);
-        const u32 obdly = PACK_U32_NIBBLE_HIGH_BYTE_LOW(obdlyHigh, obdlyLow);
+        inline u32 wdv;
+        inline u32 wsv;
+        inline u32 wev;
 
-        const u32 pdex2rw = CEIL((CEIL(12.335 - tCK_avg) + (7.430 / tCK_avg) - CEIL(tCK_avg * 11.361)));
+        inline u32 obdly;
 
-        const u32 tCLKSTOP = FLOOR(MIN(8.488 / tCK_avg, 23.0)) + 8.0;
+        inline u32 pdex2rw;
 
-        const double tMMRI    = tRCD + (tCK_avg * 3);
-        const double pdex2mrr = tMMRI + 10; /* Do this properly? */
+        inline u32 tCLKSTOP;
+
+        inline u32 pdex2mrr;
 
         inline u8 mrw2;
     }

Source/Atmosphere/stratosphere/loader/source/oc/oc_common.hpp

@@ -18,85 +18,155 @@
 
 #pragma once
 
-#ifdef ATMOSPHERE_IS_STRATOSPHERE
-    #include <stratosphere.hpp>
-    #include <vapours/results/results_common.hpp>
-    #define LOGGING(fmt, ...) ((void)0)
-    #define CRASH(msg, ...) { ams::diag::AbortImpl(msg, __PRETTY_FUNCTION__, "", 0); __builtin_unreachable(); }
-#else
-    #include "oc_test.hpp"
+#include <stratosphere.hpp>
+#include <vapours/results/results_common.hpp>
+
+
+#ifndef HOC_UART_LOG
+#define HOC_UART_LOG 0
 #endif
 
+#if HOC_UART_LOG && !(defined(AMS_BUILD_FOR_AUDITING) || defined(AMS_BUILD_FOR_DEBUGGING))
+    #undef HOC_UART_LOG
+    #define HOC_UART_LOG 0
+#endif
+
+#define HOC_PCV_NVLOG_PATCH 1
+#define HOC_PCV_FORCE_VERBOSITY 1
+
 #include "customize.hpp"
+#include "oc_log.hpp"
+
+#define HOC_IRAM_LOG 0
+
+#if (!HOC_UART_LOG) && (defined(AMS_BUILD_FOR_AUDITING) || defined(AMS_BUILD_FOR_DEBUGGING))
+    #undef HOC_IRAM_LOG
+    #define HOC_IRAM_LOG 1
+#endif
+
+#if defined(AMS_BUILD_FOR_AUDITING) || defined(AMS_BUILD_FOR_DEBUGGING)
+
+    #if HOC_IRAM_LOG
+        #define LOGGING(...) Log(__VA_ARGS__)
+    #elif HOC_UART_LOG
+        #define LOGGING(fmt, ...) AMS_LOG(fmt "\n", ##__VA_ARGS__)
+    #endif
+
+#else
+    #define LOGGING(...) ((void)0)
+#endif
+
+#define CRASH(msg, ...) { ams::diag::AbortImpl(msg, __PRETTY_FUNCTION__, "", 0); __builtin_unreachable(); }
 
 #define PATCH_OFFSET(offset, value) \
     static_assert(sizeof(__typeof__(offset)) <= sizeof(u64)); \
     *(offset) = value;
 
 namespace ams::ldr {
-    R_DEFINE_ERROR_RESULT(OutOfRange,               1000);
-    R_DEFINE_ERROR_RESULT(InvalidMemPllmEntry,      1001);
-    R_DEFINE_ERROR_RESULT(InvalidMtcMagic,          1002);
-    R_DEFINE_ERROR_RESULT(InvalidMtcTable,          1003);
-    R_DEFINE_ERROR_RESULT(InvalidDvbTable,          1004);
-    R_DEFINE_ERROR_RESULT(InvalidCpuFreqVddEntry,   1005);
-    R_DEFINE_ERROR_RESULT(InvalidCpuVoltDfllEntry,  1006);
-    R_DEFINE_ERROR_RESULT(InvalidCpuDvfs,           1007);
-    R_DEFINE_ERROR_RESULT(InvalidCpuMinVolt,        1008);
-    R_DEFINE_ERROR_RESULT(InvalidGpuDvfs,           1009);
-    R_DEFINE_ERROR_RESULT(InvalidGpuFreqMaxPattern, 1010);
-    R_DEFINE_ERROR_RESULT(InvalidGpuPllEntry,       1011);
-    R_DEFINE_ERROR_RESULT(InvalidRegulatorEntry,    1012);
-    R_DEFINE_ERROR_RESULT(UninitializedPatcher,     1013);
-    R_DEFINE_ERROR_RESULT(UnsuccessfulPatcher,      1014);
-    R_DEFINE_ERROR_RESULT(SafetyCheckFailure,       1015);
+    R_DEFINE_ERROR_RESULT(OutOfRange,                1000);
+    R_DEFINE_ERROR_RESULT(InvalidMemPllmEntry,       1001);
+    R_DEFINE_ERROR_RESULT(InvalidMtcMagic,           1002);
+    R_DEFINE_ERROR_RESULT(InvalidMtcTable,           1003);
+    R_DEFINE_ERROR_RESULT(InvalidDvbTable,           1004);
+    R_DEFINE_ERROR_RESULT(InvalidCpuFreqVddEntry,    1005);
+    R_DEFINE_ERROR_RESULT(InvalidCpuVoltDfllEntry,   1006);
+    R_DEFINE_ERROR_RESULT(InvalidCpuDvfs,            1007);
+    R_DEFINE_ERROR_RESULT(InvalidCpuMinVolt,         1008);
+    R_DEFINE_ERROR_RESULT(InvalidGpuDvfs,            1009);
+    R_DEFINE_ERROR_RESULT(InvalidGpuFreqMaxPattern,  1010);
+    R_DEFINE_ERROR_RESULT(InvalidGpuPllEntry,        1011);
+    R_DEFINE_ERROR_RESULT(InvalidRegulatorEntry,     1012);
+    R_DEFINE_ERROR_RESULT(UninitializedPatcher,      1013);
+    R_DEFINE_ERROR_RESULT(UnsuccessfulPatcher,       1014);
+    R_DEFINE_ERROR_RESULT(SafetyCheckFailure,        1015);
+    R_DEFINE_ERROR_RESULT(InvalidMtcTablePattern,    1016);
+    R_DEFINE_ERROR_RESULT(InvalidSocVoltPattern,     1017);
+    R_DEFINE_ERROR_RESULT(InvalidSocVoltLimit,       1018);
+    R_DEFINE_ERROR_RESULT(InvalidEmcDvfsCount,       1019);
+    R_DEFINE_ERROR_RESULT(InvalidEmcSocLut,          1020);
+    R_DEFINE_ERROR_RESULT(InvalidEmcRateList,        1021);
+    R_DEFINE_ERROR_RESULT(InvalidNvLogRedirect,      1022);
+    R_DEFINE_ERROR_RESULT(InvalidBusFreqReloc,       1023);
+    R_DEFINE_ERROR_RESULT(HookArenaOutOfMemory,      1024);
+    R_DEFINE_ERROR_RESULT(HookPayloadTooLarge,       1025);
+    R_DEFINE_ERROR_RESULT(HookRelocationUnsupported, 1026);
+    R_DEFINE_ERROR_RESULT(HookSiteInvalid,           1027);
+    R_DEFINE_ERROR_RESULT(HookPayloadEscapes,        1028);
+    R_DEFINE_ERROR_RESULT(HookDataOutOfMemory,       1029);
+    R_DEFINE_ERROR_RESULT(HookUnavailable,           1030);
 }
 
 namespace ams::ldr::hoc {
     template<typename Pointer>
     struct PatcherEntry {
-        using patternFn = bool(*)(Pointer* ptr);
-        using patcherFn = Result(*)(Pointer* ptr);
+        using patternFn = bool(*)(Pointer *ptr);
+        using patcherFn = Result(*)(Pointer *ptr);
 
         const char* description;
         patcherFn   patcher_fn = nullptr;
         size_t      maximum_patched_count = 0;
         patternFn   pattern_search_fn = nullptr;
         Pointer     value_search;
-
         size_t      patched_count = 0;
+        bool        optional = false;
 
-        Result Apply(Pointer* ptr) {
+        Result Apply(Pointer *ptr) {
             Result res = patcher_fn(ptr);
-            if (R_SUCCEEDED(res))
+            if (R_SUCCEEDED(res)) {
                 patched_count++;
+            }
 
             return res;
         }
 
-        Result SearchAndApply(Pointer* ptr) {
+        Result SearchAndApply(Pointer *ptr) {
             bool searchOk = false;
             if (pattern_search_fn) {
-                if (pattern_search_fn(ptr)) searchOk = true;
+                if (pattern_search_fn(ptr)) {
+                    searchOk = true;
+                }
             } else {
-                if (value_search == *(ptr)) searchOk = true;
+                if (value_search == *(ptr)) {
+                    searchOk = true;
+                }
             }
 
-            if (searchOk)
+            if (searchOk) {
                 return Apply(ptr);
+            }
 
             R_THROW(ldr::ResultUnsuccessfulPatcher());
         }
 
         Result CheckResult() {
-            #ifndef ATMOSPHERE_IS_STRATOSPHERE
-            R_UNLESS(patched_count > 0, ldr::ResultUnsuccessfulPatcher());
-            #endif
+            R_UNLESS(optional || patched_count > 0, ldr::ResultUnsuccessfulPatcher());
 
-            if (maximum_patched_count)
+            if (maximum_patched_count) {
                 R_UNLESS(patched_count <= maximum_patched_count, ldr::ResultUnsuccessfulPatcher());
+            }
 
             R_SUCCEED();
         }
     };
+
+    namespace panic {
+        /* Requires modifying g_ams_handlers in secmon_smc_handler.cpp */
+        constexpr inline void SmcError(u32 rgb) {
+            SecmonArgs args = {};
+            constexpr u32 SmcShowErrorID = 0xF0000005;
+            args.X[0] = SmcShowErrorID;
+            args.X[1] = rgb;
+            svcCallSecureMonitor(&args);
+        }
+
+        constexpr inline u32 PackCode(u32 r, u32 g, u32 b) {
+            return ((r & 0xF) << 8) | ((g & 0xF) << 4) | ((b & 0xF) << 0);
+        }
+
+        constexpr u32 Gpu   = PackCode(0xF, 0x7, 0x0);
+        constexpr u32 Cpu   = PackCode(0xF, 0x0, 0x0);
+        constexpr u32 Emc   = PackCode(0x0, 0xF, 0xF);
+        constexpr u32 Patch = PackCode(0x8, 0x0, 0xF);
+    }
+
 }

Source/Atmosphere/stratosphere/loader/source/oc/oc_log.cpp

@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2019 m4xw <m4x@m4xw.net>
+ * Copyright (c) 2019 Atmosphere-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/>.
+ */
+
+/* See https://github.com/lulle2007200/emuMMC/blob/internal-emummc/source/ */
+
+#include "oc_common.hpp"
+
+#if HOC_IRAM_LOG
+#include "fatal_handler_bin.h"
+#endif
+
+namespace ams::ldr::hoc {
+
+    #define ATMOSPHERE_REBOOT_TO_FATAL_MAGIC 0x32454641
+    #define ATMOSPHERE_IRAM_PAYLOAD_BASE 0x40010000
+    #define ATMOSPHERE_FATAL_ERROR_ADDR 0x4003E000
+
+    _Alignas(4096) u8 working_buf[4096];
+
+    void SmcRebootToIramPayload() {
+        SecmonArgs args;
+        args.X[0] = 0xC3000401;
+        args.X[1] = 65001;
+        args.X[2] = 0;
+        args.X[3] = 2;
+        svcCallSecureMonitor(&args);
+    }
+
+    Result SmcCopyToIram(uintptr_t dest, const void *src, u32 size) {
+        SecmonArgs args;
+        args.X[0] = 0xF0000201;
+        args.X[1] = (u64)src;
+        args.X[2] = (u64)dest;
+        args.X[3] = size;
+        args.X[4] = 1;
+        svcCallSecureMonitor(&args);
+        Result rc = 0;
+        if (args.X[0] != 0) {
+            rc = (26u | ((u32)args.X[0] << 9u));
+        }
+        return rc;
+    }
+
+    Result SmcCopyFromIram(void *dest, uintptr_t src, u32 size) {
+        SecmonArgs args;
+        args.X[0] = 0xF0000201;
+        args.X[1] = (u64)dest;
+        args.X[2] = (u64)src;
+        args.X[3] = size;
+        args.X[4] = 0;
+        svcCallSecureMonitor(&args);
+        Result rc = 0;
+        if (args.X[0] != 0) {
+            rc = (26u | ((u32)args.X[0] << 9u));
+        }
+        return rc;
+    }
+
+    #if HOC_UART_LOG
+    /* Remove this? */
+    void UartLog(const char *fmt, ...) {
+        char line[256];
+        constexpr size_t PrefixLen = 13;   /* "[HOC] " */
+        std::memcpy(line, "[Horizon OC] ", PrefixLen);
+
+        va_list args;
+        va_start(args, fmt);
+        int n = vsnprintf(line + PrefixLen, sizeof(line) - PrefixLen - 1, fmt, args);
+        va_end(args);
+        if (n < 0) {
+            return;
+        }
+
+        size_t body = static_cast<size_t>(n);
+        if (body > sizeof(line) - PrefixLen - 2) { /* vsnprintf returns the untruncated length */
+            body = sizeof(line) - PrefixLen - 2;
+        }
+        size_t len = PrefixLen + body;
+        line[len++] = '\n';
+
+        svc::OutputDebugString(line, len);
+    }
+    #endif
+
+    struct log_ctx_t {
+        u32 magic;
+        u32 sz;
+        u32 start;
+        u32 end;
+        char buf[];
+    };
+
+    #define IRAM_LOG_CTX_ADDR 0x4003C000
+    #define IRAM_LOG_MAX_SZ 4096
+
+    #if HOC_IRAM_LOG
+    void Log(const char *data, ...) {
+        static const u32 max_log_sz = sizeof(working_buf) - sizeof(log_ctx_t);
+        static bool initDone = false;
+        log_ctx_t *log_ctx = (log_ctx_t*)working_buf;
+
+        R_DISCARD(SmcCopyFromIram(working_buf, IRAM_LOG_CTX_ADDR, sizeof(working_buf)));
+
+        if (!initDone) {
+            initDone = true;
+            log_ctx->buf[0] = '\0';
+            log_ctx->magic = 0xaabbccdd;
+            log_ctx->start = 0;
+            log_ctx->end   = 0;
+        }
+
+        va_list args;
+        va_start(args, data);
+        s32 res = vsnprintf(log_ctx->buf + log_ctx->end, max_log_sz - log_ctx->end, data, args);
+        va_end(args);
+
+        if (res < 0 || res >= (static_cast<s32>(max_log_sz - log_ctx->end))) {
+            R_DISCARD(SmcCopyToIram(IRAM_LOG_CTX_ADDR, working_buf, sizeof(working_buf)));
+            return;
+        }
+
+        log_ctx->end += res;
+        R_DISCARD(SmcCopyToIram(IRAM_LOG_CTX_ADDR, working_buf, sizeof(working_buf)));
+    }
+    #endif
+
+    void ViewLog() {
+        #if HOC_IRAM_LOG
+        if (spl::GetSocType() == spl::SocType_Mariko) {
+            return;
+        }
+
+        constexpr size_t PageSize = 4096;
+        for (size_t ofs = 0; ofs < fatal_handler_bin_size; ofs += PageSize) {
+            memcpy(&working_buf, fatal_handler_bin + ofs, std::min(fatal_handler_bin_size - ofs, PageSize));
+            R_DISCARD(SmcCopyToIram(ATMOSPHERE_IRAM_PAYLOAD_BASE + ofs, &working_buf, std::min(fatal_handler_bin_size - ofs, PageSize)));
+        }
+
+        SmcRebootToIramPayload();
+
+        while(true) { }
+        #endif
+    }
+}

Source/Atmosphere/stratosphere/loader/source/oc/oc_log.hpp

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2019 m4xw <m4x@m4xw.net>
+ * Copyright (c) 2019 Atmosphere-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/>.
+ */
+
+/* See https://github.com/lulle2007200/emuMMC/blob/internal-emummc/source/ */
+
+#pragma once
+
+namespace ams::ldr::hoc {
+
+    Result SmcCopyToIram(uintptr_t dest, const void *src, u32 size);
+    void Log(const char *data, ...);
+    void ViewLog();
+
+    /* Emit a formatted line over the kernel debug UART via svcOutputDebugString.
+       No-op unless the running kernel enables debug logging (audit/debug mesosphere). */
+    void UartLog(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/oc_test.cpp

@@ -1,214 +0,0 @@
-/*
- * Copyright (C) Switch-OC-Suite
- *
- * Copyright (c) Souldbminer, Lightos_ and Horizon OC Contributors
- *
- * 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/>.
- */
-
-#ifndef ATMOSPHERE_IS_STRATOSPHERE
-#include "oc_test.hpp"
-#include "oc_loader.hpp"
-
-void* loadExec(const char* file_loc, size_t* out_size) {
-    FILE* fp = fopen(file_loc, "rb");
-    if (!fp) {
-        fprintf(stderr, "Cannot open file: \"%s\"\n", file_loc);
-        exit(-1);
-    }
-
-    if (fseek(fp, 0, SEEK_END) < 0) {
-        fprintf(stderr, "fseek error\n");
-        exit(-1);
-    }
-
-    long size = ftell(fp);
-    if (size == -1L) {
-        fprintf(stderr, "\"%s\" is a directory", file_loc);
-        exit(-1);
-    }
-
-    fseek(fp, 0, SEEK_SET);
-    void* buf = malloc(size);
-
-    fread(buf, size, 1, fp);
-    fclose(fp);
-
-    if (size < 8192) {
-        fprintf(stderr, "File is too small to process: \"%s\" (%ld B)\n", file_loc, size);
-        exit(-1);
-    }
-
-    *out_size = size;
-    return buf;
-}
-
-void saveExec(const char* file_loc, const void* buf, size_t size) {
-    FILE* fp = fopen(file_loc, "wb");
-    if (!fp) {
-        fprintf(stderr, "Cannot write to \"%s\"\n", file_loc);
-        exit(-1);
-    }
-    printf("Saving to \"%s\"...\n", file_loc);
-    fwrite(buf, size, 1, fp);
-    fclose(fp);
-}
-
-Result Test_PcvDvfsTable() {
-    using namespace ams::ldr::hoc::pcv;
-
-    assert(GetDvfsTableEntryCount((cvb_entry_t *)(&mariko::CpuCvbTableDefault)) == 18);
-    assert(GetDvfsTableEntryCount((cvb_entry_t *)(&erista::CpuCvbTableDefault)) == 16);
-
-    assert(GetDvfsTableEntryCount((cvb_entry_t *)(&mariko::GpuCvbTableDefault)) == 17);
-    assert(GetDvfsTableEntryCount((cvb_entry_t *)(&erista::GpuCvbTableDefault)) == 12);
-
-    cvb_entry_t last_mariko_cpu_cvb_entry_default = { 1963500, { 1675751, -38635, 27 }, { 1120000 } };
-    assert(memcmp(GetDvfsTableLastEntry((cvb_entry_t *)(&mariko::CpuCvbTableDefault)), (void *)&last_mariko_cpu_cvb_entry_default, sizeof(last_mariko_cpu_cvb_entry_default)) == 0);
-    assert(GetDvfsTableLastEntry((cvb_entry_t *)(&erista::GpuCvbTableDefault))->freq == 921600);
-    assert(GetDvfsTableEntryCount((cvb_entry_t *)(&ams::ldr::hoc::C.marikoCpuDvfsTableSLT)) == 25);
-
-    // Customized table default
-    assert(GetDvfsTableEntryCount((cvb_entry_t *)(&ams::ldr::hoc::C.eristaCpuDvfsTable)) == 19);
-    assert(GetDvfsTableEntryCount((cvb_entry_t *)(&ams::ldr::hoc::C.marikoCpuDvfsTable)) == 21);
-    assert(GetDvfsTableEntryCount((cvb_entry_t *)(&ams::ldr::hoc::C.marikoCpuDvfsTableSLT)) == 22);
-
-    assert(GetDvfsTableEntryCount((cvb_entry_t *)(&ams::ldr::hoc::C.eristaGpuDvfsTable)) == 12);
-    assert(GetDvfsTableEntryCount((cvb_entry_t *)(&ams::ldr::hoc::C.marikoGpuDvfsTable)) == 17);
-    assert(GetDvfsTableEntryCount((cvb_entry_t *)(&ams::ldr::hoc::C.marikoGpuDvfsTableSLT)) == 17);
-    assert(GetDvfsTableEntryCount((cvb_entry_t *)(&ams::ldr::hoc::C.marikoGpuDvfsTableHiOPT)) == 17);
-
-    constexpr size_t limit = ams::ldr::hoc::pcv::DvfsTableEntryLimit;
-    cvb_entry_t customized_table[limit] = {};
-    for (size_t i = 0; i < limit; i++) {
-        assert(GetDvfsTableEntryCount(customized_table) == i);
-        auto p = GetDvfsTableLastEntry(customized_table);
-        if (p)
-            assert(p->freq == i);
-
-        customized_table[i].freq = i + 1;
-    }
-
-    R_SUCCEED();
-}
-
-void unitTest() {
-    UnitTest test[] = {
-        { "PCV DVFS Table", &Test_PcvDvfsTable }
-    };
-
-    for (auto &t : test) {
-        t.Test();
-    }
-}
-
-int main(int argc, char** argv) {
-    unitTest();
-
-    const char* pcv_opt    = "pcv";
-    const char* ptm_opt    = "ptm";
-    const char* save_opt   = "-s";
-    const char* mariko_ext = ".mariko";
-    const char* erista_ext = ".erista";
-    enum EXE_OPTION {
-        EXE_PCV,
-        EXE_PTM,
-        UNKNOWN
-    };
-    EXE_OPTION exe_opt = UNKNOWN;
-    if (argc > 2) {
-        if (!strcmp(argv[1], pcv_opt))
-            exe_opt = EXE_PCV;
-
-        if (!strcmp(argv[1], ptm_opt))
-            exe_opt = EXE_PTM;
-    }
-    if ((argc != 3 && argc != 4) || exe_opt == UNKNOWN) {
-        fprintf(stderr, "Usage:\n"\
-                        "    %s  %s | %s  [%s]  <exec_path>\n\n"\
-                        "    %s : Save patched executable with extension \"%s\" / \"%s\"\n"
-                        , argv[0], pcv_opt, ptm_opt, save_opt
-                        , save_opt, mariko_ext, erista_ext);
-        return -1;
-    }
-
-    bool save_patched = false;
-    char* exec_path = argv[2];
-    if (argc == 4 && !strcmp(argv[2], save_opt)) {
-        save_patched = true;
-        exec_path = argv[3];
-    }
-
-    size_t file_size;
-    void* file_buffer = loadExec(exec_path, &file_size);
-
-    size_t exec_path_len = strlen(reinterpret_cast<const char *>(exec_path));
-    size_t exec_path_patched_len = exec_path_len + std::max(strlen(mariko_ext), strlen(erista_ext)) + 1;
-
-    if (exe_opt == EXE_PCV) {
-        ams::ldr::hoc::pcv::SafetyCheck();
-
-        {
-            void* erista_buf = malloc(file_size);
-            std::memcpy(erista_buf, file_buffer, file_size);
-
-            printf("Patching %s for Erista...\n", pcv_opt);
-            ams::ldr::hoc::pcv::erista::Patch(reinterpret_cast<uintptr_t>(erista_buf), file_size);
-            if (save_patched) {
-                char* exec_path_erista = reinterpret_cast<char *>(malloc(exec_path_patched_len));
-                strncpy(exec_path_erista, exec_path, exec_path_patched_len);
-                strncat(exec_path_erista, erista_ext, exec_path_patched_len);
-                saveExec(exec_path_erista, erista_buf, file_size);
-                free(exec_path_erista);
-            }
-            free(erista_buf);
-        }
-
-        {
-            void* mariko_buf = malloc(file_size);
-            std::memcpy(mariko_buf, file_buffer, file_size);
-
-            printf("Patching %s for Mariko...\n", pcv_opt);
-            ams::ldr::hoc::pcv::mariko::Patch(reinterpret_cast<uintptr_t>(mariko_buf), file_size);
-            if (save_patched) {
-                char* exec_path_mariko = reinterpret_cast<char *>(malloc(exec_path_patched_len));
-                strncpy(exec_path_mariko, exec_path, exec_path_patched_len);
-                strncat(exec_path_mariko, mariko_ext, exec_path_patched_len);
-                saveExec(exec_path_mariko, mariko_buf, file_size);
-                free(exec_path_mariko);
-            }
-            free(mariko_buf);
-        }
-    }
-
-    if (exe_opt == EXE_PTM) {
-        void* mariko_buf = malloc(file_size);
-        std::memcpy(mariko_buf, file_buffer, file_size);
-
-        printf("Patching %s (Mariko Only)...\n", ptm_opt);
-        ams::ldr::hoc::ptm::Patch(reinterpret_cast<uintptr_t>(mariko_buf), file_size);
-        if (save_patched) {
-            char* exec_path_mariko = reinterpret_cast<char *>(malloc(exec_path_patched_len));
-            strncpy(exec_path_mariko, exec_path, exec_path_patched_len);
-            strncat(exec_path_mariko, mariko_ext, exec_path_patched_len);
-            saveExec(exec_path_mariko, mariko_buf, file_size);
-            free(exec_path_mariko);
-        }
-        free(mariko_buf);
-    }
-
-    free(file_buffer);
-    printf("Passed!\n\n");
-    return 0;
-}
-#endif

Source/Atmosphere/stratosphere/loader/source/oc/oc_test.hpp

@@ -1,81 +0,0 @@
-/*
- * Copyright (C) Switch-OC-Suite
- *
- * Copyright (c) Souldbminer, Lightos_ and Horizon OC Contributors
- *
- * 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
-
-#ifndef ATMOSPHERE_IS_STRATOSPHERE
-#include <cassert>
-#include <algorithm>
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <cctype>
-
-typedef uint8_t  u8;
-typedef uint16_t u16;
-typedef uint32_t u32;
-typedef int32_t  s32;
-typedef uint64_t u64;
-typedef int      Result;
-
-#define R_SUCCEEDED(arg)   (arg == 0)
-#define R_FAILED(arg)      (arg != 0)
-#define LOGGING(fmt, ...)  { printf(fmt "\n", ##__VA_ARGS__); }
-#define CRASH(msg, ...)    { fprintf(stderr, "%s\nFailed in %s!\n", msg, __PRETTY_FUNCTION__); exit(-1); }
-#define R_SUCCEED()        { return 0; }
-#define R_THROW(err)       { return err; }
-#define R_TRY(expr)        { Result _rc = (expr); if (R_FAILED(_rc)) { return _rc; } }
-#define R_UNLESS(expr, rc) { if (!(expr)) { return rc; } }
-
-#define R_DEFINE_ERROR_RESULT(name, rc)        \
-    inline Result Result##name() { return rc; }
-
-#define HEXDUMP(ptr, len)                                           \
-    {                                                               \
-        const uint8_t* p = reinterpret_cast<const uint8_t *>(ptr);  \
-        size_t i, j;                                                \
-        for (i = 0; i < len; i += 16) {                             \
-            printf("%06zx: ", i);                                   \
-            for (j = 0; j < 16 && i + j < len; j++)                 \
-                printf("%02x ", p[i + j]);                          \
-            for (; j < 16; j++)                                     \
-                printf("   ");                                      \
-            for (j = 0; j < 16 && i + j < len; j++)                 \
-                printf("%c", isprint(p[i + j]) ? p[i + j] : '.');   \
-            printf("\n");                                           \
-        }                                                           \
-    }                                                               \
-
-typedef struct UnitTest {
-    using Func = Result(*)();
-
-    const char* description;
-    Func        fun = nullptr;
-
-    void Test() {
-        Result res = fun();
-        if (R_FAILED(res)) {
-            CRASH(description);
-        }
-    }
-} UnitTest;
-
-#endif

Source/Atmosphere/stratosphere/loader/source/oc/pcv/erista/calculate_timings_erista.cpp

@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) Lightos_
+ *
+ * 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 "../../mtc_timing_value.hpp"
+
+namespace ams::ldr::hoc::pcv::erista {
+
+    void SwitchLatency(volatile u32 &latency, u32 index, u32 latencyStep) {
+        latency += index * latencyStep;
+    }
+
+    static s32 GetMaxLatencyIndex(volatile u32 *latencyArray, u32 latencySize) {
+        s32 maxIndex = -1;
+        for (u32 i = 0; i < latencySize; ++i) {
+            if (latencyArray[i]) {
+                maxIndex = i;
+            }
+        }
+
+        return maxIndex;
+    }
+
+    void AutoLatency(volatile u32 &latency, u32 freq, u32 latencyStep) {
+        if (freq > 1600'000 && freq <= 1866'000) { /* 1866tRWL */
+            latency += latencyStep * 2;
+        } else { /* 2133tRWL */
+            latency += latencyStep * 3;
+        }
+    }
+
+    void HandleLatency(u32 freq, volatile u32 &latency, volatile u32 *latencyArray, u32 indexMax, u32 latencyStep) {
+        for (u32 i = 0; i <= indexMax; ++i) {
+            if (latencyArray[i] != 0 && freq <= latencyArray[i]) {
+                SwitchLatency(latency, i, latencyStep);
+                return;
+            }
+        }
+
+        SwitchLatency(latency, indexMax, latencyStep);
+    }
+
+    void HandleLatency(u32 freq) {
+        static s32 rlIndexMax = GetMaxLatencyIndex(C.readLatency, std::size(C.readLatency));
+        static s32 wlIndexMax = GetMaxLatencyIndex(C.writeLatency, std::size(C.writeLatency));
+        constexpr u32 ReadLatencyStep  = 4;
+        constexpr u32 WriteLatencyStep = 2;
+        bool autoLatencyRead = false, autoLatencyWrite = false;
+
+        if (rlIndexMax == -1) {
+            AutoLatency(RL, freq, ReadLatencyStep);
+            autoLatencyRead = true;
+        }
+
+        if (wlIndexMax == -1) {
+            AutoLatency(WL, freq, WriteLatencyStep);
+            autoLatencyWrite = true;
+        }
+
+        if (autoLatencyRead && autoLatencyWrite) {
+            return;
+        }
+
+        if (!autoLatencyRead) {
+            HandleLatency(freq, RL, C.readLatency, rlIndexMax, ReadLatencyStep);
+        }
+
+        if (!autoLatencyWrite) {
+            HandleLatency(freq, WL, C.writeLatency, wlIndexMax, WriteLatencyStep);
+        }
+    }
+
+    void CalculateMrw2() {
+        static const u8 rlMapDBI[8] = {
+            6, 12, 16, 22, 28, 32, 36, 40
+        };
+
+        static const u8 wlMapSetA[8] = {
+            4, 6, 8, 10, 12, 14, 16, 18
+        };
+
+        u32 rlIndex = 0;
+        u32 wlIndex = 0;
+
+        for (u32 i = 0; i < std::size(rlMapDBI); ++i) {
+            if (rlMapDBI[i] == 32) {
+                rlIndex = i;
+                break;
+            }
+        }
+
+        for (u32 i = 0; i < std::size(wlMapSetA); ++i) {
+            if (wlMapSetA[i] == WL) {
+                wlIndex = i;
+                break;
+            }
+        }
+
+        /* DBI is always enabled. */
+        mrw2 = static_cast<u8>(((rlIndex & 0x7) | ((wlIndex & 0x7) << 3) | ((0 & 0x1) << 6)));
+    }
+
+    void CalculateTimings(double tCK_avg, u32 freq) {
+        RL = RL_1331;
+        WL = WL_1331;
+
+        HandleLatency(freq);
+        CalculateMrw2();
+
+        tR2P = CEIL((RL * 0.426) - 2.0);
+        tR2W = FLOOR(FLOOR((5.0 / tCK_avg) + ((FLOOR(48.0 / WL) - 0.478) * 3.0)) / 1.501) + RL - (C.t6_tRTW * 3) + finetRTW;
+
+        tW2P    = (CEIL(WL * 1.7303) * 2) - 5;
+        tWTPDEN = CEIL(((1.803 / tCK_avg) + MAX(RL + (2.694 / tCK_avg), static_cast<double>(tW2P))) + (BL / 2));
+        tW2R    = FLOOR(MAX((5.020 / tCK_avg) + 1.130, WL - MAX(-CEIL(0.258 * (WL - RL)), 1.964)) * 1.964) + WL - CEIL(tWTR / tCK_avg) + finetWTR;
+
+        wdv = WL;
+        wsv = WL - 2;
+        wev = 0xA + (WL - 14);
+
+        u32 obdlyHigh = 3 / FLOOR(MIN(static_cast<double>(2), tCK_avg * (WL - 7)));
+        u32 obdlyLow  = MAX(WL - FLOOR((126.0 / CEIL(tCK_avg + 8.601))), 0.0);
+        obdly         = PACK_U32_NIBBLE_HIGH_BYTE_LOW(obdlyHigh, obdlyLow);
+
+        pdex2rw  = CEIL((CEIL(12.335 - tCK_avg) + (7.430 / tCK_avg) - CEIL(tCK_avg * 11.361)));
+        tCLKSTOP = FLOOR(MIN(8.488 / tCK_avg, 23.0)) + 8.0;
+
+        const double tMMRI = tRCD + (tCK_avg * 3);
+        pdex2mrr           = tMMRI + 10;
+    }
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/erista/calculate_timings_erista.hpp

@@ -18,6 +18,6 @@
 
 namespace ams::ldr::hoc::pcv::erista {
 
-    void CalculateTimings(double tCK_avg);
+    void CalculateTimings(double tCK_avg, u32 freq);
 
 }

Source/Atmosphere/stratosphere/loader/source/oc/pcv/erista/pcv_erista.cpp

@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) Switch-OC-Suite
+ *
+ * Copyright (c) 2023 hanai3Bi
+ *
+ * Copyright (c) B3711
+ *
+ * Copyright (c) Souldbminer, Lightos_ and Horizon OC Contributors
+ *
+ * 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 "../pcv.hpp"
+#include "../../mtc_timing_value.hpp"
+#include "pcv_erista_cpu.hpp"
+#include "pcv_erista_gpu.hpp"
+#include "pcv_erista_mtc.hpp"
+#include "calculate_timings_erista.hpp"
+
+namespace ams::ldr::hoc::pcv::erista {
+
+    DEFINE_HOOK_PAYLOAD_PTR(HookPayloadData, e_HookPayloadData);
+
+    u32 *nsoStart;
+
+    Result InstallHooks() {
+        R_TRY(Hooks().CheckEnabled());
+
+        R_TRY(Hooks().CopyPayload());
+
+        auto *data = Hooks().BindData(e_HookPayloadData);
+        R_UNLESS(data != nullptr, ldr::ResultHookDataOutOfMemory());
+
+        R_TRY(MtcInstallHooks(data));
+
+        R_SUCCEED();
+    }
+
+    void Patch(uintptr_t mapped_nso, size_t nso_size) {
+        nsoStart = reinterpret_cast<u32 *>(mapped_nso);
+        MtcGenerateFreqTables();
+
+        u32 CpuCvbDefaultMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(CpuCvbTableDefault)->freq);
+        u32 GpuCvbDefaultMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(GpuCvbTableDefault)->freq);
+
+        PatcherEntry<u32> patches[] = {
+            {"CPU Freq Table",     CpuFreqCvbTable<false>, 1, nullptr,  CpuCvbDefaultMaxFreq },
+            {"CPU Volt DVFS",     &CpuVoltDvfs,            1, nullptr,  CpuVminOfficial      },
+            {"CPU Volt Thermals", &CpuVoltThermals,        1, nullptr,  CpuVminOfficial      },
+            {"CPU Volt Dfll",     &CpuVoltDfll,            1, nullptr,  CpuTune0Low          },
+            {"GPU Volt DVFS",     &GpuVoltDVFS,            1, nullptr,  GpuVminOfficial      },
+            {"GPU Volt Thermals", &GpuVoltThermals,        1, nullptr,  GpuVminOfficial      },
+            {"GPU Freq Table",     GpuFreqCvbTable<false>, 1, nullptr,  GpuCvbDefaultMaxFreq },
+            {"GPU Freq Asm",      &GpuFreqMaxAsm,          2,          &GpuMaxClockPatternFn },
+            {"GPU PLL Max",       &GpuFreqPllMax,          1, nullptr,  GpuClkPllMax         },
+            // {"GPU PLL Limit",  &GpuFreqPllLimit,        4, nullptr,  GpuClkPllLimit       },
+            {"MEM Table Asm",     &MemMtcTableAsm,         4,           &MemMtcGetGetTablePatternFn },
+            {"MEM Freq Mtc",      &MemFreqMtcTable,        1, nullptr,  EmcClkOSLimit        },
+            {"MEM Freq Max",      &MemFreqMax,             0, nullptr,  EmcClkOSLimit        },
+            {"MEM Freq PLLM",     &MemFreqPllmLimit,       2, nullptr,  EmcClkPllmLimit      },
+            {"MEM Volt",          &MemVoltHandler,         2, nullptr,  MemVoltHOS           },
+        };
+
+        for (uintptr_t ptr = mapped_nso; ptr <= mapped_nso + nso_size - sizeof(EristaMtcTable); ptr += sizeof(u32)) {
+            u32 *ptr32 = reinterpret_cast<u32 *>(ptr);
+            for (auto &entry : patches) {
+                if (R_SUCCEEDED(entry.SearchAndApply(ptr32))) {
+                    break;
+                }
+            }
+        }
+
+        for (auto &entry : patches) {
+            LOGGING("%s Count: %zu", entry.description, entry.patched_count);
+            if (R_FAILED(entry.CheckResult())) {
+                panic::SmcError(panic::Patch);
+
+                CRASH(entry.description);
+            }
+        }
+
+        if (R_FAILED(InstallHooks())) {
+            panic::SmcError(panic::Patch);
+        }
+    }
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/erista/pcv_erista.hpp

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) Switch-OC-Suite
+ *
+ * Copyright (c) 2023 hanai3Bi
+ *
+ * Copyright (c) Souldbminer, Lightos_ and Horizon OC Contributors
+ *
+ * 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 "../../oc_common.hpp"
+#include "../pcv_common.hpp"
+#include "../pcv_asm.hpp"
+#include "../pcv_hook.hpp"
+
+namespace ams::ldr::hoc::pcv::erista {
+
+    struct HookPayloadData {
+        struct {
+            EristaMtcTable *mtcTable;
+            u32             mtcCount;
+        } mtcTableAsm;
+    };
+    DECLARE_HOOK_PAYLOAD_PTR(HookPayloadData, e_HookPayloadData);
+
+    extern u32 *nsoStart;
+
+    void Patch(uintptr_t mapped_nso, size_t nso_size);
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/erista/pcv_erista_cpu.cpp

@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) Switch-OC-Suite
+ *
+ * Copyright (c) 2023 hanai3Bi
+ *
+ * Copyright (c) B3711
+ *
+ * Copyright (c) Souldbminer, Lightos_ and Horizon OC Contributors
+ *
+ * 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 "../pcv.hpp"
+
+namespace ams::ldr::hoc::pcv::erista {
+
+    Result CpuVoltDvfs(u32 *ptr) {
+        if (std::memcmp(ptr + 5, cpuVoltDvfsPattern, sizeof(cpuVoltDvfsPattern))) {
+            R_THROW(ldr::ResultInvalidCpuMinVolt());
+        }
+
+        if (C.eristaCpuVmin) {
+            PATCH_OFFSET(ptr, C.eristaCpuVmin);
+        }
+
+        if (C.eristaCpuUV) {
+            PATCH_OFFSET(ptr - 2, C.eristaCpuVmin);
+        }
+
+        if (C.eristaCpuMaxVolt) {
+            PATCH_OFFSET(ptr + 5, C.eristaCpuMaxVolt);
+        }
+
+        R_SUCCEED();
+    }
+
+    Result CpuVoltThermals(u32 *ptr) {
+        if (std::memcmp(ptr - 6, cpuVoltageThermalPattern, sizeof(cpuVoltageThermalPattern))) {
+            R_THROW(ldr::ResultInvalidCpuMinVolt());
+        }
+
+        if (C.eristaCpuVmin) {
+            PATCH_OFFSET(    ptr, C.eristaCpuVmin);
+            PATCH_OFFSET(ptr + 3, C.eristaCpuVmin);
+            PATCH_OFFSET(ptr + 6, C.eristaCpuVmin);
+        }
+
+        if (C.eristaCpuMaxVolt) {
+            PATCH_OFFSET(ptr - 2, C.eristaCpuMaxVolt);
+            PATCH_OFFSET(ptr + 1, C.eristaCpuMaxVolt);
+            PATCH_OFFSET(ptr + 4, C.eristaCpuMaxVolt);
+            PATCH_OFFSET(ptr + 7, C.eristaCpuMaxVolt);
+        }
+
+        R_SUCCEED();
+    }
+
+    Result CpuVoltDfll(u32* ptr) {
+        CvbCpuDfllData *entry = reinterpret_cast<CvbCpuDfllData *>(ptr);
+
+        R_UNLESS(entry->tune0_low  == 0xFFEAD0FF, ldr::ResultInvalidCpuVoltDfllEntry());
+        R_UNLESS(entry->tune0_high == 0x0,        ldr::ResultInvalidCpuVoltDfllEntry());
+        R_UNLESS(entry->tune1_low  == 0x0,        ldr::ResultInvalidCpuVoltDfllEntry());
+        R_UNLESS(entry->tune1_high == 0x0,        ldr::ResultInvalidCpuVoltDfllEntry());
+
+        if (!C.eristaCpuUV) {
+            R_SKIP();
+        }
+
+        switch (C.eristaCpuUV) {
+            case 1:
+                PATCH_OFFSET(&(entry->tune0_high), 0xffff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27007ff);
+                break;
+            case 2:
+                PATCH_OFFSET(&(entry->tune0_high), 0xefff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27407ff);
+                break;
+            case 3:
+                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27807ff);
+                break;
+            case 4:
+                PATCH_OFFSET(&(entry->tune0_high), 0xdfdf);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27a07ff);
+                break;
+            case 5:
+                PATCH_OFFSET(&(entry->tune0_high), 0xcfdf);
+                PATCH_OFFSET(&(entry->tune1_high), 0x37007ff);
+                break;
+            default:
+                break;
+        }
+
+        R_SUCCEED();
+    }
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/erista/pcv_erista_cpu.hpp

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) Switch-OC-Suite
+ *
+ * Copyright (c) 2023 hanai3Bi
+ *
+ * Copyright (c) B3711
+ *
+ * Copyright (c) Souldbminer, Lightos_ and Horizon OC Contributors
+ *
+ * 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 "pcv_erista.hpp"
+
+namespace ams::ldr::hoc::pcv::erista {
+
+    constexpr cvb_entry_t CpuCvbTableDefault[] = {
+        // CPU_PLL_CVB_TABLE_ODN
+        {  204000,  {721094}, {                         } },
+        {  306000,  {754040}, {                         } },
+        {  408000,  {786986}, {                         } },
+        {  510000,  {819932}, {                         } },
+        {  612000,  {852878}, {                         } },
+        {  714000,  {885824}, {                         } },
+        {  816000,  {918770}, {                         } },
+        {  918000,  {951716}, {                         } },
+        { 1020000,  {984662}, { -2875621,  358099, -8585} },
+        { 1122000, {1017608}, {   -52225,  104159, -2816} },
+        { 1224000, {1050554}, {  1076868,    8356,  -727} },
+        { 1326000, {1083500}, {  2208191,  -84659,  1240} },
+        { 1428000, {1116446}, {  2519460, -105063,  1611} },
+        { 1581000, {1130000}, {  2889664, -122173,  1834} },
+        { 1683000, {1168000}, {  5100873, -279186,  4747} },
+        { 1785000, {1227500}, {  5100873, -279186,  4747} },
+        {                                                 },
+    };
+
+    constexpr u32 CpuVoltOfficial = 1227;
+    constexpr u32 CpuVminOfficial = 825;
+    constexpr u32 CpuTune0Low     = 0xFFEAD0FF;
+
+    constexpr u32 CpuVoltL4T = 1257'000;
+
+    static const u32 cpuVoltDvfsPattern[] = { 1227, 1000, 100, 1000, 0 };
+    static_assert(sizeof(cpuVoltDvfsPattern) == 0x14, "Invalid cpuVoltDvfsPattern size");
+
+    static const u32 cpuVoltageThermalPattern[] = { 950, 1132, 0, 950, 1227, 0, 825, 1227, 15000, 825, 1170, 60000, 825, 1132, 80000 };
+    static_assert(sizeof(cpuVoltageThermalPattern) == 0x3c, "Invalid cpuVoltageThermalPattern size");
+
+
+    Result CpuVoltDvfs(u32 *ptr);
+    Result CpuVoltThermals(u32 *ptr);
+    Result CpuVoltDfll(u32* ptr);
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/erista/pcv_erista_gpu.cpp

@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) Switch-OC-Suite
+ *
+ * Copyright (c) 2023 hanai3Bi
+ *
+ * Copyright (c) B3711
+ *
+ * Copyright (c) Souldbminer, Lightos_ and Horizon OC Contributors
+ *
+ * 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 "../pcv.hpp"
+#include "../pcv_asm.hpp"
+
+namespace ams::ldr::hoc::pcv::erista {
+
+    Result GpuVoltDVFS(u32 *ptr) {
+        if (std::memcmp(ptr, gpuVoltDvfsPattern, sizeof(gpuVoltDvfsPattern))) {
+            R_THROW(ldr::ResultInvalidGpuDvfs());
+        }
+
+        if (C.eristaGpuVmin) {
+            PATCH_OFFSET(ptr, C.eristaGpuVmin);
+        }
+
+        R_SUCCEED();
+    }
+
+    Result GpuVoltThermals(u32 *ptr) {
+        if (std::memcmp(ptr - 3, gpuVoltThermalPattern, sizeof(gpuVoltThermalPattern))) {
+            R_THROW(ldr::ResultInvalidGpuDvfs());
+        }
+
+        if (C.eristaGpuVmin) {
+            PATCH_OFFSET(ptr,      C.eristaGpuVmin);
+            PATCH_OFFSET(ptr + 3,  C.eristaGpuVmin);
+            PATCH_OFFSET(ptr + 6,  C.eristaGpuVmin);
+            PATCH_OFFSET(ptr + 9,  C.eristaGpuVmin);
+            PATCH_OFFSET(ptr + 12, C.eristaGpuVmin);
+        }
+
+        R_SUCCEED();
+    }
+
+    Result GpuFreqMaxAsm(u32 *ptr32) {
+        // Check if both two instructions match the pattern
+        u32 ins1 = *ptr32, ins2 = *(ptr32 + 1);
+        if (!(asm_compare_no_rd(ins1, GpuAsmPattern[0]) && asm_compare_no_rd(ins2, GpuAsmPattern[1]))) {
+            R_THROW(ldr::ResultInvalidGpuFreqMaxPattern());
+        }
+
+        // Both instructions should operate on the same register
+        u8 rd = asm_get_rd(ins1);
+        if (rd != asm_get_rd(ins2)) {
+            R_THROW(ldr::ResultInvalidGpuFreqMaxPattern());
+        }
+
+        u32 max_clock;
+        switch (C.eristaGpuUV) {
+        case 0:
+            max_clock = GetDvfsTableLastEntry(C.eristaGpuDvfsTable)->freq;
+            break;
+        case 1:
+            max_clock = GetDvfsTableLastEntry(C.eristaGpuDvfsTableSLT)->freq;
+            break;
+        case 2:
+            max_clock = GetDvfsTableLastEntry(C.eristaGpuDvfsTableHiOPT)->freq;
+            break;
+        default:
+            max_clock = GetDvfsTableLastEntry(C.eristaGpuDvfsTable)->freq;
+            break;
+        }
+
+        u32 asm_patch[2] = {
+            asm_set_rd(asm_set_imm16(GpuAsmPattern[0], max_clock), rd),
+            asm_set_rd(asm_set_imm16(GpuAsmPattern[1], max_clock >> 16), rd)
+        };
+
+        PATCH_OFFSET(ptr32,     asm_patch[0]);
+        PATCH_OFFSET(ptr32 + 1, asm_patch[1]);
+
+        R_SUCCEED();
+    }
+
+    Result GpuFreqPllMax(u32 *ptr) {
+        clk_pll_param *entry = reinterpret_cast<clk_pll_param *>(ptr);
+
+        // All zero except for freq
+        for (size_t i = 1; i < sizeof(clk_pll_param) / sizeof(u32); i++) {
+            R_UNLESS(*(ptr + i) == 0, ldr::ResultInvalidGpuPllEntry());
+        }
+
+        // Double the max clk simply
+        u32 max_clk = entry->freq * 2;
+        entry->freq = max_clk;
+        R_SUCCEED();
+    }
+
+    // patch out 1305MHz limit on erista, don't use this!
+    // Result GpuFreqPllLimit(u32 *ptr) {
+    //     u32 prev_freq = *(ptr - 1);
+
+    //     if (prev_freq != 128000 && prev_freq != 1300000 && prev_freq != 76800) {
+    //         R_THROW(ldr::ResultInvalidGpuPllEntry());
+    //     }
+
+    //     PATCH_OFFSET(ptr, 3600000);
+
+    //     R_SUCCEED();
+    // }
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/erista/pcv_erista_gpu.hpp

@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) Switch-OC-Suite
+ *
+ * Copyright (c) 2023 hanai3Bi
+ *
+ * Copyright (c) B3711
+ *
+ * Copyright (c) Souldbminer, Lightos_ and Horizon OC Contributors
+ *
+ * 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 "pcv_erista.hpp"
+
+namespace ams::ldr::hoc::pcv::erista {
+
+    constexpr u32 GpuClkPllLimit  = 2'600'000;
+    constexpr u32 GpuClkPllMax    = 921'600'000;
+    constexpr u32 GpuVminOfficial = 810;
+
+    static const u32 gpuVoltDvfsPattern[] = { 810, 1150, 1000, 100, 1000, 10, };
+    static_assert(sizeof(gpuVoltDvfsPattern) == (sizeof(u32) * 6), "Invalid gpuVoltDvfsPattern");
+
+    static const u32 gpuVoltThermalPattern[] = { 950, 1132, 0, 810, 1132, 15000, 810, 1132, 30000, 810, 1132, 50000, 810, 1132, 70000, 810, 1132, 105000 };
+    static_assert(sizeof(gpuVoltThermalPattern) == 0x48, "Invalid gpuVoltageThermalPattern size");
+
+    /* GPU Max Clock asm Pattern:
+        *
+        * MOV W11, #0x1000 MOV (wide immediate)                0x1000                              0xB (11)
+        *  sf | opc |                 | hw  |                   imm16                        |      Rd
+        * #31 |30 29|28 27 26 25 24 23|22 21|20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5 |4  3  2  1  0
+        *   0 | 1 0 | 1  0  0  1  0  1| 0  0| 0  0  0  1  0  0  0  0  0  0  0  0  0  0  0  0 |0  1  0  1  1
+        *
+        * MOVK W11, #0xE, LSL#16     <shift>16                    0xE                              0xB (11)
+        *  sf | opc |                 | hw  |                   imm16                        |      Rd
+        * #31 |30 29|28 27 26 25 24 23|22 21|20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5 |4  3  2  1  0
+        *   0 | 1 1 | 1  0  0  1  0  1| 0  1| 0  0  0  0  0  0  0  0  0  0  0  0  1  1  1  0 |0  1  0  1  1
+        */
+    inline constexpr u32 GpuAsmPattern[] = { 0x52820000, 0x72A001C0 };
+
+    inline bool GpuMaxClockPatternFn(u32 *ptr32) {
+        return asm_compare_no_rd(*ptr32, GpuAsmPattern[0]);
+    };
+
+    constexpr cvb_entry_t GpuCvbTableDefault[] = {
+        // NA_FREQ_CVB_TABLE
+        {  76800, {}, {  814294, 8144, -940, 808, -21583, 226, } },
+        { 153600, {}, {  856185, 8144, -940, 808, -21583, 226, } },
+        { 230400, {}, {  898077, 8144, -940, 808, -21583, 226, } },
+        { 307200, {}, {  939968, 8144, -940, 808, -21583, 226, } },
+        { 384000, {}, {  981860, 8144, -940, 808, -21583, 226, } },
+        { 460800, {}, { 1023751, 8144, -940, 808, -21583, 226, } },
+        { 537600, {}, { 1065642, 8144, -940, 808, -21583, 226, } },
+        { 614400, {}, { 1107534, 8144, -940, 808, -21583, 226, } },
+        { 691200, {}, { 1149425, 8144, -940, 808, -21583, 226, } },
+        { 768000, {}, { 1191317, 8144, -940, 808, -21583, 226, } },
+        { 844800, {}, { 1233208, 8144, -940, 808, -21583, 226, } },
+        { 921600, {}, { 1275100, 8144, -940, 808, -21583, 226, } },
+        {                                                        },
+    };
+
+    Result GpuVoltDVFS(u32 *ptr);
+    Result GpuVoltThermals(u32 *ptr);
+    Result GpuFreqMaxAsm(u32 *ptr32);
+    Result GpuFreqPllMax(u32 *ptr);
+
+    // patch out 1305MHz limit on erista, don't use this!
+    // Result GpuFreqPllLimit(u32 *ptr);
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/erista/pcv_erista_mtc.cpp

@@ -3,6 +3,8 @@
  *
  * Copyright (c) 2023 hanai3Bi
  *
+ * Copyright (c) B3711
+ *
  * Copyright (c) Souldbminer, Lightos_ and Horizon OC Contributors
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -18,152 +20,21 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "pcv.hpp"
-#include "../mtc_timing_value.hpp"
-#include "../erista/calculate_timings_erista.hpp"
+#include <vector>
+#include "../pcv.hpp"
+#include "../../mtc_timing_value.hpp"
+#include "calculate_timings_erista.hpp"
 
 namespace ams::ldr::hoc::pcv::erista {
 
-    Result CpuVoltDvfs(u32 *ptr) {
-        if (std::memcmp(ptr + 5, cpuVoltDvfsPattern, sizeof(cpuVoltDvfsPattern))) {
-            R_THROW(ldr::ResultInvalidCpuMinVolt());
-        }
+    namespace {
+        std::vector<u32> newEmcList;
 
-        if (C.eristaCpuVmin) {
-            PATCH_OFFSET(ptr, C.eristaCpuVmin);
-        }
-
-        if (C.eristaCpuUV) {
-            PATCH_OFFSET(ptr - 2, C.eristaCpuVmin);
-        }
-
-        if (C.eristaCpuMaxVolt) {
-            PATCH_OFFSET(ptr + 5, C.eristaCpuMaxVolt);
-        }
-
-        R_SUCCEED();
-    }
-
-    Result CpuVoltThermals(u32 *ptr) {
-        if (std::memcmp(ptr - 6, cpuVoltageThermalPattern, sizeof(cpuVoltageThermalPattern))) {
-            R_THROW(ldr::ResultInvalidCpuMinVolt());
-        }
-
-        if (C.eristaCpuVmin) {
-            PATCH_OFFSET(    ptr, C.eristaCpuVmin);
-            PATCH_OFFSET(ptr + 3, C.eristaCpuVmin);
-            PATCH_OFFSET(ptr + 6, C.eristaCpuVmin);
-        }
-
-        if (C.eristaCpuMaxVolt) {
-            PATCH_OFFSET(ptr - 2, C.eristaCpuMaxVolt);
-            PATCH_OFFSET(ptr + 1, C.eristaCpuMaxVolt);
-            PATCH_OFFSET(ptr + 4, C.eristaCpuMaxVolt);
-            PATCH_OFFSET(ptr + 7, C.eristaCpuMaxVolt);
-        }
-
-        R_SUCCEED();
-    }
-
-    Result CpuVoltDfll(u32* ptr) {
-        cvb_cpu_dfll_data *entry = reinterpret_cast<cvb_cpu_dfll_data *>(ptr);
-        R_UNLESS(entry->tune0_low == 0xFFEAD0FF, ldr::ResultInvalidCpuVoltDfllEntry());
-        R_UNLESS(entry->tune0_high == 0x0, ldr::ResultInvalidCpuVoltDfllEntry());
-        R_UNLESS(entry->tune1_low == 0x0, ldr::ResultInvalidCpuVoltDfllEntry());
-        R_UNLESS(entry->tune1_high == 0x0, ldr::ResultInvalidCpuVoltDfllEntry());
-
-        if (!C.eristaCpuUV) {
-            R_SKIP();
-        }
-
-        switch(C.eristaCpuUV) {
-            case 1:
-                PATCH_OFFSET(&(entry->tune0_high), 0xffff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27007ff);
-                break;
-            case 2:
-                PATCH_OFFSET(&(entry->tune0_high), 0xefff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27407ff);
-                break;
-            case 3:
-                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27807ff);
-                break;
-            case 4:
-                PATCH_OFFSET(&(entry->tune0_high), 0xdfdf);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27a07ff);
-                break;
-            case 5:
-                PATCH_OFFSET(&(entry->tune0_high), 0xcfdf);
-                PATCH_OFFSET(&(entry->tune1_high), 0x37007ff);
-                break;
-            default:
-                break;
-        }
-        R_SUCCEED();
-    }
-
-    Result GpuVoltDVFS(u32 *ptr) {
-        if (std::memcmp(ptr, gpuVoltDvfsPattern, sizeof(gpuVoltDvfsPattern))) {
-            R_THROW(ldr::ResultInvalidGpuDvfs());
-        }
-
-        if (C.eristaGpuVmin) {
-            PATCH_OFFSET(ptr, C.eristaGpuVmin);
-        }
-
-        R_SUCCEED();
-    }
-
-    Result GpuVoltThermals(u32 *ptr) {
-        if (std::memcmp(ptr - 3, gpuVoltThermalPattern, sizeof(gpuVoltThermalPattern))) {
-            R_THROW(ldr::ResultInvalidGpuDvfs());
-        }
-
-        if (C.eristaGpuVmin) {
-            PATCH_OFFSET(ptr    , C.eristaGpuVmin);
-            PATCH_OFFSET(ptr + 3, C.eristaGpuVmin);
-            PATCH_OFFSET(ptr + 6, C.eristaGpuVmin);
-            PATCH_OFFSET(ptr + 9, C.eristaGpuVmin);
-            PATCH_OFFSET(ptr + 12, C.eristaGpuVmin);
-        }
-
-        R_SUCCEED();
-    }
-
-    Result GpuFreqMaxAsm(u32 *ptr32) {
-        // Check if both two instructions match the pattern
-        u32 ins1 = *ptr32, ins2 = *(ptr32 + 1);
-        if (!(asm_compare_no_rd(ins1, asm_pattern[0]) && asm_compare_no_rd(ins2, asm_pattern[1])))
-            R_THROW(ldr::ResultInvalidGpuFreqMaxPattern());
-
-        // Both instructions should operate on the same register
-        u8 rd = asm_get_rd(ins1);
-        if (rd != asm_get_rd(ins2))
-            R_THROW(ldr::ResultInvalidGpuFreqMaxPattern());
-
-        u32 max_clock;
-        switch (C.eristaGpuUV) {
-        case 0:
-            max_clock = GetDvfsTableLastEntry(C.eristaGpuDvfsTable)->freq;
-            break;
-        case 1:
-            max_clock = GetDvfsTableLastEntry(C.eristaGpuDvfsTableSLT)->freq;
-            break;
-        case 2:
-            max_clock = GetDvfsTableLastEntry(C.eristaGpuDvfsTableHiOPT)->freq;
-            break;
-        default:
-            max_clock = GetDvfsTableLastEntry(C.eristaGpuDvfsTable)->freq;
-            break;
-        }
-        u32 asm_patch[2] = {
-            asm_set_rd(asm_set_imm16(asm_pattern[0], max_clock), rd),
-            asm_set_rd(asm_set_imm16(asm_pattern[1], max_clock >> 16), rd)};
-        PATCH_OFFSET(ptr32, asm_patch[0]);
-        PATCH_OFFSET(ptr32 + 1, asm_patch[1]);
-
-        R_SUCCEED();
+        struct {
+            u32            *getEristaMtcTableFnSite = nullptr;
+            EristaMtcTable *mtcTable                = nullptr;
+            bool            foundMtcTablePattern    = false;
+        } getMtcTableCache;
     }
 
     /* Note: This does not have proper timings, so base latency adjustment will not work.             */
@@ -204,13 +75,15 @@ namespace ams::ldr::hoc::pcv::erista {
         }
 
         u32 trefbw = refresh_raw + 0x40;
-        trefbw = MIN(trefbw, static_cast<u32>(0x3FFF));
+        trefbw     = MIN(trefbw, static_cast<u32>(0x3FFF));
 
-        CalculateTimings(tCK_avg);
+        const u32 dyn_self_ref_control = (static_cast<u32>(7605.0 / tCK_avg) + 260) | (table->burst_regs.emc_dyn_self_ref_control & 0xffff0000);
+
+        CalculateTimings(tCK_avg, table->rate_khz);
 
         WRITE_PARAM_ALL_REG(table, emc_rd_rcd, GET_CYCLE_CEIL(tRCD));
         WRITE_PARAM_ALL_REG(table, emc_wr_rcd, GET_CYCLE_CEIL(tRCD));
-        WRITE_PARAM_ALL_REG(table, emc_rc, MIN(GET_CYCLE_CEIL(tRC), static_cast<u32>(0xB8)));
+        WRITE_PARAM_ALL_REG(table, emc_rc, MIN(GET_CYCLE_CEIL(tRC), static_cast<u32>(0xB9)));
         WRITE_PARAM_ALL_REG(table, emc_ras, MIN(GET_CYCLE_CEIL(tRAS), static_cast<u32>(0x7F)));
         WRITE_PARAM_ALL_REG(table, emc_rrd, GET_CYCLE_CEIL(tRRD));
         WRITE_PARAM_ALL_REG(table, emc_rfcpb, GET_CYCLE_CEIL(tRFCpb));
@@ -233,7 +106,6 @@ namespace ams::ldr::hoc::pcv::erista {
         WRITE_PARAM_ALL_REG(table, emc_refresh, refresh_raw);
         WRITE_PARAM_ALL_REG(table, emc_pre_refresh_req_cnt, refresh_raw / 4);
         WRITE_PARAM_ALL_REG(table, emc_trefbw, trefbw);
-        const u32 dyn_self_ref_control = (static_cast<u32>(7605.0 / tCK_avg) + 260) | (table->burst_regs.emc_dyn_self_ref_control & 0xffff0000);
         WRITE_PARAM_ALL_REG(table, emc_dyn_self_ref_control, dyn_self_ref_control);
         WRITE_PARAM_ALL_REG(table, emc_pdex2wr, pdex2rw);
         WRITE_PARAM_ALL_REG(table, emc_pdex2rd, pdex2rw);
@@ -246,16 +118,17 @@ namespace ams::ldr::hoc::pcv::erista {
         WRITE_PARAM_ALL_REG(table, emc_rw2pden, tWTPDEN);
 
         /* Accept imperfection or prepare for suffering. */
+        // #if defined(AMS_BUILD_FOR_AUDITING) || defined(AMS_BUILD_FOR_DEBUGGING)
         // WRITE_PARAM_ALL_REG(table, emc_einput, einput);
         // WRITE_PARAM_ALL_REG(table, emc_einput_duration, einput_duration);
-        // WRITE_PARAM_ALL_REG(table, emc_obdly, obdly);
+        WRITE_PARAM_ALL_REG(table, emc_obdly, obdly);
         // WRITE_PARAM_ALL_REG(table, emc_ibdly, ibdly);
         // WRITE_PARAM_ALL_REG(table, emc_wdv_mask, wdv);
         // WRITE_PARAM_ALL_REG(table, emc_quse_width, quse_width);
         // WRITE_PARAM_ALL_REG(table, emc_quse, quse);
-        // WRITE_PARAM_ALL_REG(table, emc_wdv, wdv);
-        // WRITE_PARAM_ALL_REG(table, emc_wsv, wsv);
-        // WRITE_PARAM_ALL_REG(table, emc_wev, wev);
+        WRITE_PARAM_ALL_REG(table, emc_wdv, wdv);
+        WRITE_PARAM_ALL_REG(table, emc_wsv, wsv);
+        WRITE_PARAM_ALL_REG(table, emc_wev, wev);
         // WRITE_PARAM_ALL_REG(table, emc_qrst, qrst);
         // WRITE_PARAM_ALL_REG(table, emc_tr_qrst, qrst);
         // WRITE_PARAM_ALL_REG(table, emc_qsafe, qsafe);
@@ -268,22 +141,21 @@ namespace ams::ldr::hoc::pcv::erista {
         // WRITE_PARAM_ALL_REG(table, emc_rdv_early_mask, rdv);
         // WRITE_PARAM_ALL_REG(table, emc_rdv_mask, rdv + 2);
         // WRITE_PARAM_ALL_REG(table, emc_tr_rdv, rdv);
-        // ams::ldr::hoc::pcv::mariko::CalculateMrw2();
-        // table->emc_mrw2 = (table->emc_mrw2 & ~0xFFu) | static_cast<u32>(mrw2);
+        table->emc_mrw2 = (table->emc_mrw2 & ~0xFFu) | static_cast<u32>(mrw2);
         // table->dram_timings.rl = RL;
+        // #endif
 
-        /* This needs some clean up. */
         constexpr double MC_ARB_DIV = 4.0;
-        constexpr u32 MC_ARB_SFA = 2;
+        constexpr u32 MC_ARB_SFA    = 2;
 
-        table->burst_mc_regs.mc_emem_arb_cfg          = table->rate_khz             / (33.3 * 1000) / MC_ARB_DIV;
-        table->burst_mc_regs.mc_emem_arb_timing_rcd   = CEIL(GET_CYCLE_CEIL(tRCD)   / MC_ARB_DIV) - 2;
-        table->burst_mc_regs.mc_emem_arb_timing_rp    = CEIL(GET_CYCLE_CEIL(tRPpb)  / MC_ARB_DIV) - 1;
-        table->burst_mc_regs.mc_emem_arb_timing_rc    = CEIL(GET_CYCLE_CEIL(tRC)    / MC_ARB_DIV) - 1;
-        table->burst_mc_regs.mc_emem_arb_timing_ras   = CEIL(GET_CYCLE_CEIL(tRAS)   / MC_ARB_DIV) - 2;
-        table->burst_mc_regs.mc_emem_arb_timing_faw   = CEIL(GET_CYCLE_CEIL(tFAW)   / MC_ARB_DIV) - 1;
-        table->burst_mc_regs.mc_emem_arb_timing_rrd   = CEIL(GET_CYCLE_CEIL(tRRD)   / MC_ARB_DIV) - 1;
-        table->burst_mc_regs.mc_emem_arb_timing_rfcpb = CEIL(GET_CYCLE_CEIL(tRFCpb) / MC_ARB_DIV) - 1;
+        table->burst_mc_regs.mc_emem_arb_cfg            = table->rate_khz             / (33.3 * 1000) / MC_ARB_DIV;
+        table->burst_mc_regs.mc_emem_arb_timing_rcd     = CEIL(GET_CYCLE_CEIL(tRCD)   / MC_ARB_DIV) - 2;
+        table->burst_mc_regs.mc_emem_arb_timing_rp      = CEIL(GET_CYCLE_CEIL(tRPpb)  / MC_ARB_DIV) - 1;
+        table->burst_mc_regs.mc_emem_arb_timing_rc      = CEIL(GET_CYCLE_CEIL(tRC)    / MC_ARB_DIV) - 1;
+        table->burst_mc_regs.mc_emem_arb_timing_ras     = CEIL(GET_CYCLE_CEIL(tRAS)   / MC_ARB_DIV) - 2;
+        table->burst_mc_regs.mc_emem_arb_timing_faw     = CEIL(GET_CYCLE_CEIL(tFAW)   / MC_ARB_DIV) - 1;
+        table->burst_mc_regs.mc_emem_arb_timing_rrd     = CEIL(GET_CYCLE_CEIL(tRRD)   / MC_ARB_DIV) - 1;
+        table->burst_mc_regs.mc_emem_arb_timing_rfcpb   = CEIL(GET_CYCLE_CEIL(tRFCpb) / MC_ARB_DIV) - 1;
         table->burst_mc_regs.mc_emem_arb_timing_rap2pre = CEIL(tR2P / MC_ARB_DIV);
         table->burst_mc_regs.mc_emem_arb_timing_wap2pre = CEIL(tW2P / MC_ARB_DIV) + MC_ARB_SFA;
 
@@ -307,7 +179,16 @@ namespace ams::ldr::hoc::pcv::erista {
         da_covers |= (w_cover << 16);
         table->burst_mc_regs.mc_emem_arb_da_covers = da_covers;
 
-        table->burst_mc_regs.mc_emem_arb_misc0 = (table->burst_mc_regs.mc_emem_arb_misc0 & 0xFFE08000) | (table->burst_mc_regs.mc_emem_arb_timing_rc + 1);
+        constexpr u32 AtomsPerDvfsPulse             = 0x7;
+        constexpr u32 McEmcSameFreq                 = 0x0;
+        constexpr u32 ExpiringSoonSlackThreshold    = 0xC;
+        const     u32 priorityInversionIsoThreshold = GET_CYCLE_CEIL(7.5);
+        constexpr u32 EmcReqB2bXfer                 = 0x0;
+        const     u32 priorityInversionThreshold    = GET_CYCLE_CEIL(22.5);
+        const     u32 bc2aaHoldoffThreshold         = table->burst_mc_regs.mc_emem_arb_timing_rc + 1;
+
+        const u32 mc_emem_arb_misc0 = (AtomsPerDvfsPulse << 28) | (McEmcSameFreq << 27) | (ExpiringSoonSlackThreshold << 21) | (priorityInversionIsoThreshold << 16) | (EmcReqB2bXfer << 15) | (priorityInversionThreshold << 8) | (bc2aaHoldoffThreshold << 0);
+        table->burst_mc_regs.mc_emem_arb_misc0 = mc_emem_arb_misc0;
 
         u32 mpcorer_ptsa_rate = MIN(static_cast<u32>(227), (table->rate_khz / 1600000) * 208);
         table->la_scale_regs.mc_mll_mpcorer_ptsa_rate = mpcorer_ptsa_rate;
@@ -319,8 +200,8 @@ namespace ams::ldr::hoc::pcv::erista {
         table->la_scale_regs.mc_ptsa_grant_decrement = grant_decrement;
 
         constexpr u32 MaskHigh = 0xFF00FFFF;
-        constexpr u32 Mask2 = 0xFFFFFF00;
-        constexpr u32 Mask3 = 0xFF00FF00;
+        constexpr u32 Mask2    = 0xFFFFFF00;
+        constexpr u32 Mask3    = 0xFF00FF00;
 
         const u32 allowance1 = static_cast<u32>(0x32000 / (table->rate_khz / 0x3E8)) & 0xFF;
         const u32 allowance2 = static_cast<u32>(0x9C40  / (table->rate_khz / 0x3E8)) & 0xFF;
@@ -348,135 +229,251 @@ namespace ams::ldr::hoc::pcv::erista {
         table->la_scale_regs.mc_latency_allowance_hc_1      =              (table->la_scale_regs.mc_latency_allowance_hc_1      & Mask2)    |  allowance1;
         table->la_scale_regs.mc_latency_allowance_vi2_0     =              (table->la_scale_regs.mc_latency_allowance_vi2_0     & Mask2)    |  allowance1;
 
-        table->dram_timings.t_rp = tRFCpb;
-        table->dram_timings.t_rfc = tRFCab;
-        table->emc_cfg_2 = 0x11083D;
-        table->min_volt = std::min(static_cast<u32>(1050), 900 + C.emcDvbShift * 25);
+        table->dram_timings.t_rp  = tRP_values[0];
+        const u32 tRFCabStock     = tRFC_values[0] * 2;
+        table->dram_timings.t_rfc = tRFCabStock;
+
+        table->emc_mrw2        = (table->emc_mrw2 & ~0xFFu) | static_cast<u32>(mrw2);
+        table->emc_mrw         = (table->emc_mrw  & ~0x70u) | 0x40; /* nWR */
+        table->emc_cfg_2       = 0x11083D;
+        table->min_volt        = std::clamp(900 + (C.emcDvbShift * 25), 900, 1050);
+    }
+
+    /* TODO: Template this */
+    Result VerifyMtcTable(EristaMtcTable *tableStart, u32 expectedFreq) {
+        R_UNLESS(tableStart->rate_khz == expectedFreq,  ldr::ResultInvalidMtcTable());
+        R_UNLESS(tableStart->rev      == MTC_TABLE_REV, ldr::ResultInvalidMtcTable());
+
+        R_SUCCEED();
+    }
+
+    /* TODO: Template this */
+    Result MtcValidateAllTables(EristaMtcTable *tableStart, const u32 *validationList, u32 tableCount) {
+        for (u32 i = 0; i < tableCount; ++i) {
+            R_TRY(VerifyMtcTable(&tableStart[i], validationList[i]));
+        }
+
+        R_SUCCEED();
+    }
+
+    /* TODO: Put this into common. */
+    DramId GetDramId() {
+        u64 id64;
+        splGetConfig(SplConfigItem_DramId, &id64);
+        return static_cast<DramId>(id64);
+    }
+
+    MtcTableIndex GetMtcDramIndex(DramId dramId) {
+        for (u32 i = 0; i < std::size(mtcIndexTable); ++i) {
+            if (mtcIndexTable[i].dramId == dramId) {
+                return mtcIndexTable[i].index;
+            }
+        }
+
+        return MtcTableIndex_Invalid;
+    }
+
+    NORETURN void AbortInvalidMtc(const char *crashMsg) {
+        panic::SmcError(panic::Emc);
+        CRASH(crashMsg);
+    }
+
+    u32 GetMtcOffset(MtcTableIndex index) {
+        if (index < T210SdevEmcDvfsTableS6gb01) {
+            return index * erista::MtcFullTableSize;
+        }
+
+        /* Account for the weird in between mariko table. */
+        return index * erista::MtcFullTableSize + mariko::MtcFullTableSize;
+    }
+
+    void PrepareMtcMemoryRegion(u8 *firstTable, EristaMtcTable *usedTable) {
+        /* Move the table, this is nessasary for NLE */
+        memmove(firstTable, usedTable, erista::MtcFullTableSize);
+
+        /* Clear all other tables. */
+        /* The used table is excluded. */
+        constexpr size_t RemainingRegionSize = (mariko::MtcFullTableSize) * (mariko::MtcFullTableCount) + (erista::MtcFullTableSize * (erista::MtcFullTableCount - 1));
+        memset(firstTable + erista::MtcFullTableSize, 0, RemainingRegionSize);
+    }
+
+    void MtcExtendTables(EristaMtcTable *table) {
+        for (u32 i = erista::MtcTableCountDefault; i < newEmcList.size(); ++i) {
+            std::memcpy(&table[i], &table[i - 1], sizeof(EristaMtcTable));
+            table[i].rate_khz = newEmcList[i];
+        }
+    }
+
+    /* The silicon instructs; the children obey... */
+    void MtcGenerateFreqTables() {
+        newEmcList.clear();
+        newEmcList.reserve(DvfsTableEntryCount);
+        newEmcList.insert(newEmcList.end(), std::begin(EmcListDefault), std::end(EmcListDefault));
+
+        if (C.eristaEmcMaxClock <= EmcClkOSLimit) {
+            return;
+        }
+
+        /* This is scuffed, but Eristas step rate is... weird? */
+        /* 1766MHz seems to cause crashes with other freqs near it... why is anyones guess... */
+        u32 freqsLow[]                = { 1633000, 1666000, 1700000, 1733000, 1800000, 1833000, 1862400, };
+        constexpr size_t freqsLowSize = std::size(freqsLow);
+
+        for (size_t i = 0; i < freqsLowSize; ++i) {
+            if (freqsLow[i] <= C.eristaEmcMaxClock) {
+                newEmcList.push_back(freqsLow[i]);
+            } else {
+                break;
+            }
+        }
+
+        if (C.eristaEmcMaxClock <= freqsLow[freqsLowSize - 1]) {
+            return;
+        }
+
+        /* High range. */
+        constexpr u32 StepRate = 38400;
+        while (newEmcList.back() + StepRate < C.eristaEmcMaxClock) {
+            newEmcList.push_back(newEmcList.back() + StepRate);
+        }
+
+        if (newEmcList.back() != C.eristaEmcMaxClock) {
+            newEmcList.push_back(static_cast<u32>(C.eristaEmcMaxClock));
+        }
+
+        constexpr u32 PllmToggleFrequency = 19200;
+
+        /* A step of 19.2khz will cause hangs, crashes and other weirdness. */
+        /* Why? ¯\_(ツ)_/¯ */
+        if (C.eristaEmcMaxClock - newEmcList[newEmcList.size() - 2] <= PllmToggleFrequency) {
+            newEmcList.erase(newEmcList.begin() + newEmcList.size() - 2);
+        }
+
+        newEmcList.resize(std::min(newEmcList.size(), DvfsTableEntryLimit));
     }
 
-    /* Probably more intuitive to point to 40800 rather than 1600000, but oh well. */
     Result MemFreqMtcTable(u32 *ptr) {
-        if (GET_MAX_OF_ARR(maxEmcClocks) <= EmcClkOSLimit) {
+        static const DramId dramId = [] {
+            DramId id = GetDramId();
+            return id;
+        }();
+
+        static const MtcTableIndex mtcIndex = [] {
+            MtcTableIndex idx = GetMtcDramIndex(dramId);
+            /* If for some reason this happens, there is no chance of recovering this. */
+            if (idx == MtcTableIndex_Invalid) {
+                AbortInvalidMtc("Invalid dramId");
+            }
+            return idx;
+        }();
+
+        static const u32 mtcOffset = GetMtcOffset(mtcIndex);
+
+        constexpr u32 StartAdjustment = offsetof(EristaMtcTable, rate_khz) + sizeof(EristaMtcTable) * (erista::MtcTableCountDefault - 1);
+        u8 *startPtr = reinterpret_cast<u8 *>(ptr) - StartAdjustment;
+
+        EristaMtcTable *table = reinterpret_cast<EristaMtcTable *>(startPtr + mtcOffset);
+
+        R_TRY(MtcValidateAllTables(table, EmcListDefault, EmcListSizeDefault));
+
+        PrepareMtcMemoryRegion(startPtr, table);
+        table = reinterpret_cast<EristaMtcTable *>(startPtr);
+
+        if (R_FAILED(MtcValidateAllTables(table, EmcListDefault, EmcListSizeDefault))) {
+            AbortInvalidMtc("Failed mtc validation");
+        }
+
+        /* Cache the table for hooks. */
+        getMtcTableCache.mtcTable = table;
+
+        if (C.eristaEmcMaxClock <= EmcClkOSLimit) {
             R_SKIP();
         }
 
-        u32 khz_list[] = { 40800, 68000, 102000, 204000, 408000, 665600, 800000, 1065600, 1331200, 1600000 };
-        std::sort(maxEmcClocks, maxEmcClocks + std::size(maxEmcClocks));
-        u32 khz_list_size = std::size(khz_list);
+        MtcExtendTables(table);
 
-        // Generate list for mtc table pointers
-        EristaMtcTable *table_list[khz_list_size];
-        for (u32 i = 0; i < khz_list_size; i++) {
-            u32 mtcIndex = khz_list_size - 1 - i;
-            u8 *table = reinterpret_cast<u8 *>(ptr) - offsetof(EristaMtcTable, rate_khz) - i * sizeof(EristaMtcTable);
-            table_list[mtcIndex] = reinterpret_cast<EristaMtcTable *>(table);
-            R_UNLESS(table_list[mtcIndex]->rate_khz == khz_list[mtcIndex], ldr::ResultInvalidMtcTable());
-            R_UNLESS(table_list[mtcIndex]->rev == MTC_TABLE_REV, ldr::ResultInvalidMtcTable());
+        if (R_FAILED(MtcValidateAllTables(table, newEmcList.data(), newEmcList.size()))) {
+            AbortInvalidMtc("Failed mtc validation");
         }
 
-        /* If we oc ram at all, tables are always shifted by at least 1. */
-        u32 tableShifts = 1;
-        for (u32 i = 0; i < std::size(maxEmcClocks) - 1; ++i) {
-            /* Duplicated mtc tables may cause pcv to not select frequencies properly, causing issues. */
-            if (maxEmcClocks[i] != maxEmcClocks[i + 1] && maxEmcClocks[i] > EmcClkOSLimit) {
-                ++tableShifts;
-            } else {
-                maxEmcClocks[i] = 0;
-            }
-        }
-
-        /* Erista has extra, useless mtc tables, such as 40.8 Mhz, overwrite them to make room for oc freqs. */
-        /* More than 3 tables can be overwritten, but 3 is plenty. */
-        std::memmove(table_list[0], table_list[tableShifts], sizeof(EristaMtcTable) * (khz_list_size - tableShifts));
-
-        /* Since we're not scaling r/w latency properly on Erista, we first overwrite the tables with the 1600 MHz table before scaling it. */
-        for (u32 i = 0; i < tableShifts; ++i) {
-            std::memcpy(table_list[khz_list_size - i - 1], table_list[khz_list_size - tableShifts - 1], sizeof(EristaMtcTable));
-        }
-
-        for (u32 i = tableShifts, j = 0; i > 0 && j < std::size(maxEmcClocks); ++j) {
-            if (!maxEmcClocks[j]) {
-                continue;
-            }
-
-            table_list[khz_list_size - i]->rate_khz = maxEmcClocks[j];
-            MemMtcTableAutoAdjust(table_list[khz_list_size - i]);
-            --i;
+        for (u32 i = erista::MtcTableCountDefault; i < newEmcList.size(); ++i) {
+            MemMtcTableAutoAdjust(&table[i]);
         }
 
         R_SUCCEED();
     }
 
     Result MemFreqMax(u32 *ptr) {
-        if (GET_MAX_OF_ARR(maxEmcClocks) <= EmcClkOSLimit) {
+        if (C.eristaEmcMaxClock <= EmcClkOSLimit) {
             R_SKIP();
         }
 
-        PATCH_OFFSET(ptr, GET_MAX_OF_ARR(maxEmcClocks));
+        PATCH_OFFSET(ptr, C.eristaEmcMaxClock);
 
         R_SUCCEED();
     }
 
-    Result GpuFreqPllMax(u32 *ptr) {
-        clk_pll_param *entry = reinterpret_cast<clk_pll_param *>(ptr);
+    HOOK_PAYLOAD_FN EristaMtcTable *GetEristaMtcTableImpl(u32 *count) {
+        const HookPayloadData *data = HOOK_PAYLOAD_PTR(HookPayloadData, e_HookPayloadData);
 
-        // All zero except for freq
-        for (size_t i = 1; i < sizeof(clk_pll_param) / sizeof(u32); i++) {
-            R_UNLESS(*(ptr + i) == 0, ldr::ResultInvalidGpuPllEntry());
-        }
+        *count = data->mtcTableAsm.mtcCount;
+        return data->mtcTableAsm.mtcTable;
+    }
+
+    Result MtcInstallHooks(HookPayloadData *data) {
+        R_UNLESS(getMtcTableCache.getEristaMtcTableFnSite != nullptr && getMtcTableCache.mtcTable != nullptr, ldr::ResultInvalidMtcTablePattern());
+
+        /* Copy the data to the payload. */
+        data->mtcTableAsm.mtcTable = reinterpret_cast<EristaMtcTable *>(Hooks().ToVa(getMtcTableCache.mtcTable));
+        data->mtcTableAsm.mtcCount = newEmcList.size();
+
+        R_TRY(INSTALL_IMPL_HOOK(getMtcTableCache.getEristaMtcTableFnSite, GetEristaMtcTableImpl));
 
-        // Double the max clk simply
-        u32 max_clk = entry->freq * 2;
-        entry->freq = max_clk;
         R_SUCCEED();
     }
 
-    // patch out 1305MHz limit on erista, don't use this!
-    // Result GpuFreqPllLimit(u32 *ptr) {
-    //     u32 prev_freq = *(ptr - 1);
+    Result MemMtcTableAsm(u32 *ptr) {
+        /* Return if the pattern was already found. */
+        /* This pattern happens multiple times in this function., we only need to find it once. */
+        R_UNLESS(!getMtcTableCache.foundMtcTablePattern, ldr::ResultInvalidMtcTablePattern());
 
-    //     if (prev_freq != 128000 && prev_freq != 1300000 && prev_freq != 76800) {
-    //         R_THROW(ldr::ResultInvalidGpuPllEntry());
-    //     }
+        /* This is a mess but the compiler made this painful to patch so we must do it this way */
+        constexpr u32 AddrpOffset  = 1;
+        constexpr u32 MovOffset    = 7;
+        constexpr u32 BlOffset     = 5;
+        constexpr u32 MovOffsetOld = 8;
 
-    //     PATCH_OFFSET(ptr, 3600000);
+        /* Ensure we don't dereference memory before nso start. */
+        R_UNLESS(ptr - MovOffset >= nsoStart, ldr::ResultInvalidMtcTablePattern());
 
-    //     R_SUCCEED();
-    // }
+        u32 adrp = *(ptr - AddrpOffset);
+        R_UNLESS(AsmCompareAdrpNoImm(adrp, MtcAdrpAsm), ldr::ResultInvalidMtcTablePattern());
 
-    void Patch(uintptr_t mapped_nso, size_t nso_size) {
-        PatcherEntry<u32> patches[] = {
-            {"CPU Freq Table", CpuFreqCvbTable<false>, 1, nullptr, static_cast<u32>(GetDvfsTableLastEntry(CpuCvbTableDefault)->freq)},
-            {"CPU Volt DVFS", &CpuVoltDvfs, 1, nullptr, CpuVminOfficial},
-            {"CPU Volt Thermals", &CpuVoltThermals, 1, nullptr, CpuVminOfficial},
-            {"CPU Volt Dfll", &CpuVoltDfll, 1, nullptr, 0xFFEAD0FF},
-            {"GPU Volt DVFS", &GpuVoltDVFS, 1, nullptr, GpuVminOfficial},
-            {"GPU Volt Thermals", &GpuVoltThermals, 1, nullptr, GpuVminOfficial},
-            {"GPU Freq Table", GpuFreqCvbTable<false>, 1, nullptr, static_cast<u32>(GetDvfsTableLastEntry(GpuCvbTableDefault)->freq)},
-            {"GPU Freq Asm", &GpuFreqMaxAsm, 2, &GpuMaxClockPatternFn},
-            {"GPU PLL Max", &GpuFreqPllMax, 1, nullptr, GpuClkPllMax},
-            // {"GPU PLL Limit", &GpuFreqPllLimit, 4, nullptr, GpuClkPllLimit},
-            {"MEM Freq Mtc", &MemFreqMtcTable, 0, nullptr, EmcClkOSLimit},
-            {"MEM Freq Max", &MemFreqMax, 0, nullptr, EmcClkOSLimit},
-            {"MEM Freq PLLM", &MemFreqPllmLimit, 2, nullptr, EmcClkPllmLimit},
-            {"MEM Volt", &MemVoltHandler, 2, nullptr, MemVoltHOS},
-        };
+        /* Check for the branch instruction above the cbz to ensure we are patching the right location*/
+        u32 bl = *(ptr - BlOffset);
+        R_UNLESS(AsmBlCompareOpcodeOnly(bl, MtcBlIns), ldr::ResultInvalidMtcTablePattern());
 
-        for (uintptr_t ptr = mapped_nso; ptr <= mapped_nso + nso_size - sizeof(EristaMtcTable); ptr += sizeof(u32)) {
-            u32 *ptr32 = reinterpret_cast<u32 *>(ptr);
-            for (auto &entry : patches) {
-                if (R_SUCCEEDED(entry.SearchAndApply(ptr32))) {
-                    break;
-                }
-            }
+        /* Check for the mov that actually sets the mtc table count. */
+        u32 mov = *(ptr - MovOffset);
+        bool foundMov = false;
+        foundMov = asm_compare_no_rd(mov, MtcMovAsm);
+
+        if (!foundMov) {
+            mov = *(ptr + MovOffsetOld);
+            /* Check old firmware offset. */
+            foundMov = asm_compare_no_rd(mov, MtcMovAsm);
         }
 
-        for (auto &entry : patches) {
-            LOGGING("%s Count: %zu", entry.description, entry.patched_count);
-            if (R_FAILED(entry.CheckResult())) {
-                CRASH(entry.description);
-            }
-        }
+        R_UNLESS(foundMov, ldr::ResultInvalidMtcTablePattern());
+
+        constexpr u32 PrologueWindow = 140;
+        u32 *functionPrologue = FindFnPrologue(ptr, PrologueWindow, nsoStart);
+        R_UNLESS(functionPrologue != nullptr, ldr::ResultInvalidMtcTablePattern());
+
+        getMtcTableCache.getEristaMtcTableFnSite = functionPrologue;
+        getMtcTableCache.foundMtcTablePattern = true;
+
+        R_SUCCEED();
     }
 
 }

Source/Atmosphere/stratosphere/loader/source/oc/pcv/erista/pcv_erista_mtc.hpp

@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) Switch-OC-Suite
+ *
+ * Copyright (c) 2023 hanai3Bi
+ *
+ * Copyright (c) B3711
+ *
+ * Copyright (c) Souldbminer, Lightos_ and Horizon OC Contributors
+ *
+ * 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 "pcv_erista.hpp"
+#include "../../mtc_timing_table.hpp"
+
+namespace ams::ldr::hoc::pcv::erista {
+
+    constexpr u32 EmcListDefault[]   = { 40800, 68000, 102000, 204000, 408000, 665600, 800000, 1065600, 1331200, 1600000, };
+    constexpr u32 EmcListSizeDefault = std::size(EmcListDefault);
+    constexpr u32 EmcListEndDefault  = EmcListSizeDefault - 1;
+
+    constexpr u32 MemVoltHOS      = 1125'000;
+    constexpr u32 EmcClkPllmLimit = 1866'000'000;
+
+    constexpr u32 MTC_TABLE_REV        = 7;
+    constexpr u32 MtcTableCountDefault = 10;
+
+    constexpr size_t MtcFullTableSize  = sizeof(EristaMtcTable) * MtcTableCountDefault;
+    constexpr u32 MtcFullTableCount    = 3;
+
+    /* These dramids were copied from Hekate -- see /bdk/mem/sdram.h */
+    enum DramId {
+        ICOSA_4GB_SAMSUNG_K4F6E304HB_MGCH        = 0,
+        ICOSA_4GB_HYNIX_H9HCNNNBPUMLHR_NLE       = 1,
+        ICOSA_4GB_MICRON_MT53B512M32D2NP_062_WTC = 2,
+        ICOSA_6GB_SAMSUNG_K4FHE3D4HM_MGCH        = 4,
+        ICOSA_8GB_SAMSUNG_K4FBE3D4HM_MGXX        = 7,
+    };
+
+    enum MtcTableIndex {
+        T210SdevEmcDvfsTableS4gb01 = 0, /* HB-MGCH, WT:C */
+        T210SdevEmcDvfsTableS6gb01 = 1, /* HM-MGCH */
+        T210SdevEmcDvfsTableH4gb01 = 2, /* HR-NLE  */
+        MtcTableIndex_Invalid      = 3,
+    };
+
+    struct MtcDramIndex {
+        DramId dramId;
+        MtcTableIndex index;
+    };
+
+    /* TODO: Test 6gb and 8gb. */
+    const inline MtcDramIndex mtcIndexTable[] = {
+        { ICOSA_4GB_SAMSUNG_K4F6E304HB_MGCH,        T210SdevEmcDvfsTableS4gb01, },
+        { ICOSA_4GB_MICRON_MT53B512M32D2NP_062_WTC, T210SdevEmcDvfsTableS4gb01, },
+        { ICOSA_6GB_SAMSUNG_K4FHE3D4HM_MGCH,        T210SdevEmcDvfsTableS6gb01, },
+        { ICOSA_8GB_SAMSUNG_K4FBE3D4HM_MGXX,        T210SdevEmcDvfsTableS6gb01, },
+        { ICOSA_4GB_HYNIX_H9HCNNNBPUMLHR_NLE,       T210SdevEmcDvfsTableH4gb01, },
+    };
+
+    constexpr u32 MtcBrAsm   = 0xD61F0140;
+    constexpr u32 MtcMovAsm  = 0x52800148;
+    constexpr u32 MtcAdrpAsm = 0xD0000081;
+    constexpr u32 MtcBlIns = 0x97ffae64;
+    constexpr u32 MtcAddAsm = 0x91131821;
+
+    ALWAYS_INLINE bool MemMtcGetGetTablePatternFn(u32 *ptr) {
+        /* This builds an address that gets returned, so the register must be x0 by convention. */
+        return AsmCompareAddNoImm12(*ptr, MtcAddAsm);
+    }
+
+    Result MemFreqMtcTable(u32 *ptr);
+    void MtcGenerateFreqTables();
+    Result MemFreqMax(u32 *ptr);
+    HOOK_PAYLOAD_FN EristaMtcTable *GetEristaMtcTableImpl(u32 *count);
+    Result MemMtcTableAsm(u32 *ptr);
+
+    Result MtcInstallHooks(HookPayloadData *data);
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/mariko/calculate_timings_mariko.cpp

@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) Lightos_
+ *
+ * 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 <stratosphere.hpp>
+#include "../../mtc_timing_value.hpp"
+#include "timing_tables.hpp"
+
+namespace ams::ldr::hoc::pcv::mariko {
+
+    void GetRext() {
+        if (auto r = FindRext()) {
+            rext = r->rext;
+            return;
+        }
+
+        /* > 3200 */
+        rext = 0x1E;
+    }
+
+    void SwitchLatency(volatile u32 &latency, u32 index, u32 latencyStep) {
+        latency += index * latencyStep;
+    }
+
+    static s32 GetMaxLatencyIndex(volatile u32 *latencyArray, u32 latencySize) {
+        s32 maxIndex = -1;
+        for (u32 i = 0; i < latencySize; ++i) {
+            if (latencyArray[i]) {
+                maxIndex = i;
+            }
+        }
+
+        return maxIndex;
+    }
+
+    void AutoLatency(volatile u32 &latency, u32 freq, u32 latencyStep) {
+        if (freq > 1600'000 && freq <= 1862'400) { /* 1866tRWL */
+            latency += latencyStep * 2;
+        } else { /* 2133tRWL */
+            latency += latencyStep * 3;
+        }
+    }
+
+    void HandleLatency(u32 freq, volatile u32 &latency, volatile u32 *latencyArray, u32 indexMax, u32 latencyStep) {
+        for (u32 i = 0; i <= indexMax; ++i) {
+            if (latencyArray[i] != 0 && freq <= latencyArray[i]) {
+                SwitchLatency(latency, i, latencyStep);
+                return;
+            }
+        }
+
+        SwitchLatency(latency, indexMax, latencyStep);
+    }
+
+    void HandleLatency(u32 freq) {
+        static s32 rlIndexMax = GetMaxLatencyIndex(C.readLatency, std::size(C.readLatency));
+        static s32 wlIndexMax = GetMaxLatencyIndex(C.writeLatency, std::size(C.writeLatency));
+        constexpr u32 ReadLatencyStep  = 4;
+        constexpr u32 WriteLatencyStep = 2;
+        bool autoLatencyRead = false, autoLatencyWrite = false;
+
+        if (rlIndexMax == -1) {
+            AutoLatency(RL, freq, ReadLatencyStep);
+            autoLatencyRead = true;
+        }
+
+        if (wlIndexMax == -1) {
+            AutoLatency(WL, freq, WriteLatencyStep);
+            autoLatencyWrite = true;
+        }
+
+        if (autoLatencyRead && autoLatencyWrite) {
+            return;
+        }
+
+        if (!autoLatencyRead) {
+            HandleLatency(freq, RL, C.readLatency, rlIndexMax, ReadLatencyStep);
+        }
+
+        if (!autoLatencyWrite) {
+            HandleLatency(freq, WL, C.writeLatency, wlIndexMax, WriteLatencyStep);
+        }
+    }
+
+    void CalculateMrw2() {
+        static const u8 rlMapDBI[8] = {
+            6, 12, 16, 22, 28, 32, 36, 40
+        };
+
+        static const u8 wlMapSetA[8] = {
+            4, 6, 8, 10, 12, 14, 16, 18
+        };
+
+        u32 rlIndex = 0;
+        u32 wlIndex = 0;
+
+        for (u32 i = 0; i < std::size(rlMapDBI); ++i) {
+            if (rlMapDBI[i] == RL) {
+                rlIndex = i;
+                break;
+            }
+        }
+
+        for (u32 i = 0; i < std::size(wlMapSetA); ++i) {
+            if (wlMapSetA[i] == WL) {
+                wlIndex = i;
+                break;
+            }
+        }
+
+        /* DBI is always enabled. */
+        mrw2 = static_cast<u8>(((rlIndex & 0x7) | ((wlIndex & 0x7) << 3) | ((0 & 0x1) << 6)));
+    }
+
+    void CalculateTimings(double tCK_avg, u32 freq) {
+        RL = RL_1331;
+        WL = WL_1331;
+
+        HandleLatency(freq);
+
+        GetRext();
+
+        /* At 1333WL, for some reason (incorrect ram timing config in mtc table?), tRP causes crashes at high reductions - 2 seems to be the most common limit. */
+        /* This is a lazy workaround until I find the issue... */
+        const bool lowFreq = freq < C.timingEmcTbreak;
+
+        tRCD   = tRCD_values[lowFreq ? C.low_t1_tRCD : C.t1_tRCD];
+        tRPpb  = tRP_values[lowFreq  ? C.low_t2_tRP  : C.t2_tRP];
+        tRAS   = tRAS_values[lowFreq ? C.low_t3_tRAS : C.t3_tRAS];
+        tRRD   = tRRD_values[lowFreq ? C.low_t4_tRRD : C.t4_tRRD];
+        tRFCpb = tRFC_values[lowFreq ? C.low_t5_tRFC : C.t5_tRFC];
+
+        u32 tRTW = lowFreq ? C.low_t6_tRTW : C.t6_tRTW;
+        u32 tWTR = 10 - tWTR_values[lowFreq ? C.low_t7_tWTR : C.t7_tWTR];
+
+        s32 finetRTW = C.fineTune_t6_tRTW;
+        s32 finetWTR = C.fineTune_t7_tWTR;
+
+        u32 tREFI = lowFreq ? C.low_t8_tREFI : C.t8_tREFI;
+        refresh_raw = 0xFFFF;
+        if (tREFI != 6) {
+            refresh_raw = CEIL(tREFpb_values[tREFI] / tCK_avg) - 0x40;
+            refresh_raw = MIN(refresh_raw, static_cast<u32>(0xFFFF));
+        }
+
+        tRC    = tRAS + tRPpb;
+        tRFCab = tRFCpb * 2;
+        tXSR   = static_cast<double>(tRFCab + 7.5);
+        tFAW   = static_cast<u32>(tRRD * 4.0);
+        tRPab  = tRPpb + 3;
+
+        tR2P  = CEIL((RL * 0.426) - 2.0);
+        tR2W  = FLOOR(FLOOR((5.0 / tCK_avg) + ((FLOOR(48.0 / WL) - 0.478) * 3.0)) / 1.501) + RL - (tRTW * 3) + finetRTW;
+        tRTM  = FLOOR((10.0 + RL) + (3.502 / tCK_avg)) + FLOOR(7.489 / tCK_avg);
+        tRATM = CEIL((tRTM - 10.0) + (RL * 0.426));
+
+        rdv               = RL + FLOOR((5.105 / tCK_avg) + 17.017);
+        qpop              = rdv - 14;
+        quse_width        = CEIL(((4.897 / tCK_avg) - FLOOR(2.538 / tCK_avg)) + 3.782);
+        quse              = FLOOR(RL + ((5.082 / tCK_avg) + FLOOR(2.560 / tCK_avg))) - CEIL(4.820 / tCK_avg);
+        einput_duration   = FLOOR(9.936 / tCK_avg) + 5.0 + quse_width;
+        einput            = quse - CEIL(9.928 / tCK_avg);
+        u32 qrst_duration = FLOOR(8.399 - tCK_avg);
+        u32 qrstLow       = MAX(static_cast<s32>(einput - qrst_duration - 2), static_cast<s32>(0));
+        qrst              = PACK_U32(qrst_duration, qrstLow);
+        ibdly             = PACK_U32_NIBBLE_HIGH_BYTE_LOW(1, quse - qrst_duration - 2.0);
+        qsafe             = (einput_duration + 3) + MAX(MIN(qrstLow * rdv, qrst_duration + qrst_duration), einput);
+        tW2P              = (CEIL(WL * 1.7303) * 2) - 5;
+        tWTPDEN           = CEIL(((1.803 / tCK_avg) + MAX(RL + (2.694 / tCK_avg), static_cast<double>(tW2P))) + (BL / 2));
+        tW2R              = FLOOR(MAX((5.020 / tCK_avg) + 1.130, WL - MAX(-CEIL(0.258 * (WL - RL)), 1.964)) * 1.964) + WL - CEIL(tWTR / tCK_avg) + finetWTR;
+        tWTM              = CEIL(WL + ((7.570 / tCK_avg) + 8.753));
+        tWATM             = (tWTM + (FLOOR(WL / 0.816) * 2.0)) - 4.0;
+
+        wdv = WL;
+        wsv = WL - 2;
+        wev = 0xA + (WL - 14);
+
+        u32 obdlyHigh = 3 / FLOOR(MIN(static_cast<double>(2), tCK_avg * (WL - 7)));
+        u32 obdlyLow  = MAX(WL - FLOOR((126.0 / CEIL(tCK_avg + 8.601))), 0.0);
+        obdly         = PACK_U32_NIBBLE_HIGH_BYTE_LOW(obdlyHigh, obdlyLow);
+
+        pdex2rw  = CEIL((CEIL(12.335 - tCK_avg) + (7.430 / tCK_avg) - CEIL(tCK_avg * 11.361)));
+
+        tCLKSTOP = FLOOR(MIN(8.488 / tCK_avg, 23.0)) + 8.0;
+
+        u32 tMMRI = tRCD + (tCK_avg * 3);
+        pdex2mrr  = tMMRI + 10;
+
+        CalculateMrw2();
+    }
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/mariko/calculate_timings_mariko.hpp

@@ -1,24 +1,24 @@
-/*
- * Copyright (c) Lightos_
- *
- * 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
-
-namespace ams::ldr::hoc::pcv::mariko {
-
-    void CalculateTimings();
-
-}
-
+/*
+ * Copyright (c) Lightos_
+ *
+ * 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
+
+namespace ams::ldr::hoc::pcv::mariko {
+
+    void CalculateTimings(double tCK_avg, u32 freq);
+
+}
+

Source/Atmosphere/stratosphere/loader/source/oc/pcv/mariko/pcv_mariko.cpp

@@ -0,0 +1,588 @@
+/*
+ * Copyright (C) Switch-OC-Suite
+ *
+ * Copyright (c) 2023 hanai3Bi
+ *
+ * Copyright (c) B3711
+ *
+ * Copyright (c) Souldbminer and Horizon OC Contributors
+ *
+ * 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 <vector>
+#include "../pcv.hpp"
+#include "../../mtc_timing_value.hpp"
+#include "pcv_mariko.hpp"
+#include "pcv_mariko_cpu.hpp"
+#include "pcv_mariko_gpu.hpp"
+#include "pcv_mariko_mtc.hpp"
+#include "calculate_timings_mariko.hpp"
+
+namespace ams::ldr::hoc::pcv::mariko {
+
+    u32 *nsoStart;
+
+    namespace {
+        size_t g_nso_size = 0;
+        uintptr_t g_cave_cursor = 0;
+    }
+
+    static uintptr_t CaveReserve(size_t count) {
+        if (g_pcv_cave == 0 || g_cave_cursor == 0) {
+            return 0;
+        }
+        if (g_cave_cursor + count * sizeof(u32) > g_pcv_cave + g_pcv_cave_size) {
+            return 0;
+        }
+        const uintptr_t entry = g_cave_cursor;
+        g_cave_cursor += count * sizeof(u32);
+        return entry;
+    }
+
+    #if HOC_UART_LOG
+    /* Redirect pcv's NvLog() calls to UART */
+    Result NvLogUartRedirect(u32 *ptr) {
+        const uintptr_t mapped_nso     = reinterpret_cast<uintptr_t>(nsoStart);
+        const size_t    nso_size       = g_nso_size;
+        const uintptr_t textEnd        = g_pcv_cave; /* .text ends where the cave begins */
+        const uintptr_t vsnprintf_addr = reinterpret_cast<uintptr_t>(ptr);
+
+        /* NvLog via the VDD_SOC log */
+        static const char Fmt[] = "%s(%s): DVFS request VDD_SOC %d mV\n";
+        constexpr size_t FmtLen = sizeof(Fmt) - 1;
+        uintptr_t strAddr = 0;
+        {
+            const char *hay = reinterpret_cast<const char *>(mapped_nso);
+            for (size_t i = 0; i + FmtLen <= nso_size; ++i) {
+                if (std::memcmp(hay + i, Fmt, FmtLen) == 0) { strAddr = mapped_nso + i; break; }
+            }
+        }
+        if (strAddr == 0) {
+            LOGGING("NvLogRedirect: fmt string not found (vsnprintf@+%lx)", vsnprintf_addr - mapped_nso);
+            R_THROW(ldr::ResultInvalidNvLogRedirect());
+        }
+
+        uintptr_t nvlog_addr = 0;
+        for (u32 *p = nsoStart; reinterpret_cast<uintptr_t>(p + 2) <= textEnd; ++p) {
+            const uintptr_t pc = reinterpret_cast<uintptr_t>(p);
+            if (!AsmIsAdrp(p[0])) {
+                continue;
+            }
+            const uintptr_t adrpPage = (pc & ~static_cast<uintptr_t>(0xFFFu)) + static_cast<uintptr_t>(AsmAdrpPageOffset(p[0]));
+            if (adrpPage != (strAddr & ~static_cast<uintptr_t>(0xFFFu))) {
+                continue;
+            }
+            const u32 reg = asm_get_rd(p[0]);
+            if (!(AsmIsAddImm64(p[1]) && asm_get_rd(p[1]) == reg && AsmGetRn(p[1]) == reg && AsmGetImm12(p[1]) == (strAddr & 0xFFFu))) {
+                continue;
+            }
+            for (u32 k = 2; k <= 12 && (pc + (k + 1) * 4) <= textEnd; ++k) {
+                if (AsmIsBl(p[k])) { nvlog_addr = AsmBranchTarget(p[k], pc + k * 4); break; }
+            }
+            if (nvlog_addr != 0) {
+                break;
+            }
+        }
+        if (nvlog_addr == 0 || nvlog_addr < mapped_nso || nvlog_addr >= textEnd) {
+            LOGGING("NvLogRedirect: NvLog entry not found (fmt@+%lx)", strAddr - mapped_nso);
+            R_THROW(ldr::ResultInvalidNvLogRedirect());
+        }
+
+        const uintptr_t helper = CaveReserve(40);
+        if (helper == 0) {
+            LOGGING("NvLogRedirect: cave unavailable (cave=%lx size=%lx)",
+                    static_cast<unsigned long>(g_pcv_cave), static_cast<unsigned long>(g_pcv_cave_size));
+            R_THROW(ldr::ResultInvalidNvLogRedirect());
+        }
+        u32 *t = reinterpret_cast<u32 *>(helper);
+        size_t n = 0;
+        auto emit = [&](u32 ins) { t[n] = ins; ++n; };
+
+        emit(AsmMakeSubImm64(31, 31, 0x200));
+        emit(AsmMakeStpImm64(0, 1, 31, 0x100));
+        emit(AsmMakeStpImm64(2, 3, 31, 0x110));
+        emit(AsmMakeStpImm64(4, 5, 31, 0x120));
+        emit(AsmMakeStpImm64(6, 7, 31, 0x130));
+        emit(AsmMakeStpqImm(0, 1, 31, 0x140));
+        emit(AsmMakeStpqImm(2, 3, 31, 0x160));
+        emit(AsmMakeStpqImm(4, 5, 31, 0x180));
+        emit(AsmMakeStpqImm(6, 7, 31, 0x1A0));
+        emit(AsmMakeStrImm64(30, 31, 0x1E0));
+        emit(AsmMakeAddImm64(9, 31, 0x200)); emit(AsmMakeStrImm64(9, 31, 0x1C0)); /* __stack  */
+        emit(AsmMakeAddImm64(9, 31, 0x140)); emit(AsmMakeStrImm64(9, 31, 0x1C8)); /* __gr_top */
+        emit(AsmMakeAddImm64(9, 31, 0x1C0)); emit(AsmMakeStrImm64(9, 31, 0x1D0)); /* __vr_top */
+        emit(AsmMakeMovnW(9, 0x37)); emit(AsmMakeStrImm32(9, 31, 0x1D8)); /* __gr_offs = -56  */
+        emit(AsmMakeMovnW(9, 0x7F)); emit(AsmMakeStrImm32(9, 31, 0x1DC)); /* __vr_offs = -128 */
+        emit(AsmMakeAddImm64(0, 31, 0x00)); /* mov x0,sp (buf)  */
+        emit(AsmMakeMovzW(1, 0x100)); /* size = 0x100     */
+        emit(AsmMakeLdrImm64(2, 31, 0x100)); /* fmt (saved x0)   */
+        emit(AsmMakeAddImm64(3, 31, 0x1C0)); /* ap               */
+        emit(AsmMakeBl(helper + n * 4, vsnprintf_addr));
+        emit(AsmMakeMovReg(1, 0)); /* len = retval     */
+        emit(AsmMakeCmpImm32(1, 0x100));
+        { const size_t at = n; emit(AsmMakeBCond(helper + at * 4, helper + (at + 2) * 4, 0x3u)); } /* b.lo +2 */
+        emit(AsmMakeMovzW(1, 0xFF)); /* clamp len        */
+        emit(AsmMakeAddImm64(0, 31, 0x00)); /* mov x0,sp (str)  */
+        emit(AsmMakeSvc(0x27)); /* svcOutputDebugString */
+        emit(AsmMakeLdrImm64(30, 31, 0x1E0));
+        emit(AsmMakeAddImm64(31, 31, 0x200));
+        emit(RetIns);
+
+        /* Redirect the call sites as patching the actual function causes crash */
+        const uintptr_t roStart = g_pcv_cave + g_pcv_cave_size; /* module .rodata start */
+        size_t patchedSites = 0;
+        if (HOC_PCV_NVLOG_PATCH) {
+            for (u32 *p = nsoStart; reinterpret_cast<uintptr_t>(p + 1) <= textEnd; ++p) {
+                if (!AsmIsBl(*p)) {
+                    continue;
+                }
+                const uintptr_t pc = reinterpret_cast<uintptr_t>(p);
+                if (AsmBranchTarget(*p, pc) != nvlog_addr) {
+                    continue;
+                }
+                bool isFmtCall = false;
+                for (u32 j = 1; j <= 8 && reinterpret_cast<uintptr_t>(p - j) >= reinterpret_cast<uintptr_t>(nsoStart); ++j) {
+                    const u32 w = *(p - j);
+                    if (AsmIsAdrp(w) && asm_get_rd(w) == 0) { /* adrp x0,<page> */
+                        const uintptr_t wpc = pc - j * 4;
+                        const uintptr_t tgtPage = (wpc & ~static_cast<uintptr_t>(0xFFFu)) + static_cast<uintptr_t>(AsmAdrpPageOffset(w));
+                        if (tgtPage >= (roStart & ~static_cast<uintptr_t>(0xFFFu))) { isFmtCall = true; break; }
+                    }
+                }
+                if (isFmtCall) {
+                    PATCH_OFFSET(p, AsmMakeBl(pc, helper));
+                    ++patchedSites;
+                }
+            }
+        }
+
+        LOGGING("NvLogRedirect: stub@+%lx vsnprintf@+%lx helper@+%lx instr=%zu sites=%zu",
+                nvlog_addr - mapped_nso, vsnprintf_addr - mapped_nso, helper - mapped_nso, n, patchedSites);
+        R_SUCCEED();
+    }
+    #endif
+
+    /* Relocate C2/C3Bus to avoid issues*/
+    Result BusFreqReloc(u32 *ptr) {
+        const u32 busReg  = AsmGetRn(ptr[0]); /* ldr Xbuf,[Xbus,#0x10] : bus struct pointer */
+        const u32 bufReg  = asm_get_rd(ptr[0]);  /*                        : freq-buffer arg    */
+        const u32 bufOff  = AsmGetLdStImm64Off(ptr[0]); /*                        : bus->freqBuf offset */
+        const u32 cntReg  = asm_get_rd(ptr[1]); /* add Xcnt,Xbus,#0x18   : arg2 (&count)       */
+        const u32 railReg = asm_get_rd(ptr[2]); /* str Xrail,[Xbus,#0x50]: arg0 (rail)         */
+        u32 *call = ptr + 3; /* the bl to relocate                          */
+        const uintptr_t realFn = AsmBranchTarget(*call, reinterpret_cast<uintptr_t>(call));
+
+        /* Pick 3 scratch registers */
+        u32 s[3], sc = 0;
+        for (u32 r = 9; r <= 15 && sc < 3; ++r) {
+            if (r != busReg && r != bufReg && r != cntReg && r != railReg) {
+                s[sc++] = r;
+            }
+        }
+        R_UNLESS(sc == 3, ldr::ResultInvalidBusFreqReloc());
+
+        const uintptr_t tramp = CaveReserve(9);
+        R_UNLESS(tramp != 0, ldr::ResultInvalidBusFreqReloc());
+
+        const uintptr_t region = g_pcv_scratch + HocBusFreqBufOffset; /* [0]=counter, +0x10 + i*0x400 = bufs */
+        u32 *t = reinterpret_cast<u32 *>(tramp);
+        size_t n = 0;
+        auto emit = [&](u32 ins) { t[n] = ins; ++n; };
+        emit(AsmMakeAdrp(tramp + n * 4, region, s[0])); /* adrp s0,<region>            */
+        emit(AsmMakeAddImm64(s[0], s[0], region & 0xFFFu)); /* add  s0,s0,#lo              */
+        emit(AsmMakeLdrImm32(s[1], s[0], 0x00)); /* s1 = counter               */
+        emit(AsmMakeAddImm64(s[2], s[1], 1)); /* s2 = counter+1             */
+        emit(AsmMakeStrImm32(s[2], s[0], 0x00)); /* counter++                  */
+        emit(AsmMakeAddImm64(s[0], s[0], 0x10)); /* s0 = region+0x10 (buffers) */
+        emit(AsmMakeAddShiftedReg64(bufReg, s[0], s[1], 10)); /* Xbuf = s0 + counter*0x400  */
+        emit(AsmMakeStrImm64(bufReg, busReg, bufOff)); /* bus[freqBuf] = Xbuf        */
+        emit(AsmMakeB(tramp + n * 4, realFn)); /* tail-call the real function */
+
+        PATCH_OFFSET(call, AsmMakeBl(reinterpret_cast<uintptr_t>(call), tramp));
+        const uintptr_t base = reinterpret_cast<uintptr_t>(nsoStart);
+        (void) base;
+        LOGGING("BusFreqReloc: call@+%lx -> tramp@+%lx realfn@+%lx (bus=x%u buf=x%u off=0x%x scratch=x%u,x%u,x%u)",
+                reinterpret_cast<uintptr_t>(call) - base, tramp - base, realFn - base, busReg, bufReg, bufOff, s[0], s[1], s[2]);
+        R_SUCCEED();
+    }
+
+
+    #if HOC_UART_LOG
+    /* Force GetEffectiveVerbosityLevel to return a non-zero level so all NvLog runs. */
+    Result ForceVerbosity(u32 *ptr) {
+        PATCH_OFFSET(&ptr[0], AsmMakeMovzW(0, static_cast<u16>(HOC_PCV_FORCE_VERBOSITY))); /* movz w0,#level */
+        PATCH_OFFSET(&ptr[1], RetIns);                                                     /* ret            */
+        R_SUCCEED();
+    }
+    #endif
+
+    /* Widen InitDram for a >32-entry EMC DVFS list. Freq array can be dropped to free 264 bytes, relocate the Soc LUT to that space */
+    Result EmcSocLutReloc(u32 *ptr) {
+        constexpr u32 Window = 48;
+
+        u32 *freqStore = ScanAssembly(ptr - Window, Window, EmcSocFreqStoreAsm, asm_compare_no_rd); /* str x?,[x8,#0x18] */
+        u32 *voltStore = ScanAssembly(ptr - Window, Window, EmcSocVoltStoreAsm, asm_compare_no_rd); /* str w?,[x8,#0x48] */
+        u32 *readLoad  = ScanAssembly(ptr - Window, Window, EmcSocReadLoadAsm,  asm_compare_no_rd); /* ldr w?,[x9,#0x48] */
+        R_UNLESS(freqStore && voltStore && readLoad, ldr::ResultInvalidEmcSocLut());
+
+        u32 *voltBase = voltStore - 2;   /* `add Xb,Xsrc,Xi,LSL#2` (a cmn sits between it and store) */
+        R_UNLESS(AsmIsAddShiftedReg64(*voltBase) && asm_get_rd(*voltBase) == AsmGetRn(*voltStore),
+                 ldr::ResultInvalidEmcSocLut());
+
+        /* adrp Xl ; add Xl,Xl,#off ; ... ; str Xl,[rail,#0x120] */
+        const u32 lutReg  = asm_get_rd(ptr[0]);
+        const u32 railReg = AsmGetRn(ptr[0]);
+        R_UNLESS(AsmIsAdrp(ptr[-3]) && asm_get_rd(ptr[-3]) == lutReg, ldr::ResultInvalidEmcSocLut());
+        R_UNLESS(AsmIsAddImm64(ptr[-2]) && asm_get_rd(ptr[-2]) == lutReg && AsmGetRn(ptr[-2]) == lutReg,
+                 ldr::ResultInvalidEmcSocLut());
+
+        const u32 srcBase = AsmGetRn(*voltBase);   /* rail ptr at +0x20 */
+        const u32 wBase   = asm_get_rd(*voltBase); /* base reg */
+        const u32 wIdx    = AsmGetRm(*voltBase);   /* loop index */
+
+        PATCH_OFFSET(freqStore,     NopIns); /* Unneeded */
+        PATCH_OFFSET(voltBase,      AsmMakeLdrImm64(wBase, srcBase, 0x20)); /* ldr Xb,[Xsrc,#0x20] (rail) */
+        PATCH_OFFSET(voltStore - 1, AsmMakeAddImm64(wBase, wBase, 0x18));  /* add Xb,Xb,#0x18 (was cmn) */
+        PATCH_OFFSET(voltStore,     AsmSetLdStRegOffset(*voltStore, wIdx)); /* str Wv,[Xb,Xi,LSL#2] -> rail+0x18+i*4 */
+        PATCH_OFFSET(voltStore + 1, NopIns); /* Unneeded */
+
+        /* rail+0x18 as the socMinLut pointer. */
+        PATCH_OFFSET(ptr - 3, NopIns);
+        PATCH_OFFSET(ptr - 2, AsmMakeAddImm64(lutReg, railReg, 0x18));/* add Xl,rail,#0x18 */
+
+        /* Drop the abort branch in case of a bad read */
+        for (u32 i = 1; i <= 4; ++i) {
+            if (AsmIsBCond(readLoad[i])) {
+                PATCH_OFFSET(&readLoad[i], NopIns);
+                break;
+            }
+        }
+        R_SUCCEED();
+    }
+
+    Result EmcDvfsCountLimit(u32 *ptr) {
+        R_UNLESS(EmcDvfsCountPatternFn(ptr), ldr::ResultInvalidEmcDvfsCount());
+
+        /* cmp w?,#0x21 -> cmp w?,#EmcDvfsTableEntryCount */
+        PATCH_OFFSET(ptr, AsmSubsSetImm12(*ptr, static_cast<u16>(EmcDvfsTableEntryCount)));
+        R_SUCCEED();
+    }
+
+    Result EmcRateListLimit(u32 *ptr) {
+        /* ptr = cmp w?,#0x20 ; ptr[1] = csel w?,w?,w?,lt (w? = min(maxCount, 32)) ; ptr[2] = bl */
+        R_UNLESS(EmcRateListPatternFn(ptr), ldr::ResultInvalidEmcRateList());
+
+        /* The csel's Rm holds the 32 cap. */
+        const u32 capReg = AsmGetRm(ptr[1]);
+        const u32 capMov = AsmMakeMovzW(capReg, 0x20); /* movz w<Rm>,#0x20 */
+
+        u32 *movPtr = nullptr;
+        for (u32 i = 1; i <= 16; ++i) {
+            if (*(ptr - i) == capMov) {
+                movPtr = ptr - i;
+                break;
+            }
+        }
+        R_UNLESS(movPtr, ldr::ResultInvalidEmcRateList());
+
+        /* min(maxCount, 32) -> min(maxCount, EmcDvfsTableEntryCount). */
+        PATCH_OFFSET(ptr, AsmSubsSetImm12(*ptr, static_cast<u16>(EmcDvfsTableEntryCount)));     /* cmp  w?,#64 */
+        PATCH_OFFSET(movPtr, asm_set_imm16(*movPtr, static_cast<u16>(EmcDvfsTableEntryCount))); /* movz w?,#64 */
+        R_SUCCEED();
+    }
+
+    Result I2cSet_U8(I2cDevice dev, u8 reg, u8 val) {
+        struct {
+            u8 reg;
+            u8 val;
+        } __attribute__((packed)) cmd;
+
+        I2cSession _session;
+        R_TRY(i2cOpenSession(&_session, dev));
+
+        cmd.reg    = reg;
+        cmd.val    = val;
+        Result res = i2csessionSendAuto(&_session, &cmd, sizeof(cmd), I2cTransactionOption_All);
+        i2csessionClose(&_session);
+        return res;
+    }
+
+    Result EmcVddqVolt(u32 *ptr) {
+        regulator *entry = reinterpret_cast<regulator *>(reinterpret_cast<u8 *>(ptr) - offsetof(regulator, type_2_3.default_uv));
+
+        constexpr u32 uv_step = 5'000;
+        constexpr u32 uv_min  = 250'000;
+
+        auto validator = [entry]() {
+            R_UNLESS(entry->id               == 2,       ldr::ResultInvalidRegulatorEntry());
+            R_UNLESS(entry->type             == 3,       ldr::ResultInvalidRegulatorEntry());
+            R_UNLESS(entry->type_2_3.step_uv == uv_step, ldr::ResultInvalidRegulatorEntry());
+            R_UNLESS(entry->type_2_3.min_uv  == uv_min,  ldr::ResultInvalidRegulatorEntry());
+            R_SUCCEED();
+        };
+
+        R_TRY(validator());
+
+        u32 emc_uv = C.marikoEmcVddqVolt;
+
+        if (!emc_uv) {
+            R_SKIP();
+        }
+
+        if (emc_uv % uv_step) {
+            emc_uv = (emc_uv + uv_step - 1) / uv_step * uv_step; // rounding
+        }
+
+        PATCH_OFFSET(ptr, emc_uv);
+
+        i2cInitialize();
+        Result resultI2C = I2cSet_U8(I2cDevice_Max77812_2, 0x25, (emc_uv - uv_min) / uv_step);
+        i2cExit();
+
+        R_SUCCEED();
+
+        return resultI2C;
+    }
+
+    Result GetSocSpeedo(u32 &socSpeedo) {
+        constexpr u64 FusePhysicalAddress = 0x7000F000;
+        u64 virtualAddress                = 0;
+        constexpr u64 Size                = 0x1000;
+
+        u64 outSize;
+        /* TODO: use svc::QueryMemoryMapping instead. */
+        R_TRY(svcQueryMemoryMapping(&virtualAddress, &outSize, FusePhysicalAddress, Size));
+
+        constexpr u32 FuseOffset      = 2048;
+        constexpr u32 SocSpeedoOffset = 308;
+        socSpeedo                     = *reinterpret_cast<u32 *>(virtualAddress + FuseOffset + SocSpeedoOffset);
+
+        R_SUCCEED();
+    }
+
+    u32 GetSocProcessId(u32 socSpeedo) {
+        if (socSpeedo <= 1597) {
+            return 0;
+        }
+
+        if (socSpeedo <= 1708) {
+            return 1;
+        }
+
+        /* >= 1709. */
+        return 2;
+    }
+
+    Result SocVoltAsm(u32 *compareSpeedos) {
+        constexpr u32 VoltageScanLimit = 10;
+        /* Might actually be speedo id. */
+        u32 *writeProcessId = ScanAssembly(compareSpeedos, VoltageScanLimit, SocVoltWriteProcessIdAsm, asm_compare_no_rd);
+        R_UNLESS(writeProcessId != nullptr, ldr::ResultInvalidSocVoltPattern());
+        u8 writeProcessIdRd = asm_get_rd(*writeProcessId);
+
+        /* This writes 1050mV. */
+        u32 *writeVoltage = ScanAssembly(writeProcessId, VoltageScanLimit, SocVoltWriteVoltageAsm, asm_compare_no_rd);
+        R_UNLESS(writeVoltage != nullptr, ldr::ResultInvalidSocVoltPattern());
+        u8 writeVoltageRd = asm_get_rd(*writeVoltage);
+
+        /* A csel instruction is used to select the soc voltage limit register. */
+        /* We care about its destination register since that is used for verification. */
+        constexpr u32 VoltageSelectScanLimit = 24;
+        u32 *selectVoltage                   = ScanAssembly(writeVoltage, VoltageSelectScanLimit, SocVoltSelectRegisterAsm, AsmCompareCselNoReg);
+        R_UNLESS(selectVoltage != nullptr, ldr::ResultInvalidSocVoltPattern());
+        /* Todo: check rm and rn? */
+        u8 selectVoltageRd = asm_get_rd(*selectVoltage);
+
+        /* rdCsel is then multiplied by 1000 to convert to uV. */
+        /* This is pretty far down the function. */
+        constexpr u32 MultiplierScanLimit = 200;
+        u32 *multiplier                   = ScanAssembly(selectVoltage, MultiplierScanLimit, SocVoltMultiplyVoltsAsm, AsmCompareMullNoReg);
+        R_UNLESS(multiplier != nullptr, ldr::ResultInvalidSocVoltPattern());
+        u8 multiplierRn = AsmGetMullRn(*multiplier);
+        u8 multiplierRm = AsmGetMullRm(*multiplier);
+        /* One of the two registers has to be rdCsel. */
+        R_UNLESS((multiplierRn == selectVoltageRd) || (multiplierRm == selectVoltageRd), ldr::ResultInvalidSocVoltPattern());
+        u8 multiplierRd = asm_get_rd(*multiplier);
+
+        /* Subs instruction is then used to verify against absolute limit. */
+        u32 limitValidationPattern = AsmSubsSetRn(SocVoltValidateLimitAsm, multiplierRd);
+        u32 *limitValidation = ScanAssembly(multiplier, VoltageScanLimit, limitValidationPattern, AsmSubsCompareNoReg);
+        R_UNLESS(limitValidation != nullptr, ldr::ResultInvalidSocVoltPattern());
+
+        /* There is a b.gt instruction right after (checks for socVoltageCap < socVoltageMax). */
+        u32 *branchToAbort = limitValidation + 1;
+        R_UNLESS(AsmCompareBrConNoImm19(*branchToAbort, SocVoltBranchToAbortAsm), ldr::ResultInvalidSocVoltPattern());
+
+        if (!C.marikoSocVmax || C.marikoSocVmax <= 1000) {
+            R_SKIP();
+        }
+
+        /* Adjust 1598 speedo minimum to ensure it always goes down process id 0 branch. */
+        /* 2200 should be high enough :D */
+        u32 compareSpeedosPatch = AsmSubsSetImm12(*compareSpeedos, 2200);
+        PATCH_OFFSET(compareSpeedos, compareSpeedosPatch);
+
+        u32 socSpeedo = 0;
+        R_TRY(GetSocSpeedo(socSpeedo));
+
+        /* Adjust processId from 0 to [process id of switch booting this]. */
+        /* We're overwriting the orr instruction entirly. */
+        u32 processId           = GetSocProcessId(socSpeedo);
+        u32 writeProcessIdPatch = asm_set_rd(asm_set_imm16(SocVoltWriteVoltageAsm, processId), writeProcessIdRd);
+        PATCH_OFFSET(writeProcessId, writeProcessIdPatch);
+
+        /* Adjust voltage limit. */
+        u32 voltageLimitPatch = asm_set_rd(asm_set_imm16(SocVoltWriteVoltageAsm, C.marikoSocVmax), writeVoltageRd);
+        PATCH_OFFSET(writeVoltage, voltageLimitPatch);
+
+        /* Branches to an abort if limits are invalid -- we patch the branch instruction with NOP. */
+        PATCH_OFFSET(branchToAbort, NopIns);
+
+        R_SUCCEED();
+    }
+
+    Result SocVoltLimit(u32 *ptr) {
+        R_UNLESS(!std::memcmp(ptr - SocVoltLimitMaxDefaultIndex, socVoltLimitArray, sizeof(socVoltLimitArray)), ldr::ResultInvalidSocVoltLimit());
+        if (!C.marikoSocVmax || C.marikoSocVmax <= SocVoltLimitOfficial) {
+            R_SKIP();
+        }
+
+        constexpr u32 Step = 25;
+        u32 maxVolt = C.marikoSocVmax;
+        if (maxVolt % Step) {
+            maxVolt = maxVolt / Step * Step; /* Round. */
+        }
+
+        u32 volt = SocVoltLimitOfficial;
+        for (u32 i = 1; i < DvfsTableEntryCount - SocVoltLimitMaxDefaultIndex && volt < maxVolt; ++i) {
+            volt += Step;
+            PATCH_OFFSET(ptr + i, volt);
+        }
+
+        R_SUCCEED();
+    }
+
+    Result EmcRateSessLimit(u32 *ptr) {
+        u32 movzI = 0;
+        R_UNLESS(EmcRateSessFindClamp(ptr, nullptr, nullptr, &movzI), ldr::ResultInvalidEmcRateList());
+
+        /* Reject cmd11 GetDvfsTable. */
+        for (u32 i = 1; i <= 24; ++i) {
+            const u32 w = ptr[i];
+            if (AsmIsSubX29Imm(w) && AsmGetImm12(w) >= 0x20u) {  /* sub x?,x29,#>=0x20 */
+                R_THROW(ldr::ResultInvalidEmcRateList());
+            }
+        }
+
+        /*  mov x<desc>,x2 */
+        u32 descReg = 0xFFu;
+        for (u32 i = 1; i <= 24; ++i) {
+            if (AsmIsMovReg(ptr[i], 2)) { descReg = asm_get_rd(ptr[i]); break; }
+        }
+        R_UNLESS(descReg != 0xFFu, ldr::ResultInvalidEmcRateList());
+
+        /* Repoint the duplicated-imm pair */
+        u32 *adds[8]; u32 addImm[8]; u32 nAdds = 0;
+        for (u32 i = 1; i <= 24 && nAdds < 8; ++i) {
+            const u32 w = ptr[i];
+            if (AsmIsAddSpImm(w)) {   /* add x?,sp,#imm12 (shift 0) */
+                adds[nAdds]   = ptr + i;
+                addImm[nAdds] = AsmGetImm12(w);
+                ++nAdds;
+            }
+        }
+        u32 patched = 0;
+        for (u32 a = 0; a < nAdds; ++a) {
+            bool dup = false;
+            for (u32 b = 0; b < nAdds; ++b) {
+                if (a != b && addImm[a] == addImm[b]) { dup = true; break; }
+            }
+            if (dup) {
+                PATCH_OFFSET(adds[a], AsmMakeLdrImm64(asm_get_rd(*adds[a]), descReg, 0)); /* ldr x?,[x<desc>] */
+                ++patched;
+            }
+        }
+        R_UNLESS(patched == 2, ldr::ResultInvalidEmcRateList());
+
+        /* min(maxCount, 32) -> min(maxCount, EmcDvfsTableEntryCount) */
+        PATCH_OFFSET(ptr,         AsmSubsSetImm12(*ptr, static_cast<u16>(EmcDvfsTableEntryCount)));           /* cmp  w?,#64 */
+        PATCH_OFFSET(ptr + movzI, asm_set_imm16(*(ptr + movzI), static_cast<u16>(EmcDvfsTableEntryCount)));  /* movz w?,#64 */
+        R_SUCCEED();
+    }
+
+    void Patch(uintptr_t mapped_nso, size_t nso_size) {
+        nsoStart = reinterpret_cast<u32 *>(mapped_nso);
+
+        g_pcv_scratch = mapped_nso + nso_size - HocPcvScratchSize;
+        g_nso_size    = nso_size;
+        g_cave_cursor = g_pcv_cave;   /* start the .text-cave bump allocator (0 if unavailable) */
+
+        MtcGenerateFreqTables();
+
+        u32 CpuCvbDefaultMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(CpuCvbTableDefault)->freq);
+        u32 GpuCvbDefaultMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(GpuCvbTableDefault)->freq);
+
+        PatcherEntry<u32> patches[] = {
+            { "CPU Freq Vdd",      &CpuFreqVdd,            1, nullptr,  CpuClkOSLimit              },
+            { "CPU Freq Table",     CpuFreqCvbTable<true>, 1, nullptr,  CpuCvbDefaultMaxFreq       },
+            { "CPU Volt DVFS",     &CpuVoltDVFS,           1, nullptr,  CpuVminOfficial            },
+            { "CPU Volt Thermals", &CpuVoltThermals,       1, nullptr,  CpuVminOfficial            },
+            { "CPU Volt Dfll",     &CpuVoltDfll,           1, nullptr,  CpuTune0Low                },
+            { "GPU Volt DVFS",     &GpuVoltDVFS,           1, nullptr,  GpuVminOfficial            },
+            { "GPU Volt Thermals", &GpuVoltThermals,       1, nullptr,  GpuVminOfficial            },
+            { "GPU Freq Table",     GpuFreqCvbTable<true>, 1, nullptr,  GpuCvbDefaultMaxFreq       },
+            { "GPU Freq Asm",      &GpuFreqMaxAsm,         2,          &GpuMaxClockPatternFn       },
+            { "GPU PLL Max",       &GpuFreqPllMax,         1, nullptr,  GpuClkPllMax               },
+            { "GPU PLL Limit",     &GpuFreqPllLimit,       4, nullptr,  GpuClkPllLimit             },
+            { "MEM Freq Mtc",      &MemFreqMtcTable,       1, nullptr,  EmcClkOSLimit              },
+            { "MEM Freq Dvb",      &MemFreqDvbTable,       1, nullptr,  EmcClkOSLimit              },
+            { "MEM Freq Max",      &MemFreqMax,            0, nullptr,  EmcClkOSLimit              },
+            { "MEM Freq PLLM",     &MemFreqPllmLimit,      2, nullptr,  EmcClkPllmLimit            },
+            { "MEM Vddq",          &EmcVddqVolt,           2, nullptr,  EmcVddqDefault             },
+            { "MEM Vdd2",          &MemVoltHandler,        2, nullptr,  MemVdd2Default             },
+            { "MEM Table Asm",     &MemMtcTableAsm,        1,          &MemMtcGetGetTablePatternFn },
+            { "EMC DVFS Count",    &EmcDvfsCountLimit,     1,          &EmcDvfsCountPatternFn      },
+            { "EMC SoC LUT",       &EmcSocLutReloc,        1,          &EmcSocLutPatternFn         },
+            { "EMC Rate List",     &EmcRateListLimit,      0,          &EmcRateListPatternFn       },
+            { "EMC Rate Sess",     &EmcRateSessLimit,      1,          &EmcRateSessPatternFn       },
+            { "Bus Freq Reloc",    &BusFreqReloc,          1,          &BusFreqRelocPatternFn      },
+            { "SOC Volt Asm",      &SocVoltAsm,            1,          &SocVoltPatternFn           },
+            { "SOC Volt Limit",    &SocVoltLimit,          1, nullptr,  SocVoltLimitOfficial       },
+            /* Debugging patches */
+            #if HOC_UART_LOG
+            { "NvLog Redirect",    &NvLogUartRedirect,     1,          &NvLogVsnprintfPatternFn,   0, 0, true },
+            { "Force Verbosity",   &ForceVerbosity,        3,          &ForceVerbosityPatternFn,   0, 0, true },
+            #endif
+        };
+
+        for (uintptr_t ptr = mapped_nso; ptr <= mapped_nso + nso_size - sizeof(MarikoMtcTable); ptr += sizeof(u32)) {
+            u32 *ptr32 = reinterpret_cast<u32 *>(ptr);
+            for (auto &entry : patches) {
+                if (R_SUCCEEDED(entry.SearchAndApply(ptr32))) {
+                    break;
+                }
+            }
+        }
+
+        for (auto &entry : patches) {
+            LOGGING("%s Count: %zu", entry.description, entry.patched_count);
+            if (R_FAILED(entry.CheckResult())) {
+                panic::SmcError(panic::Patch);
+
+                CRASH(entry.description);
+            }
+        }
+    }
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/mariko/pcv_mariko.hpp

@@ -0,0 +1,431 @@
+/*
+ * Copyright (C) Switch-OC-Suite
+ *
+ * Copyright (c) 2023 hanai3Bi
+ *
+ * Copyright (c) Souldbminer, Lightos_ and Horizon OC Contributors
+ *
+ * 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 "../../oc_common.hpp"
+#include "../pcv_common.hpp"
+#include "../pcv_asm.hpp"
+
+namespace ams::ldr::hoc::pcv::mariko {
+
+    extern u32 *nsoStart;
+
+    constexpr cvb_entry_t CpuCvbTableDefault[] = {
+        {  204000, {  721589, -12695, 27 }, {         } },
+        {  306000, {  747134, -14195, 27 }, {         } },
+        {  408000, {  776324, -15705, 27 }, {         } },
+        {  510000, {  809160, -17205, 27 }, {         } },
+        {  612000, {  845641, -18715, 27 }, {         } },
+        {  714000, {  885768, -20215, 27 }, {         } },
+        {  816000, {  929540, -21725, 27 }, {         } },
+        {  918000, {  976958, -23225, 27 }, {         } },
+        { 1020000, { 1028021, -24725, 27 }, { 1120000 } },
+        { 1122000, { 1082730, -26235, 27 }, { 1120000 } },
+        { 1224000, { 1141084, -27735, 27 }, { 1120000 } },
+        { 1326000, { 1203084, -29245, 27 }, { 1120000 } },
+        { 1428000, { 1268729, -30745, 27 }, { 1120000 } },
+        { 1581000, { 1374032, -33005, 27 }, { 1120000 } },
+        { 1683000, { 1448791, -34505, 27 }, { 1120000 } },
+        { 1785000, { 1527196, -36015, 27 }, { 1120000 } },
+        { 1887000, { 1609246, -37515, 27 }, { 1120000 } },
+        { 1963500, { 1675751, -38635, 27 }, { 1120000 } },
+        {                                               },
+    };
+
+    constexpr u32 CpuClkOfficial      = 1963'500;
+    constexpr u32 CpuVoltOfficial     = 1120;
+    constexpr u32 CpuHighVminOfficial = 850;
+    constexpr u32 CpuVminOfficial     = 620;
+    constexpr u32 CpuTune0Low         = 0xFFCF;
+
+    static const u32 cpuVoltagePatchValues[]  = { 850, 38, 1120, 1000, 100, 1000, 0 };
+    static const s32 cpuVoltagePatchOffsets[] = {  -2, -1,    5,    6,   7,    8, 9 };
+    static_assert(sizeof(cpuVoltagePatchValues) == sizeof(cpuVoltagePatchOffsets), "Invalid cpuVoltagePatch size");
+
+    static const u32 cpuVoltThermalData[] = { 620, 1120, 20000, 620, 1120, 70000, 950, 1132, 0, 950, 1227, 0 };
+
+    static const u32 allowedCpuMaxFrequencies[] = { 1'963'500, 2'091'000, 2'193'000, 2'295'000, 2'397'000, 2'499'000, 2'601'000, 2'703'000, };
+
+    constexpr cvb_entry_t GpuCvbTableDefault[] = {
+        // GPUB01_NA_CVB_TABLE
+        {   76800, {}, {  610000,                                 } },
+        {  153600, {}, {  610000,                                 } },
+        {  230400, {}, {  610000,                                 } },
+        {  307200, {}, {  610000,                                 } },
+        {  384000, {}, {  610000,                                 } },
+        {  460800, {}, {  610000,                                 } },
+        {  537600, {}, {  801688, -10900, -163, 298, -10599, 162, } },
+        {  614400, {}, {  824214,  -5743, -452, 238,  -6325,  81, } },
+        {  691200, {}, {  848830,  -3903, -552, 119,  -4030,  -2, } },
+        {  768000, {}, {  891575,  -4409, -584,   0,  -2849,  39, } },
+        {  844800, {}, {  940071,  -5367, -602, -60,    -63, -93, } },
+        {  921600, {}, {  986765,  -6637, -614, -179,  1905, -13, } },
+        {  998400, {}, { 1098475, -13529, -497, -179,  3626,   9, } },
+        { 1075200, {}, { 1163644, -12688, -648,    0,  1077,  40, } },
+        { 1152000, {}, { 1204812,  -9908, -830,    0,  1469, 110, } },
+        { 1228800, {}, { 1277303, -11675, -859,    0,  3722, 313, } },
+        { 1267200, {}, { 1335531, -12567, -867,    0,  3681, 559, } },
+        {                                                           },
+    };
+
+    constexpr u32 GpuClkPllMax    = 1300'000'000;
+    constexpr u32 GpuClkPllLimit  = 2'600'000;
+    constexpr u32 GpuVminOfficial = 610;
+
+    static const u32 gpuDVFSPattern[] = { 1050, 1000, 100, 1000, 10, };
+    static const u32 gpuVoltThermalPattern[] = { 800, 1120, 0, 610, 1120, 20000, 610, 1120, 30000, 610, 1120, 50000, 610, 1120, 70000, 610, 1120, 90000, };
+    static_assert(sizeof(gpuVoltThermalPattern) == 72, "Invalid gpuVoltThermalPattern");
+
+    /* GPU Max Clock asm Pattern:
+        *
+        * MOV W11, #0x1000 MOV (wide immediate)                0x1000                              0xB (11)
+        *  sf | opc |                 | hw  |                   imm16                        |      Rd
+        * #31 |30 29|28 27 26 25 24 23|22 21|20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5 |4  3  2  1  0
+        *   0 | 1 0 | 1  0  0  1  0  1| 0  0| 0  0  0  1  0  0  0  0  0  0  0  0  0  0  0  0 |0  1  0  1  1
+        *
+        * MOVK W11, #0xE, LSL#16     <shift>16                    0xE                              0xB (11)
+        *  sf | opc |                 | hw  |                   imm16                        |      Rd
+        * #31 |30 29|28 27 26 25 24 23|22 21|20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5 |4  3  2  1  0
+        *   0 | 1 1 | 1  0  0  1  0  1| 0  1| 0  0  0  0  0  0  0  0  0  0  0  0  1  1  1  0 |0  1  0  1  1
+        */
+    inline constexpr u32 GpuAsmPattern[] = { 0x52820000, 0x72A001C0 };
+
+    inline bool GpuMaxClockPatternFn(u32 *ptr32) {
+        return asm_compare_no_rd(*ptr32, GpuAsmPattern[0]);
+    }
+
+    struct DvbEntry {
+        u64 freq;
+        u32 volt[4] = {};
+    };
+
+    constexpr DvbEntry EmcDvbTableDefault[] = {
+        {  204000, { 637, 637, 637, } },
+        {  408000, { 637, 637, 637, } },
+        {  800000, { 637, 637, 637, } },
+        { 1065600, { 637, 637, 637, } },
+        { 1331200, { 650, 637, 637, } },
+        { 1600000, { 675, 650, 637, } },
+    };
+
+    /* Movz */
+    /*
+        SF | OPC                     | HW    | Imm16                                      | RD
+        31 | 30 29 28 27 26 25 24 23 | 22 21 | 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 | 4 3 2 1 0
+    */
+    constexpr u32 SocVoltCompareSpeedoAsm  = 0x7118FAFF; /* subs imm, compares to >=1598 max speedo and then goes down process id 1 route. */
+    constexpr u32 SocVoltWriteProcessIdAsm = 0x2A1F03F4; /* orr, writes id 0. */
+    constexpr u32 SocVoltWriteVoltageAsm   = 0x52808358; /* Movz imm, writes 1050mV. */
+    constexpr u32 SocVoltSelectRegisterAsm = 0x1A9A3118; /* Csel, selects the voltage -- we need the register of this. */
+    constexpr u32 SocVoltMultiplyVoltsAsm  = 0x1B1A7F0B; /* Mul, converts from mV -> uV */
+    constexpr u32 SocVoltValidateLimitAsm  = 0x6B0A017F; /* Subs, checks limits */
+    constexpr u32 SocVoltBranchToAbortAsm  = 0x540020AC; /* B.ge Branches to abort if limits are invalid. */
+
+    ALWAYS_INLINE bool SocVoltPatternFn(u32 *ptr) {
+        return asm_compare_no_rd(*ptr, SocVoltCompareSpeedoAsm);
+    }
+
+    constexpr u32 SocVoltLimitOfficial                      = 1050;
+    constexpr u32 SocVoltLimitMaxDefaultIndex               = 17;
+    static const u32 socVoltLimitArray[DvfsTableEntryCount] = { 637, 650, 675, 700, 725, 750, 775, 800, 825, 850, 875, 900, 925, 950, 975, 1000, 1025, 1050, };
+
+    constexpr u32 EmcListDefault[]   = { 204000, 1331200, 1600000, };
+    constexpr u32 EmcListSizeDefault = std::size(EmcListDefault);
+    constexpr u32 EmcListEndDefault  = EmcListSizeDefault - 1;
+
+    constexpr u32 EmcClkOSAlt     = 1331'200;
+    constexpr u32 EmcClkPllmLimit = 2133'000'000;
+    constexpr u32 EmcVddqDefault  = 600'000;
+    constexpr u32 MemVdd2Default  = 1100'000;
+
+    constexpr u32 MTC_TABLE_REV        = 3;
+    constexpr u32 MtcTableCountDefault = 3;
+
+    constexpr size_t MtcFullTableSize  = sizeof(MarikoMtcTable) * MtcTableCountDefault;
+    constexpr u32 MtcFullTableCount    = 17;
+
+    /* These dramids were copied from Hekate -- see /bdk/mem/sdram.h */
+    enum DramId : u64 {
+        HOAG_4GB_HYNIX_H9HCNNNBKMMLXR_NEE       = 3,
+        AULA_4GB_HYNIX_H9HCNNNBKMMLXR_NEE       = 5,
+        IOWA_4GB_HYNIX_H9HCNNNBKMMLXR_NEE       = 6,
+
+        IOWA_4GB_SAMSUNG_K4U6E3S4AM_MGCJ        = 8,
+        IOWA_8GB_SAMSUNG_K4UBE3D4AM_MGCJ        = 9,
+        IOWA_4GB_HYNIX_H9HCNNNBKMMLHR_NME       = 10,
+        IOWA_4GB_MICRON_MT53E512M32D2NP_046_WTE = 11,
+
+        HOAG_4GB_SAMSUNG_K4U6E3S4AM_MGCJ        = 12,
+        HOAG_8GB_SAMSUNG_K4UBE3D4AM_MGCJ        = 13,
+        HOAG_4GB_HYNIX_H9HCNNNBKMMLHR_NME       = 14,
+        HOAG_4GB_MICRON_MT53E512M32D2NP_046_WTE = 15,
+
+        IOWA_4GB_SAMSUNG_K4U6E3S4AA_MGCL        = 17,
+        IOWA_8GB_SAMSUNG_K4UBE3D4AA_MGCL        = 18,
+        HOAG_4GB_SAMSUNG_K4U6E3S4AA_MGCL        = 19,
+
+        IOWA_4GB_SAMSUNG_K4U6E3S4AB_MGCL        = 20,
+        HOAG_4GB_SAMSUNG_K4U6E3S4AB_MGCL        = 21,
+        AULA_4GB_SAMSUNG_K4U6E3S4AB_MGCL        = 22,
+
+        HOAG_8GB_SAMSUNG_K4UBE3D4AA_MGCL        = 23,
+        AULA_4GB_SAMSUNG_K4U6E3S4AA_MGCL        = 24,
+
+        IOWA_4GB_MICRON_MT53E512M32D2NP_046_WTF = 25,
+        HOAG_4GB_MICRON_MT53E512M32D2NP_046_WTF = 26,
+        AULA_4GB_MICRON_MT53E512M32D2NP_046_WTF = 27,
+
+        AULA_8GB_SAMSUNG_K4UBE3D4AA_MGCL        = 28,
+
+        IOWA_4GB_HYNIX_H54G46CYRBX267           = 29,
+        HOAG_4GB_HYNIX_H54G46CYRBX267           = 30,
+        AULA_4GB_HYNIX_H54G46CYRBX267           = 31,
+
+        IOWA_4GB_MICRON_MT53E512M32D1NP_046_WTB = 32,
+        HOAG_4GB_MICRON_MT53E512M32D1NP_046_WTB = 33,
+        AULA_4GB_MICRON_MT53E512M32D1NP_046_WTB = 34,
+    };
+
+    enum MtcTableIndex {
+        T210b0SdevEmcDvfsTableS4gb01    =   0, /* (Unused) Samsung 4Gb */
+        T210b0SdevEmcDvfsTableS4gb03    =   1, /* Samsung AM-MGCJ  4Gb */
+        T210b0SdevEmcDvfsTableS8gb03    =   2, /* (Unused) Samsung 4Gb */
+        T210b0SdevEmcDvfsTableH4gb03    =   3, /* Hynix NME        4Gb */
+        T210b0SdevEmcDvfsTableM4gb03    =   4, /* Micron WT:F      4Gb */
+        T210b0SdevEmcDvfsTableS4gbY01   =   5, /* (Unused) Samsung 4Gb */
+        T210b0SdevEmcDvfsTableS1y4gbY01 =   6, /* (Unused) Samsung 4Gb */
+        T210b0SdevEmcDvfsTableS1y8gbY01 =   7, /* (Unused) Samsung 4Gb */
+        T210b0SdevEmcDvfsTableS1y4gbX03 =   8, /* Samsung AA-MGCL  4Gb */
+        T210b0SdevEmcDvfsTableS1y8gbX03 =   9, /* Samsung AA-MGCL  8Gb */
+        T210b0SdevEmcDvfsTableS1y4gb01  =  10, /* (Unused) Samsung 4Gb */
+        T210b0SdevEmcDvfsTableM1y4gb01  =  11, /* Micron WT:E      4Gb */
+        T210b0SdevEmcDvfsTableH1y4gb01  =  12, /* Hynix NEE        4Gb */
+        T210b0SdevEmcDvfsTableS1y8gb04  =  13, /* Samsung AM-MGCJ  8Gb */
+        T210b0SdevEmcDvfsTableS1z4gb01  =  14, /* Samsung AB-MGCL  4Gb */
+        T210b0SdevEmcDvfsTableH1a4gb01  =  15, /* Hynix x267       4Gb */
+        T210b0SdevEmcDvfsTableM1a4gb01  =  16, /* Micron WT:B      8Gb */
+        MtcTableIndex_Invalid           =  17,
+    };
+
+    struct MtcDramIndex {
+        DramId dramId;
+        MtcTableIndex index;
+    };
+
+    const inline MtcDramIndex mtcIndexTable[] = {
+        { HOAG_4GB_HYNIX_H9HCNNNBKMMLXR_NEE,       T210b0SdevEmcDvfsTableH1y4gb01,  },
+        { AULA_4GB_HYNIX_H9HCNNNBKMMLXR_NEE,       T210b0SdevEmcDvfsTableH1y4gb01,  },
+        { IOWA_4GB_HYNIX_H9HCNNNBKMMLXR_NEE,       T210b0SdevEmcDvfsTableH1y4gb01,  },
+        { IOWA_4GB_SAMSUNG_K4U6E3S4AM_MGCJ,        T210b0SdevEmcDvfsTableS4gb03,    },
+        { IOWA_8GB_SAMSUNG_K4UBE3D4AM_MGCJ,        T210b0SdevEmcDvfsTableS1y8gb04,  },
+        { IOWA_4GB_HYNIX_H9HCNNNBKMMLHR_NME,       T210b0SdevEmcDvfsTableH4gb03,    },
+        { IOWA_4GB_MICRON_MT53E512M32D2NP_046_WTE, T210b0SdevEmcDvfsTableM1y4gb01,  },
+        { HOAG_4GB_SAMSUNG_K4U6E3S4AM_MGCJ,        T210b0SdevEmcDvfsTableS4gb03,    },
+        { HOAG_8GB_SAMSUNG_K4UBE3D4AM_MGCJ,        T210b0SdevEmcDvfsTableS1y8gb04,  },
+        { HOAG_4GB_HYNIX_H9HCNNNBKMMLHR_NME,       T210b0SdevEmcDvfsTableH4gb03,    },
+        { HOAG_4GB_MICRON_MT53E512M32D2NP_046_WTE, T210b0SdevEmcDvfsTableM1y4gb01,  },
+        { IOWA_4GB_SAMSUNG_K4U6E3S4AA_MGCL,        T210b0SdevEmcDvfsTableS1y4gbX03, },
+        { IOWA_8GB_SAMSUNG_K4UBE3D4AA_MGCL,        T210b0SdevEmcDvfsTableS1y8gbX03, },
+        { HOAG_4GB_SAMSUNG_K4U6E3S4AA_MGCL,        T210b0SdevEmcDvfsTableS1y4gbX03, },
+        { IOWA_4GB_SAMSUNG_K4U6E3S4AB_MGCL,        T210b0SdevEmcDvfsTableS1z4gb01,  },
+        { HOAG_4GB_SAMSUNG_K4U6E3S4AB_MGCL,        T210b0SdevEmcDvfsTableS1y8gb04,  },
+        { AULA_4GB_SAMSUNG_K4U6E3S4AB_MGCL,        T210b0SdevEmcDvfsTableS1y8gb04,  },
+        { HOAG_8GB_SAMSUNG_K4UBE3D4AA_MGCL,        T210b0SdevEmcDvfsTableS1y8gbX03, },
+        { AULA_4GB_SAMSUNG_K4U6E3S4AA_MGCL,        T210b0SdevEmcDvfsTableS1y4gbX03, },
+        { IOWA_4GB_MICRON_MT53E512M32D2NP_046_WTF, T210b0SdevEmcDvfsTableM4gb03,    },
+        { HOAG_4GB_MICRON_MT53E512M32D2NP_046_WTF, T210b0SdevEmcDvfsTableM4gb03,    },
+        { AULA_4GB_MICRON_MT53E512M32D2NP_046_WTF, T210b0SdevEmcDvfsTableM4gb03,    },
+        { AULA_8GB_SAMSUNG_K4UBE3D4AA_MGCL,        T210b0SdevEmcDvfsTableS1y8gbX03, },
+        { IOWA_4GB_HYNIX_H54G46CYRBX267,           T210b0SdevEmcDvfsTableH1a4gb01,  },
+        { HOAG_4GB_HYNIX_H54G46CYRBX267,           T210b0SdevEmcDvfsTableH1a4gb01,  },
+        { AULA_4GB_HYNIX_H54G46CYRBX267,           T210b0SdevEmcDvfsTableH1a4gb01,  },
+        { IOWA_4GB_MICRON_MT53E512M32D1NP_046_WTB, T210b0SdevEmcDvfsTableM1a4gb01,  },
+        { HOAG_4GB_MICRON_MT53E512M32D1NP_046_WTB, T210b0SdevEmcDvfsTableM1a4gb01,  },
+        { AULA_4GB_MICRON_MT53E512M32D1NP_046_WTB, T210b0SdevEmcDvfsTableM1a4gb01,  },
+    };
+
+    /*
+        710006abfc 40 01 1f d6     br         x10
+    */
+
+    /*
+        710006ac28 a0 03 00 90     adrp       x0,0x71000de000
+        710006ac2c 00 80 16 91     add        x0=>SdevEmcDvfsTableS4gb01,x0,#0x5a0
+    */
+
+    /* Br */
+    /*
+                             | Z     | OP | Fixed                         | A | M  | RN        | RM
+        31 30 29 28 27 26 25 | 24 23 | 22 | 21 20 19 18 17 16 15 14 13 12 |11 | 10 | 9 8 7 6 5 | 4 3 2 1 0
+        1 1 0 1 0 1 1 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 Rn 0 0 0 0 0
+        Z  op   A M  Rm
+    */
+
+    /* Adrp */
+    /*
+        OP | ImmLow |                | ImmHigh                                             | RD
+        31 | 30 29  | 28 27 26 25 24 | 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 | 4 3 2 1 0
+    */
+
+    /* ADD (immediate) */
+    /*
+        SF | OP | S  | Fixed value       | Sh | Imm12                               | RN        | RD
+        31 | 30 | 29 | 28 27 26 25 24 23 | 22 | 21 20 19 18 17 16 15 14 13 12 11 10 | 9 8 7 6 5 | 4 3 2 1 0
+    */
+
+    constexpr u32 MtcBrAsm   = 0xD61F0140;
+    constexpr u32 MtcMovAsm  = 0x52800068;
+    constexpr u32 MtcAdrpAsm = 0x900003A0;
+    constexpr u32 MtcAddAsm  = 0x91168000;
+
+    ALWAYS_INLINE bool MemMtcGetGetTablePatternFn(u32 *ptr) {
+        /* This builds an address that gets returned, so the register must be x0 by convention. */
+        return AsmCompareAddNoImm12(*ptr, MtcAddAsm);
+    }
+
+    constexpr u32 EmcCountCmpAsm = 0x7100851F; /* cmp w?,#0x21 (subs wzr,w?,#0x21) */
+
+    /*
+        str <lut>,[<rail>,#0x120]   ; volt-array pointer
+        str w?,  [<rail>,#0x154]    ; num_freqs
+    */
+    constexpr u32 EmcSocLutPtrStoreAsm = 0xF9009009;   /* str x?,[x0,#0x120] (anchor) */
+    constexpr u32 EmcSocLutCountStoreAsm = 0xB9015408; /* str w?,[x0,#0x154] (anchor) */
+    constexpr u32 EmcSocFreqStoreAsm = 0xF9000D00;     /* str x?,[x8,#0x18] */
+    constexpr u32 EmcSocVoltStoreAsm = 0xB9004900;     /* str w?,[x8,#0x48] (socMinLut[i]) */
+    constexpr u32 EmcSocReadLoadAsm = 0xB9404929;      /* ldr w?,[x9,#0x48] (socMinLut readback) */
+
+    inline bool EmcDvfsCountPatternFn(u32 *ptr) {
+        /* Local context: cbz w?,<skip> ; cmp w?,#0x21 ; b.cs <abort> */
+        return asm_compare_no_rd(*ptr, EmcCountCmpAsm) && AsmCompareBrConNoImm19(*(ptr + 1), 0x54000002) /* b.cs */
+               && AsmCbzCompareOpcodeOnly(*(ptr - 1), 0x34000000);                                       /* cbz */
+    }
+
+    inline bool EmcSocLutPatternFn(u32 *ptr) {
+        return asm_compare_no_rd(*ptr, EmcSocLutPtrStoreAsm)             /* str x?,[x0,#0x120] */
+               && asm_compare_no_rd(*(ptr + 1), EmcSocLutCountStoreAsm); /* str w?,[x0,#0x154] */
+    }
+
+    /*
+        mov  w?,#0x20            ; the 32 cap
+        cmp  w?,#0x20
+        csel w?,w?,w?,lt         ; w? = min(maxCount, 32)
+        bl   TegraGetEmcDvfsFreqTable
+
+        cmp  w?,#0x20            ; (maxCount)
+        csel w?,<same>,<cap>,lt  ; min(maxCount, 32)
+        bl   <Get*DvfsFreqTable>
+    */
+    constexpr u32 EmcRateCapCmpAsm = 0x710082FF;  /* cmp  w?,#0x20 */
+    constexpr u32 EmcRateCapCselAsm = 0x1A80B000; /* csel w?,w?,w?,lt */
+
+    inline bool EmcRateListPatternFn(u32 *ptr) {
+        return AsmSubsCompareNoReg(*ptr, EmcRateCapCmpAsm)           /* cmp w?,#0x20 */
+               && AsmCompareCselNoReg(*(ptr + 1), EmcRateCapCselAsm) /* csel w?,w?,w?,lt */
+               && (AsmGetRn(*ptr) == AsmGetRn(*(ptr + 1)))           /* min(reg, 0x20) */
+               && AsmBlCompareOpcodeOnly(*(ptr + 2), 0x94000000);    /* bl <Get*DvfsFreqTable> */
+    }
+
+    constexpr u32 EmcRateSessCmpAsm  = 0x710082FF; /* cmp  w?,#0x20 */
+    constexpr u32 EmcRateSessMovAsm  = 0x52800400; /* movz w?,#0x20 */
+    constexpr u32 EmcRateSessCselAsm = 0x1A80B000; /* csel w?,w?,w?,lt (opcode + cond) */
+
+    inline bool EmcRateSessFindClamp(u32 *ptr, u32 *out_c, u32 *out_cap, u32 *out_movz_i) {
+        if (!AsmSubsCompareNoReg(ptr[0], EmcRateSessCmpAsm)) return false;   /* cmp w<c>,#0x20 */
+        const u32 c = AsmGetRn(ptr[0]);
+        for (u32 i = 1; i <= 14; ++i) {
+            const u32 w = ptr[i];
+            if (AsmCompareCselNoReg(w, EmcRateSessCselAsm) && AsmGetRn(w) == c && asm_get_rd(w) == c) {
+                const u32 cap = AsmGetRm(w);
+                for (u32 j = 1; j < i; ++j) {
+                    if ((ptr[j] & 0xFFFFFFE0u) == EmcRateSessMovAsm && asm_get_rd(ptr[j]) == cap) {
+                        if (out_c)      *out_c      = c;
+                        if (out_cap)    *out_cap    = cap;
+                        if (out_movz_i) *out_movz_i = j;
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }
+        return false;
+    }
+
+    inline bool EmcRateSessPatternFn(u32 *ptr) {
+        return EmcRateSessFindClamp(ptr, nullptr, nullptr, nullptr);
+    }
+
+    inline bool BusFreqRelocPatternFn(u32 *ptr) {
+        if (g_pcv_scratch == 0 || g_pcv_cave == 0) {
+            return false;
+        }
+        if (reinterpret_cast<uintptr_t>(ptr + 4) > g_pcv_cave) {   /* the call site lives in .text */
+            return false;
+        }
+        if (!(AsmIsLdrImm64(ptr[0]) && AsmGetLdStImm64Off(ptr[0]) == 0x10)) return false; /* ldr Xbuf,[Xbus,#0x10] */
+        if (!(AsmIsAddImm64(ptr[1]) && AsmGetImm12(ptr[1])       == 0x18)) return false; /* add Xcnt,Xbus,#0x18   */
+        if (!(AsmIsStrImm64(ptr[2]) && AsmGetLdStImm64Off(ptr[2]) == 0x50)) return false; /* str Xrail,[Xbus,#0x50]*/
+        if (!AsmIsBl(ptr[3]))                                              return false; /* bl GetDvfsRailUnique  */
+        const u32 bus = AsmGetRn(ptr[0]);
+        return AsmGetRn(ptr[1]) == bus && AsmGetRn(ptr[2]) == bus;
+    }
+
+    inline bool ForceVerbosityPatternFn(u32 *ptr) {
+        if (HOC_PCV_FORCE_VERBOSITY == 0 || g_pcv_cave == 0) {
+            return false;
+        }
+        if (reinterpret_cast<uintptr_t>(ptr + 11) > g_pcv_cave) {   /* .text only */
+            return false;
+        }
+        if (ptr[0] != 0xA9BE7BFDu || ptr[1] != 0xF9000BF3u || ptr[2] != 0x910003FDu) return false; /* stp/str/mov x29,sp */
+        if (!(AsmIsAddImm64(ptr[3]) && asm_get_rd(ptr[3]) == 0  && AsmGetRn(ptr[3]) == 29)) return false; /* add x0,x29,#imm  */
+        if (!(AsmIsAddImm64(ptr[4]) && asm_get_rd(ptr[4]) == 19 && AsmGetRn(ptr[4]) == 29)) return false; /* add x19,x29,#imm */
+        if (AsmGetImm12(ptr[3]) != AsmGetImm12(ptr[4]) || !AsmIsBl(ptr[5])) return false;
+        for (u32 j = 6; j <= 10; ++j) {
+            if (ptr[j] == 0x7100001Fu) { /* cmp w0,#0 */
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /* vsnprintf(buf,size,fmt,va_list) prologue */
+    inline constexpr u32 NvLogVsnSig[] = { 0xD10483FFu, 0xA9107BFDu, 0xF9008BFCu, 0x910403FDu, 0xF100003Fu };
+
+    inline bool NvLogVsnprintfPatternFn(u32 *ptr) {
+        if (HOC_UART_LOG == 0 || g_pcv_cave == 0) {
+            return false;
+        }
+        if (reinterpret_cast<uintptr_t>(ptr + std::size(NvLogVsnSig)) > g_pcv_cave) {   /* must sit in .text */
+            return false;
+        }
+        for (size_t k = 0; k < std::size(NvLogVsnSig); ++k) {
+            if (ptr[k] != NvLogVsnSig[k]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+
+    void Patch(uintptr_t mapped_nso, size_t nso_size);
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/mariko/pcv_mariko_cpu.cpp

@@ -0,0 +1,237 @@
+/*
+ * Copyright (C) Switch-OC-Suite
+ *
+ * Copyright (c) 2023 hanai3Bi
+ *
+ * Copyright (c) B3711
+ *
+ * Copyright (c) Souldbminer and Horizon OC Contributors
+ *
+ * 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 "../pcv.hpp"
+
+namespace ams::ldr::hoc::pcv::mariko {
+
+    u32 CapCpuClock() {
+        u32 cpuCap = allowedCpuMaxFrequencies[0];
+
+        for (u32 freq : allowedCpuMaxFrequencies) {
+            if (C.marikoCpuMaxClock >= freq) {
+                cpuCap = freq;
+            } else {
+                break;
+            }
+        }
+        return cpuCap;
+    }
+
+    Result CpuFreqVdd(u32 *ptr) {
+        dvfs_rail *entry = reinterpret_cast<dvfs_rail *>(reinterpret_cast<u8 *>(ptr) - offsetof(dvfs_rail, freq));
+
+        R_UNLESS(entry->id      == 1,        ldr::ResultInvalidCpuFreqVddEntry());
+        R_UNLESS(entry->min_mv  == 250'000,  ldr::ResultInvalidCpuFreqVddEntry());
+        R_UNLESS(entry->step_mv == 5000,     ldr::ResultInvalidCpuFreqVddEntry());
+        R_UNLESS(entry->max_mv  == 1525'000, ldr::ResultInvalidCpuFreqVddEntry());
+
+        if (C.marikoCpuUVHigh) {
+            PATCH_OFFSET(ptr, CapCpuClock());
+        } else {
+            PATCH_OFFSET(ptr, GetDvfsTableLastEntry(C.marikoCpuDvfsTable)->freq);
+        }
+
+        R_SUCCEED();
+    }
+
+    Result CpuVoltDVFS(u32 *ptr) {
+        CvbMeta *cpuCvbMeta = reinterpret_cast<CvbMeta *>(reinterpret_cast<u8 *>(ptr) - offsetof(CvbMeta, vmin));
+
+        R_UNLESS(cpuCvbMeta->highVmin     == CpuHighVminOfficial, ldr::ResultInvalidCpuMinVolt());
+        R_UNLESS(cpuCvbMeta->unkStepMaybe == 38,                  ldr::ResultInvalidCpuMinVolt());
+        R_UNLESS(cpuCvbMeta->vmax         == CpuVoltOfficial,     ldr::ResultInvalidCpuMinVolt());
+        R_UNLESS(cpuCvbMeta->unkScale2    == 1000,                ldr::ResultInvalidCpuMinVolt());
+        R_UNLESS(cpuCvbMeta->speedoScale  == 100,                 ldr::ResultInvalidCpuMinVolt());
+        R_UNLESS(cpuCvbMeta->voltageScale == 1000,                ldr::ResultInvalidCpuMinVolt());
+        R_UNLESS(cpuCvbMeta->unkZero5     == 0,                   ldr::ResultInvalidCpuMinVolt());
+
+        if (C.marikoCpuLowVmin) {
+            PATCH_OFFSET(&(cpuCvbMeta->vmin), C.marikoCpuLowVmin);
+        }
+
+        if (C.marikoCpuHighVmin) {
+            PATCH_OFFSET(&(cpuCvbMeta->highVmin), C.marikoCpuHighVmin);
+        }
+
+        if (C.marikoCpuMaxVolt) {
+            PATCH_OFFSET(&(cpuCvbMeta->vmax), C.marikoCpuMaxVolt);
+        }
+
+        R_SUCCEED();
+    }
+
+    Result CpuVoltThermals(u32 *ptr) {
+        if (std::memcmp(ptr, cpuVoltThermalData, sizeof(cpuVoltThermalData))) {
+            R_THROW(ldr::ResultInvalidCpuMinVolt());
+        }
+
+        if (C.marikoCpuLowVmin) {
+            PATCH_OFFSET(ptr,     C.marikoCpuLowVmin);
+            PATCH_OFFSET(ptr + 3, C.marikoCpuLowVmin);
+        }
+
+        if (C.marikoCpuMaxVolt) {
+            PATCH_OFFSET(ptr - 2, C.marikoCpuMaxVolt);
+            PATCH_OFFSET(ptr - 5, C.marikoCpuMaxVolt);
+            PATCH_OFFSET(ptr + 1, C.marikoCpuMaxVolt);
+            PATCH_OFFSET(ptr + 4, C.marikoCpuMaxVolt);
+        }
+
+        R_SUCCEED();
+    }
+
+    Result CpuVoltDfll(u32 *ptr) {
+        CvbCpuDfllData *entry = reinterpret_cast<CvbCpuDfllData *>(ptr);
+
+        R_UNLESS(entry->tune0_low  == 0xFFCF,    ldr::ResultInvalidCpuVoltDfllEntry());
+        R_UNLESS(entry->tune0_high == 0x0,       ldr::ResultInvalidCpuVoltDfllEntry());
+        R_UNLESS(entry->tune1_low  == 0x12207FF, ldr::ResultInvalidCpuVoltDfllEntry());
+        R_UNLESS(entry->tune1_high == 0x3FFF7FF, ldr::ResultInvalidCpuVoltDfllEntry());
+
+        switch (C.marikoCpuUVLow) {
+            case 1:
+                PATCH_OFFSET(&(entry->tune0_low),  0xffa0);
+                PATCH_OFFSET(&(entry->tune0_high), 0xffff);
+                PATCH_OFFSET(&(entry->tune1_low),  0x21107ff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x0);
+                break;
+            case 2:
+                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
+                PATCH_OFFSET(&(entry->tune1_low),  0x21107ff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27207ff);
+                break;
+            case 3:
+                PATCH_OFFSET(&(entry->tune0_low),  0xffdf);
+                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
+                PATCH_OFFSET(&(entry->tune1_low),  0x21107ff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27307ff);
+                break;
+            case 4:
+                PATCH_OFFSET(&(entry->tune0_low),  0xffff);
+                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
+                PATCH_OFFSET(&(entry->tune1_low),  0x21107ff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27407ff);
+                break;
+            case 5:
+                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
+                PATCH_OFFSET(&(entry->tune1_low),  0x21607ff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27707ff);
+                break;
+            case 6:
+                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
+                PATCH_OFFSET(&(entry->tune1_low),  0x21607ff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27807ff);
+                break;
+            case 7:
+                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
+                PATCH_OFFSET(&(entry->tune1_low),  0x21607ff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27b07ff);
+                break;
+            case 8:
+                PATCH_OFFSET(&(entry->tune0_low),  0xdfff);
+                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
+                PATCH_OFFSET(&(entry->tune1_low),  0x21707ff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27b07ff);
+                break;
+            case 9:
+                PATCH_OFFSET(&(entry->tune0_low),  0xdfff);
+                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
+                PATCH_OFFSET(&(entry->tune1_low),  0x21707ff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27c07ff);
+                break;
+            case 10:
+                PATCH_OFFSET(&(entry->tune0_low),  0xdfff);
+                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
+                PATCH_OFFSET(&(entry->tune1_low),  0x21707ff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27d07ff);
+                break;
+            case 11:
+                PATCH_OFFSET(&(entry->tune0_low),  0xdfff);
+                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
+                PATCH_OFFSET(&(entry->tune1_low),  0x21707ff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27e07ff);
+                break;
+            case 12:
+                PATCH_OFFSET(&(entry->tune0_low),  0xdfff);
+                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
+                PATCH_OFFSET(&(entry->tune1_low),  0x21707ff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27f07ff);
+                break;
+            default:
+                break;
+        }
+
+        switch (C.marikoCpuUVHigh) {
+            case 1:
+                PATCH_OFFSET(&(entry->tune1_high), 0x0);
+                PATCH_OFFSET(&(entry->tune0_high), 0xffff);
+                break;
+            case 2:
+                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27207ff);
+                break;
+            case 3:
+                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27307ff);
+                break;
+            case 4:
+                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27407ff);
+                break;
+            case 5:
+                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27707ff);
+                break;
+            case 6:
+                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27807ff);
+                break;
+            case 7:
+            case 8:
+                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27b07ff);
+                break;
+            case 9:
+                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27c07ff);
+                break;
+            case 10:
+                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27d07ff);
+                break;
+            case 11:
+                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27e07ff);
+                break;
+            case 12:
+                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
+                PATCH_OFFSET(&(entry->tune1_high), 0x27f07ff);
+                break;
+            default:
+                break;
+        }
+
+        R_SUCCEED();
+    }
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/mariko/pcv_mariko_cpu.hpp

@@ -1,5 +1,11 @@
 /*
- * Copyright (c) Atmosphère-NX
+ * Copyright (C) Switch-OC-Suite
+ *
+ * Copyright (c) 2023 hanai3Bi
+ *
+ * Copyright (c) B3711
+ *
+ * Copyright (c) Souldbminer and Horizon OC Contributors
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -14,12 +20,15 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#define __ACCESS_TABLE_NAME__    EmcAccessTable2
-#define __ACCESS_TABLE_ADDRESS__ MemoryRegionPhysicalDeviceExternalMemoryController2.GetAddress()
-#define __ACCESS_TABLE_INC__     "secmon_emc_access_table_data.inc"
+#pragma once
 
-#include "secmon_define_access_table.inc"
+#include "../pcv.hpp"
 
-#undef __ACCESS_TABLE_INC__
-#undef __ACCESS_TABLE_ADDRESS__
-#undef __ACCESS_TABLE_NAME__
+namespace ams::ldr::hoc::pcv::mariko {
+
+    Result CpuFreqVdd(u32 *ptr);
+    Result CpuVoltDVFS(u32 *ptr);
+    Result CpuVoltThermals(u32 *ptr);
+    Result CpuVoltDfll(u32 *ptr);
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/mariko/pcv_mariko_gpu.cpp

@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) Switch-OC-Suite
+ *
+ * Copyright (c) 2023 hanai3Bi
+ *
+ * Copyright (c) B3711
+ *
+ * Copyright (c) Souldbminer and Horizon OC Contributors
+ *
+ * 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 "../pcv.hpp"
+#include "../pcv_asm.hpp"
+
+namespace ams::ldr::hoc::pcv::mariko {
+
+    Result GpuVoltDVFS(u32 *ptr) {
+        /* Check for valid pattern. */
+        for (size_t i = 0; i < std::size(gpuDVFSPattern); ++i) {
+            if (*(ptr + i + 1) != gpuDVFSPattern[i]) {
+                R_THROW(ldr::ResultInvalidGpuDvfs());
+            }
+        }
+
+        /* Default value is 1050mV. */
+        if (C.marikoGpuVmax) {
+            PATCH_OFFSET(ptr + 1, C.marikoGpuVmax);
+        }
+
+        if (C.marikoGpuVmin) {
+            PATCH_OFFSET(ptr, C.marikoGpuVmin);
+        }
+
+        R_SUCCEED();
+    }
+
+    Result GpuVoltThermals(u32 *ptr) {
+        if (std::memcmp(ptr - 3, gpuVoltThermalPattern, sizeof(gpuVoltThermalPattern))) {
+            R_THROW(ldr::ResultInvalidGpuDvfs());
+        }
+
+        // if (C.marikoGpuBootVolt) {
+        //     PATCH_OFFSET(ptr - 3, C.marikoGpuBootVolt);
+        // }
+
+        if (C.marikoGpuVmin) {
+            PATCH_OFFSET(ptr,      C.marikoGpuVmin);
+            PATCH_OFFSET(ptr +  3, C.marikoGpuVmin);
+            PATCH_OFFSET(ptr +  6, C.marikoGpuVmin);
+            PATCH_OFFSET(ptr +  9, C.marikoGpuVmin);
+            PATCH_OFFSET(ptr + 12, C.marikoGpuVmin);
+        }
+
+        R_SUCCEED();
+    }
+
+    Result GpuFreqMaxAsm(u32 *ptr32) {
+        // Check if both two instructions match the pattern
+        u32 ins1 = *ptr32, ins2 = *(ptr32 + 1);
+        if (!(asm_compare_no_rd(ins1, GpuAsmPattern[0]) && asm_compare_no_rd(ins2, GpuAsmPattern[1]))) {
+            R_THROW(ldr::ResultInvalidGpuFreqMaxPattern());
+        }
+
+        // Both instructions should operate on the same register
+        u8 rd = asm_get_rd(ins1);
+        if (rd != asm_get_rd(ins2)) {
+            R_THROW(ldr::ResultInvalidGpuFreqMaxPattern());
+        }
+
+        u32 max_clock;
+        switch (C.marikoGpuUV) {
+        case 0:
+            max_clock = GetDvfsTableLastEntry(C.marikoGpuDvfsTable)->freq;
+            break;
+        case 1:
+            max_clock = GetDvfsTableLastEntry(C.marikoGpuDvfsTableSLT)->freq;
+            break;
+        case 2:
+            max_clock = GetDvfsTableLastEntry(C.marikoGpuDvfsTableHiOPT)->freq;
+            break;
+        case 3:
+            max_clock = GetDvfsTableLastEntry(C.marikoGpuDvfsTableHiOPT15)->freq;
+            break;
+        case 4:
+            max_clock = GetDvfsTableLastEntry(C.marikoGpuDvfsTableHighUV)->freq;
+            break;
+        default:
+            max_clock = GetDvfsTableLastEntry(C.marikoGpuDvfsTableHiOPT)->freq;
+            break;
+        }
+
+        u32 asm_patch[2] = {
+            asm_set_rd(asm_set_imm16(GpuAsmPattern[0], max_clock), rd),
+            asm_set_rd(asm_set_imm16(GpuAsmPattern[1], max_clock >> 16), rd)
+        };
+
+        PATCH_OFFSET(ptr32,     asm_patch[0]);
+        PATCH_OFFSET(ptr32 + 1, asm_patch[1]);
+
+        R_SUCCEED();
+    }
+
+    Result GpuFreqPllMax(u32 *ptr) {
+        clk_pll_param *entry = reinterpret_cast<clk_pll_param *>(ptr);
+
+        // All zero except for freq
+        for (size_t i = 1; i < sizeof(clk_pll_param) / sizeof(u32); i++) {
+            R_UNLESS(*(ptr + i) == 0, ldr::ResultInvalidGpuPllEntry());
+        }
+
+        // Double the max clk simply
+        u32 max_clk = entry->freq * 2;
+        entry->freq = max_clk;
+        R_SUCCEED();
+    }
+
+    Result GpuFreqPllLimit(u32 *ptr) {
+        u32 prev_freq = *(ptr - 1);
+
+        if (prev_freq != 128000 && prev_freq != 1300000 && prev_freq != 76800) {
+            R_THROW(ldr::ResultInvalidGpuPllEntry());
+        }
+
+        PATCH_OFFSET(ptr, 3600000);
+
+        R_SUCCEED();
+    }
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/mariko/pcv_mariko_gpu.hpp

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) Switch-OC-Suite
+ *
+ * Copyright (c) 2023 hanai3Bi
+ *
+ * Copyright (c) B3711
+ *
+ * Copyright (c) Souldbminer and Horizon OC Contributors
+ *
+ * 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 "../pcv.hpp"
+
+namespace ams::ldr::hoc::pcv::mariko {
+
+    Result GpuVoltDVFS(u32 *ptr);
+    Result GpuVoltThermals(u32 *ptr);
+    Result GpuFreqMaxAsm(u32 *ptr32);
+    Result GpuFreqPllMax(u32 *ptr);
+    Result GpuFreqPllLimit(u32 *ptr);
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/mariko/pcv_mariko_mtc.cpp

@@ -0,0 +1,676 @@
+/*
+ * Copyright (C) Switch-OC-Suite
+ *
+ * Copyright (c) 2023 hanai3Bi
+ *
+ * Copyright (c) B3711
+ *
+ * Copyright (c) Souldbminer and Horizon OC Contributors
+ *
+ * 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 "../pcv.hpp"
+#include "../../mtc_timing_value.hpp"
+#include "calculate_timings_mariko.hpp"
+
+namespace ams::ldr::hoc::pcv::mariko {
+
+    namespace {
+        std::vector<u32> newEmcList;
+    }
+
+    void MemMtcTableAutoAdjust(MarikoMtcTable *table) {
+        /* Official Tegra X1 TRM, sign up for nvidia developer program (free) to download:
+         *     https://developer.nvidia.com/embedded/dlc/tegra-x1-technical-reference-manual
+         *     Section 18.11.1:  MC Registers
+         *     Section 18.11.2: EMC Registers
+         */
+
+        #define WRITE_PARAM_ALL_REG(TABLE, PARAM, VALUE) \
+            TABLE->burst_regs.PARAM = VALUE;             \
+            TABLE->shadow_regs_ca_train.PARAM   = VALUE; \
+            TABLE->shadow_regs_rdwr_train.PARAM = VALUE;
+
+        const double tCK_avg = 1000'000.0 / table->rate_khz;
+
+        #define GET_CYCLE_CEIL(PARAM) u32(CEIL(double(PARAM) / tCK_avg))
+
+        /* Ram power down       */
+        /* B31: DRAM_CLKSTOP_PD */
+        /* B30: DRAM_CLKSTOP_SR */
+        /* B29: DRAM_ACPD       */
+        if (C.hpMode) {
+            WRITE_PARAM_ALL_REG(table, emc_cfg, 0x13200000);
+        } else {
+            WRITE_PARAM_ALL_REG(table, emc_cfg, 0xF3200000);
+        }
+
+        u32 trefbw = refresh_raw + 0x40;
+        trefbw     = MIN(trefbw, static_cast<u32>(0x3FFF));
+
+        const u32 dyn_self_ref_control = (static_cast<u32>(7605.0 / tCK_avg) + 260) | (table->burst_regs.emc_dyn_self_ref_control & 0xffff0000);
+
+        CalculateTimings(tCK_avg, table->rate_khz);
+
+        WRITE_PARAM_ALL_REG(table, emc_rd_rcd, GET_CYCLE_CEIL(tRCD));
+        WRITE_PARAM_ALL_REG(table, emc_wr_rcd, GET_CYCLE_CEIL(tRCD));
+        WRITE_PARAM_ALL_REG(table, emc_rc, MIN(GET_CYCLE_CEIL(tRC), static_cast<u32>(0xB9)));
+        WRITE_PARAM_ALL_REG(table, emc_ras, MIN(GET_CYCLE_CEIL(tRAS), static_cast<u32>(0x7F)));
+        WRITE_PARAM_ALL_REG(table, emc_rrd, GET_CYCLE_CEIL(tRRD));
+        WRITE_PARAM_ALL_REG(table, emc_rfcpb, GET_CYCLE_CEIL(tRFCpb));
+        WRITE_PARAM_ALL_REG(table, emc_rfc, GET_CYCLE_CEIL(tRFCab));
+        WRITE_PARAM_ALL_REG(table, emc_rp, GET_CYCLE_CEIL(tRPpb));
+        WRITE_PARAM_ALL_REG(table, emc_txsr, MIN(GET_CYCLE_CEIL(tXSR), static_cast<u32>(0x3fe)));
+        WRITE_PARAM_ALL_REG(table, emc_txsrdll, MIN(GET_CYCLE_CEIL(tXSR), static_cast<u32>(0x3fe)));
+        WRITE_PARAM_ALL_REG(table, emc_tfaw, GET_CYCLE_CEIL(tFAW));
+        WRITE_PARAM_ALL_REG(table, emc_trpab, MIN(GET_CYCLE_CEIL(tRPab), static_cast<u32>(0x3F)));
+        WRITE_PARAM_ALL_REG(table, emc_tckesr, GET_CYCLE_CEIL(tSR));
+        WRITE_PARAM_ALL_REG(table, emc_tcke, GET_CYCLE_CEIL(7.425) + 2);
+        WRITE_PARAM_ALL_REG(table, emc_tpd, GET_CYCLE_CEIL(tXP));
+        WRITE_PARAM_ALL_REG(table, emc_tclkstop, tCLKSTOP);
+        WRITE_PARAM_ALL_REG(table, emc_r2p, tR2P);
+        WRITE_PARAM_ALL_REG(table, emc_r2w, tR2W);
+        WRITE_PARAM_ALL_REG(table, emc_trtm, tRTM);
+        WRITE_PARAM_ALL_REG(table, emc_tratm, tRATM);
+        WRITE_PARAM_ALL_REG(table, emc_w2p, tW2P);
+        WRITE_PARAM_ALL_REG(table, emc_w2r, tW2R);
+        WRITE_PARAM_ALL_REG(table, emc_twtm, tWTM);
+        WRITE_PARAM_ALL_REG(table, emc_twatm, tWATM);
+        WRITE_PARAM_ALL_REG(table, emc_rext, rext);
+        WRITE_PARAM_ALL_REG(table, emc_wext, (table->rate_khz >= 2533000) ? 0x19 : 0x16);
+        WRITE_PARAM_ALL_REG(table, emc_refresh, refresh_raw);
+        WRITE_PARAM_ALL_REG(table, emc_pre_refresh_req_cnt, refresh_raw / 4);
+        WRITE_PARAM_ALL_REG(table, emc_trefbw, trefbw);
+        WRITE_PARAM_ALL_REG(table, emc_dyn_self_ref_control, dyn_self_ref_control);
+        WRITE_PARAM_ALL_REG(table, emc_pdex2wr, pdex2rw);
+        WRITE_PARAM_ALL_REG(table, emc_pdex2rd, pdex2rw);
+        WRITE_PARAM_ALL_REG(table, emc_pchg2pden, GET_CYCLE_CEIL(1.763));
+        WRITE_PARAM_ALL_REG(table, emc_ar2pden, GET_CYCLE_CEIL(1.75));
+        WRITE_PARAM_ALL_REG(table, emc_pdex2cke, GET_CYCLE_CEIL(1.05));
+        WRITE_PARAM_ALL_REG(table, emc_act2pden, GET_CYCLE_CEIL(14.0));
+        WRITE_PARAM_ALL_REG(table, emc_cke2pden, GET_CYCLE_CEIL(8.499));
+        WRITE_PARAM_ALL_REG(table, emc_pdex2mrr, GET_CYCLE_CEIL(pdex2mrr));
+        WRITE_PARAM_ALL_REG(table, emc_rw2pden, tWTPDEN);
+        WRITE_PARAM_ALL_REG(table, emc_einput, einput);
+        WRITE_PARAM_ALL_REG(table, emc_einput_duration, einput_duration);
+        WRITE_PARAM_ALL_REG(table, emc_obdly, obdly);
+        WRITE_PARAM_ALL_REG(table, emc_ibdly, ibdly);
+        WRITE_PARAM_ALL_REG(table, emc_wdv_mask, wdv);
+        WRITE_PARAM_ALL_REG(table, emc_quse_width, quse_width);
+        WRITE_PARAM_ALL_REG(table, emc_quse, quse);
+        WRITE_PARAM_ALL_REG(table, emc_wdv, wdv);
+        WRITE_PARAM_ALL_REG(table, emc_wsv, wsv);
+        WRITE_PARAM_ALL_REG(table, emc_wev, wev);
+        WRITE_PARAM_ALL_REG(table, emc_qrst, qrst);
+        WRITE_PARAM_ALL_REG(table, emc_tr_qrst, qrst);
+        WRITE_PARAM_ALL_REG(table, emc_qsafe, qsafe);
+        WRITE_PARAM_ALL_REG(table, emc_tr_qsafe, qsafe);
+        WRITE_PARAM_ALL_REG(table, emc_tr_qpop, qpop);
+        WRITE_PARAM_ALL_REG(table, emc_qpop, qpop);
+        WRITE_PARAM_ALL_REG(table, emc_rdv, rdv);
+        WRITE_PARAM_ALL_REG(table, emc_tr_rdv_mask, rdv + 2);
+        WRITE_PARAM_ALL_REG(table, emc_rdv_early, rdv - 2);
+        WRITE_PARAM_ALL_REG(table, emc_rdv_early_mask, rdv);
+        WRITE_PARAM_ALL_REG(table, emc_rdv_mask, rdv + 2);
+        WRITE_PARAM_ALL_REG(table, emc_tr_rdv, rdv);
+        WRITE_PARAM_ALL_REG(table, emc_cmd_brlshft_2, 0x24);
+        WRITE_PARAM_ALL_REG(table, emc_cmd_brlshft_3, 0x24);
+
+        /* This needs some clean up. */
+        constexpr double MC_ARB_DIV = 4.0;
+        constexpr u32 MC_ARB_SFA    = 2;
+
+        table->burst_mc_regs.mc_emem_arb_cfg            = table->rate_khz             / (33.3 * 1000) / MC_ARB_DIV;
+        table->burst_mc_regs.mc_emem_arb_timing_rcd     = CEIL(GET_CYCLE_CEIL(tRCD)   / MC_ARB_DIV) - 2;
+        table->burst_mc_regs.mc_emem_arb_timing_rp      = CEIL(GET_CYCLE_CEIL(tRPpb)  / MC_ARB_DIV) - 1;
+        table->burst_mc_regs.mc_emem_arb_timing_rc      = CEIL(GET_CYCLE_CEIL(tRC)    / MC_ARB_DIV) - 1;
+        table->burst_mc_regs.mc_emem_arb_timing_ras     = CEIL(GET_CYCLE_CEIL(tRAS)   / MC_ARB_DIV) - 2;
+        table->burst_mc_regs.mc_emem_arb_timing_faw     = CEIL(GET_CYCLE_CEIL(tFAW)   / MC_ARB_DIV) - 1;
+        table->burst_mc_regs.mc_emem_arb_timing_rrd     = CEIL(GET_CYCLE_CEIL(tRRD)   / MC_ARB_DIV) - 1;
+        table->burst_mc_regs.mc_emem_arb_timing_rfcpb   = CEIL(GET_CYCLE_CEIL(tRFCpb) / MC_ARB_DIV) - 1;
+        table->burst_mc_regs.mc_emem_arb_timing_rap2pre = CEIL(tR2P / MC_ARB_DIV);
+        table->burst_mc_regs.mc_emem_arb_timing_wap2pre = CEIL(tW2P / MC_ARB_DIV) + MC_ARB_SFA;
+
+        /* Two consecutive reads between two different dram modules. */
+        /* Only above 1 for 8gb ram. */
+        if (table->burst_mc_regs.mc_emem_arb_timing_r2r > 1) {
+            table->burst_mc_regs.mc_emem_arb_timing_r2r = CEIL(table->burst_regs.emc_rext / 4) - 1 + MC_ARB_SFA;
+        }
+
+        /* Same as r2r but for write. */
+        if (table->burst_mc_regs.mc_emem_arb_timing_w2w > 1) {
+            table->burst_mc_regs.mc_emem_arb_timing_w2w = CEIL(table->burst_regs.emc_wext / MC_ARB_DIV) - 1 + MC_ARB_SFA;
+        }
+
+        table->burst_mc_regs.mc_emem_arb_timing_r2w = CEIL(tR2W / MC_ARB_DIV) - 1 + MC_ARB_SFA;
+        table->burst_mc_regs.mc_emem_arb_timing_w2r = CEIL(tW2R / MC_ARB_DIV) - 1 + MC_ARB_SFA;
+
+        u32 da_turns = 0;
+        da_turns |= u8(table->burst_mc_regs.mc_emem_arb_timing_r2w / 2) << 16;
+        da_turns |= u8(table->burst_mc_regs.mc_emem_arb_timing_w2r / 2) << 24;
+        table->burst_mc_regs.mc_emem_arb_da_turns = da_turns;
+
+        u32 da_covers = 0;
+        u8 r_cover = (table->burst_mc_regs.mc_emem_arb_timing_rap2pre + table->burst_mc_regs.mc_emem_arb_timing_rp + table->burst_mc_regs.mc_emem_arb_timing_rcd) / 2;
+        u8 w_cover = (table->burst_mc_regs.mc_emem_arb_timing_wap2pre + table->burst_mc_regs.mc_emem_arb_timing_rp + table->burst_mc_regs.mc_emem_arb_timing_rcd) / 2;
+        da_covers |= (table->burst_mc_regs.mc_emem_arb_timing_rc / 2);
+        da_covers |= (r_cover << 8);
+        da_covers |= (w_cover << 16);
+        table->burst_mc_regs.mc_emem_arb_da_covers = da_covers;
+
+        constexpr u32 AtomsPerDvfsPulse      = 0x7;
+        constexpr u32 McEmcSameFreq          = 0x0;
+        const u32 expiringSoonSlackThreshold = [&] {
+            switch (table->rate_khz) {
+                case 2966000:
+                case 3100000:
+                case 3133000:
+                case 3200000:
+                    return 0x12u;
+                default:
+                    return 0x13u;
+            }
+        }();
+
+        const     u32 priorityInversionIsoThreshold = GET_CYCLE_CEIL(7.5);
+        constexpr u32 EmcReqB2bXfer                 = 0x0;
+        const     u32 priorityInversionThreshold    = GET_CYCLE_CEIL(22.5);
+        const     u32 bc2aaHoldoffThreshold         = table->burst_mc_regs.mc_emem_arb_timing_rc + 1;
+
+        const u32 mc_emem_arb_misc0 = (AtomsPerDvfsPulse << 28) | (McEmcSameFreq << 27) | (expiringSoonSlackThreshold << 21) | (priorityInversionIsoThreshold << 16) | (EmcReqB2bXfer << 15) | (priorityInversionThreshold << 8) | (bc2aaHoldoffThreshold << 0);
+        table->burst_mc_regs.mc_emem_arb_misc0 = mc_emem_arb_misc0;
+
+        table->la_scale_regs.mc_mll_mpcorer_ptsa_rate = 0x115;
+
+        if (table->rate_khz >= 2133000) {
+            table->la_scale_regs.mc_ftop_ptsa_rate = 0x1F;
+        } else {
+            table->la_scale_regs.mc_ftop_ptsa_rate = 0x1B;
+        }
+
+        table->la_scale_regs.mc_ptsa_grant_decrement = 0x17ff;
+
+        constexpr u32 MaskHigh = 0xFF00FFFF;
+        constexpr u32 Mask2    = 0xFFFFFF00;
+        constexpr u32 Mask3    = 0xFF00FF00;
+
+        const u32 allowance1 = static_cast<u32>(0x32000 / (table->rate_khz / 1000)) & 0xFF;
+        const u32 allowance2 = static_cast<u32>(0x9C40  / (table->rate_khz / 1000)) & 0xFF;
+        const u32 allowance3 = static_cast<u32>(0xB540  / (table->rate_khz / 1000)) & 0xFF;
+        const u32 allowance4 = static_cast<u32>(0x9600  / (table->rate_khz / 1000)) & 0xFF;
+        const u32 allowance5 = static_cast<u32>(0x8980  / (table->rate_khz / 1000)) & 0xFF;
+
+        table->la_scale_regs.mc_latency_allowance_xusb_0    =              (table->la_scale_regs.mc_latency_allowance_xusb_0    & MaskHigh) | (allowance1 << 16);
+        table->la_scale_regs.mc_latency_allowance_xusb_1    =              (table->la_scale_regs.mc_latency_allowance_xusb_1    & MaskHigh) | (allowance1 << 16);
+        table->la_scale_regs.mc_latency_allowance_tsec_0    =              (table->la_scale_regs.mc_latency_allowance_tsec_0    & MaskHigh) | (allowance1 << 16);
+        table->la_scale_regs.mc_latency_allowance_sdmmcaa_0 =              (table->la_scale_regs.mc_latency_allowance_sdmmcaa_0 & MaskHigh) | (allowance1 << 16);
+        table->la_scale_regs.mc_latency_allowance_sdmmcab_0 =              (table->la_scale_regs.mc_latency_allowance_sdmmcab_0 & MaskHigh) | (allowance1 << 16);
+        table->la_scale_regs.mc_latency_allowance_sdmmc_0   =              (table->la_scale_regs.mc_latency_allowance_sdmmc_0   & MaskHigh) | (allowance1 << 16);
+        table->la_scale_regs.mc_latency_allowance_sdmmca_0  =              (table->la_scale_regs.mc_latency_allowance_sdmmca_0  & MaskHigh) | (allowance1 << 16);
+        table->la_scale_regs.mc_latency_allowance_ppcs_1    =              (table->la_scale_regs.mc_latency_allowance_ppcs_1    & MaskHigh) | (allowance1 << 16);
+        table->la_scale_regs.mc_latency_allowance_nvdec_0   =              (table->la_scale_regs.mc_latency_allowance_nvdec_0   & MaskHigh) | (allowance1 << 16);
+        table->la_scale_regs.mc_latency_allowance_mpcore_0  =              (table->la_scale_regs.mc_latency_allowance_mpcore_0  & MaskHigh) | (allowance1 << 16);
+        table->la_scale_regs.mc_latency_allowance_avpc_0    =              (table->la_scale_regs.mc_latency_allowance_avpc_0    & MaskHigh) | (allowance1 << 16);
+        table->la_scale_regs.mc_latency_allowance_isp2_1    = allowance1 | (table->la_scale_regs.mc_latency_allowance_isp2_1    & Mask3)    | (allowance1 << 16);
+        table->la_scale_regs.mc_latency_allowance_gpu_0     = allowance2 | (table->la_scale_regs.mc_latency_allowance_gpu_0     & Mask3)    | (allowance1 << 16);
+        table->la_scale_regs.mc_latency_allowance_gpu2_0    = allowance2 | (table->la_scale_regs.mc_latency_allowance_gpu2_0    & Mask3)    | (allowance1 << 16);
+        table->la_scale_regs.mc_latency_allowance_vic_0     = allowance3 | (table->la_scale_regs.mc_latency_allowance_vic_0     & Mask3)    | (allowance1 << 16);
+        table->la_scale_regs.mc_latency_allowance_nvenc_0   = allowance4 | (table->la_scale_regs.mc_latency_allowance_nvenc_0   & Mask3)    | (allowance1 << 16);
+        table->la_scale_regs.mc_latency_allowance_hc_0      =              (table->la_scale_regs.mc_latency_allowance_hc_0      & Mask2)    |  allowance5;
+        table->la_scale_regs.mc_latency_allowance_hc_1      =              (table->la_scale_regs.mc_latency_allowance_hc_1      & Mask2)    |  allowance1;
+        table->la_scale_regs.mc_latency_allowance_vi2_0     =              (table->la_scale_regs.mc_latency_allowance_vi2_0     & Mask2)    |  allowance1;
+
+        table->dram_timings.t_rp  = tRP_values[0];
+        const u32 tRFCabStock     = tRFC_values[0] * 2;
+        table->dram_timings.t_rfc = tRFCabStock;
+
+        table->dram_timings.rl = RL;
+        table->emc_mrw2        = (table->emc_mrw2 & ~0xFFu) | static_cast<u32>(mrw2);
+        table->emc_mrw         = (table->emc_mrw  & ~0x70u) | 0x40; /* nWR */
+        table->emc_cfg_2       = 0x11083D;
+    }
+
+    void MemMtcPllmbDivisor(MarikoMtcTable *table) {
+        constexpr u32 PllOscInKHz   = 38400;
+        constexpr u32 PllOscHalfKHz = 19200;
+
+        double target_freq_d = static_cast<double>(table->rate_khz);
+
+        s32 divm_candidate_half = static_cast<u8>(table->rate_khz / PllOscHalfKHz);
+
+        bool remainder_check = (table->rate_khz - PllOscInKHz * (table->rate_khz / PllOscInKHz)) > (table->rate_khz - PllOscHalfKHz * divm_candidate_half) && static_cast<int>(((target_freq_d / PllOscHalfKHz - divm_candidate_half - 0.5) * 8192.0)) != 0;
+
+        u32 divm_final    = remainder_check + 1;
+        table->pllmb_divm = divm_final;
+
+        double div_step_d = static_cast<double>(PllOscInKHz) / divm_final;
+        s32 divn_integer  = static_cast<u8>(table->rate_khz  / div_step_d);
+        table->pllmb_divn = divn_integer;
+
+        u32 divn_fraction = static_cast<s32>((target_freq_d / div_step_d - divn_integer - 0.5) * 8192.0);
+
+        u32 actual_freq_khz = static_cast<u32>((divn_integer + 0.5 + divn_fraction * 0.000122070312) * div_step_d);
+
+        if (table->rate_khz - 2366001 < 133999) {
+            s32 divn_fraction_ssc = static_cast<s32>((actual_freq_khz * 0.997 / div_step_d - divn_integer - 0.5) * 8192.0);
+
+            double delta_scaled = (0.3 / div_step_d + 0.3 / div_step_d) * (divn_fraction - divn_fraction_ssc);
+            s32 delta_int       = static_cast<s32>(delta_scaled);
+            double delta_frac   = delta_scaled - delta_int;
+
+            u32 setup_value = 0;
+            if (delta_frac <= 0.5) {
+                double round_val = (delta_int + ROUND(delta_frac + delta_frac)) ? 0.5 : 0.0;
+                setup_value      = ROUND(delta_frac + delta_frac) ? static_cast<u32>(round_val + round_val) | 0x1000 : static_cast<u32>(round_val);
+            } else {
+                s32 frac_doubled = ROUND(delta_frac - 0.5 + delta_frac - 0.5);
+                double round_val = 1.0;
+                setup_value      = frac_doubled ? static_cast<u32>(round_val) : static_cast<u32>(round_val + round_val) | 0x1000;
+            }
+
+            u32 ctrl1 = static_cast<u16>(divn_fraction_ssc) | (static_cast<u16>(divn_fraction) << 16);
+            u32 ctrl2 = static_cast<u16>(divn_fraction)     | (static_cast<u16>(setup_value) << 16);
+
+            table->pllm_ss_ctrl1  = ctrl1;
+            table->pllm_ss_ctrl2  = ctrl2;
+            table->pllmb_ss_ctrl1 = ctrl1;
+            table->pllmb_ss_ctrl2 = ctrl2;
+        } else {
+            table->pllm_ss_cfg  &= 0xBFFFFFFF;
+            table->pllmb_ss_cfg &= 0xBFFFFFFF;
+
+            u64 pair     = (static_cast<u64>(divn_fraction) << 32) | static_cast<u64>(table->rate_khz);
+            u32 pll_misc = (table->pllm_ss_ctrl2 & 0xFFFF0000)     | static_cast<u32>((pair - actual_freq_khz) >> 32);
+
+            table->pllm_ss_ctrl2  = pll_misc;
+            table->pllmb_ss_ctrl2 = pll_misc;
+        }
+    }
+
+    void MtcGenerateJedecTable() {
+        const u32 jedecFreqs[] = { 1866000, 1996000, 2133000, 2400000, 2666000, 2933000, 3200000 };
+        constexpr u32 JedecFreqCount = std::size(jedecFreqs);
+
+        for (u32 i = 0; i < JedecFreqCount; ++i) {
+            if (jedecFreqs[i] <= C.marikoEmcMaxClock) {
+                newEmcList.push_back(jedecFreqs[i]);
+            } else {
+                break;
+            }
+        }
+
+        if (newEmcList.back() != C.marikoEmcMaxClock) {
+            newEmcList.push_back(static_cast<u32>(C.marikoEmcMaxClock));
+        }
+
+        newEmcList.resize(std::min(newEmcList.size(), EmcDvfsTableEntryLimit));
+    }
+
+    void MtcGenerate133StepTable() {
+        const u32 stepFreqs133[] = { 1733000, 1866000, 2000000, 2133000, 2266000, 2400000, 2533000, 2666000, 2800000, 2933000, 3066000, 3200000, 3333000, 3466000, }; // Avoid rounding issues
+        constexpr u32 StepFreqs133Size = std::size(stepFreqs133);
+
+        for (u32 i = 0; i < StepFreqs133Size; ++i) {
+            if (stepFreqs133[i] <= C.marikoEmcMaxClock) {
+                newEmcList.push_back(stepFreqs133[i]);
+            } else {
+                break;
+            }
+        }
+
+        if (newEmcList.back() != C.marikoEmcMaxClock) {
+            newEmcList.push_back(static_cast<u32>(C.marikoEmcMaxClock));
+        }
+
+        newEmcList.resize(std::min(newEmcList.size(), EmcDvfsTableEntryLimit));
+    }
+
+    void MtcGenerate33StepTable() {
+        /* ~33.33MHz but rounded*/
+        const u32 stepFreqs33[] = {
+            1633000, 1666000, 1700000, 1733000, 1766000, 1800000, 1833000, 1866000, 1900000, 1933000,
+            1966000, 2000000, 2033000, 2066000, 2100000, 2133000, 2166000, 2200000, 2233000, 2266000,
+            2300000, 2333000, 2366000, 2400000, 2433000, 2466000, 2500000, 2533000, 2566000, 2600000,
+            2633000, 2666000, 2700000, 2733000, 2766000, 2800000, 2833000, 2866000, 2900000, 2933000,
+            2966000, 3000000, 3033000, 3066000, 3100000, 3133000, 3166000, 3200000, 3233000, 3266000,
+            3300000, 3333000, 3366000, 3400000, 3433000, 3466000, 3500000,
+        };
+        constexpr u32 StepFreqs33Size = std::size(stepFreqs33);
+
+        for (u32 i = 0; i < StepFreqs33Size; ++i) {
+            if (stepFreqs33[i] <= C.marikoEmcMaxClock) {
+                newEmcList.push_back(stepFreqs33[i]);
+            } else {
+                break;
+            }
+        }
+
+        if (newEmcList.back() != C.marikoEmcMaxClock) {
+            newEmcList.push_back(static_cast<u32>(C.marikoEmcMaxClock));
+        }
+
+        newEmcList.resize(std::min(newEmcList.size(), EmcDvfsTableEntryLimit));
+    }
+
+    void MtcGenerateFreqTables() {
+        newEmcList.clear();
+        newEmcList.reserve(EmcDvfsTableEntryCount);
+        newEmcList.insert(newEmcList.end(), std::begin(EmcListDefault), std::end(EmcListDefault));
+
+        if (C.marikoEmcMaxClock <= EmcClkOSLimit) {
+            return;
+        }
+
+        u32 stepRate = 0;
+        switch (C.stepMode) {
+            case StepMode_33MHz:
+                MtcGenerate33StepTable();
+                return;
+            case StepMode_66MHz:
+                stepRate = 66667;
+                break;
+            case StepMode_100MHz:
+                stepRate = 100000;
+                break;
+            case StepMode_Jedec:
+                MtcGenerateJedecTable();
+                return;
+            case StepMode_133MHz:
+                MtcGenerate133StepTable();
+                return;
+            default:
+                stepRate = 66667;
+                break;
+        }
+
+        constexpr u32 RoundHz = 1000;
+        for (u32 stepIndex = 1;; ++stepIndex) {
+            u32 newFreq = EmcClkOSLimit + stepIndex * stepRate;
+            newFreq     = (newFreq / RoundHz) * RoundHz;
+            if (newFreq > C.marikoEmcMaxClock) {
+                if (newEmcList.back() != C.marikoEmcMaxClock) {
+                    newEmcList.push_back(static_cast<u32>(C.marikoEmcMaxClock));
+                }
+                break;
+            }
+            newEmcList.push_back(newFreq);
+        }
+
+        newEmcList.resize(std::min(newEmcList.size(), EmcDvfsTableEntryLimit));
+    }
+
+    Result VerifyMtcTable(MarikoMtcTable *tableStart, u32 expectedFreq) {
+        R_UNLESS(tableStart->rate_khz == expectedFreq,  ldr::ResultInvalidMtcTable());
+        R_UNLESS(tableStart->rev      == MTC_TABLE_REV, ldr::ResultInvalidMtcTable());
+
+        R_SUCCEED();
+    }
+
+    Result MtcValidateAllTables(MarikoMtcTable *tableStart, const u32 *validationList, u32 tableCount) {
+        for (u32 i = 0; i < tableCount; ++i) {
+            R_TRY(VerifyMtcTable(&tableStart[i], validationList[i]));
+        }
+
+        R_SUCCEED();
+    }
+
+    DramId GetDramId() {
+        u64 id64;
+        splGetConfig(SplConfigItem_DramId, &id64);
+        return static_cast<DramId>(id64);
+    }
+
+    MtcTableIndex GetMtcDramIndex(DramId dramId) {
+        for (u32 i = 0; i < std::size(mtcIndexTable); ++i) {
+            if (mtcIndexTable[i].dramId == dramId) {
+                return mtcIndexTable[i].index;
+            }
+        }
+
+        return MtcTableIndex_Invalid;
+    }
+
+    NORETURN void AbortInvalidMtc(const char *crashMsg) {
+        panic::SmcError(panic::Emc);
+        CRASH(crashMsg);
+    }
+
+    u32 GetMtcOffset(MtcTableIndex index) {
+        if (index < T210b0SdevEmcDvfsTableS4gb03) {
+            return index * mariko::MtcFullTableSize;
+        }
+
+        /* There are 2 erista mtc tables between T210b0SdevEmcDvfsTableS4gb01 and T210b0SdevEmcDvfsTableS4gb03, so we have to do this adjustment. */
+        return mariko::MtcFullTableSize * index + (2 * erista::MtcFullTableSize);
+    }
+
+    void PrepareMtcMemoryRegion(u8 *firstTable, MarikoMtcTable *usedTable) {
+        memmove(firstTable, usedTable, mariko::MtcFullTableSize);
+
+        /* Clear all other tables. */
+        /* 1 erista table is excluded because it's always before firstTable. */
+        /* We also exclude the used table obviously. */
+        constexpr size_t RemainingRegionSize = (mariko::MtcFullTableSize) * (mariko::MtcFullTableCount - 1) + (erista::MtcFullTableSize * (erista::MtcFullTableCount - 1));
+        memset(firstTable + mariko::MtcFullTableSize, 0, RemainingRegionSize);
+    }
+
+    void MtcExtendTables(MarikoMtcTable *table) {
+        for (u32 i = mariko::MtcTableCountDefault; i < newEmcList.size(); ++i) {
+            std::memcpy(&table[i], &table[i - 1], sizeof(MarikoMtcTable));
+            table[i].rate_khz = newEmcList[i];
+        }
+    }
+
+    Result MemFreqMtcTable(u32 *ptr) {
+        static const DramId dramId = [] {
+            DramId id = GetDramId();
+            id = HOAG_4GB_MICRON_MT53E512M32D2NP_046_WTF;
+            return id;
+        }();
+
+        static const MtcTableIndex mtcIndex = [] {
+            MtcTableIndex idx = GetMtcDramIndex(dramId);
+            /* If for some reason this happens, there is no chance of recovering this. */
+            if (idx == MtcTableIndex_Invalid) {
+                AbortInvalidMtc("Invalid dramId");
+            }
+            return idx;
+        }();
+
+        /* Offset to dram id specific mtc table. */
+        static const u32 mtcOffset = GetMtcOffset(mtcIndex);
+
+        /* Offset from 1600MHz pointer to 204Mhz table start. */
+        constexpr u32 StartAdjustment = offsetof(MarikoMtcTable, rate_khz) + sizeof(MarikoMtcTable) * (mariko::MtcTableCountDefault - 1);
+        u8 *startPtr = reinterpret_cast<u8 *>(ptr) - StartAdjustment;
+        MarikoMtcTable *table = reinterpret_cast<MarikoMtcTable *>(startPtr + mtcOffset);
+        R_TRY(MtcValidateAllTables(table, EmcListDefault, EmcListSizeDefault));
+
+        PrepareMtcMemoryRegion(startPtr, table);
+        table = reinterpret_cast<MarikoMtcTable *>(startPtr);
+
+        if (R_FAILED(MtcValidateAllTables(table, EmcListDefault, EmcListSizeDefault))) {
+            AbortInvalidMtc("Failed mtc validation");
+        }
+
+        if (C.marikoEmcMaxClock <= EmcClkOSLimit) {
+            R_SKIP();
+        }
+
+        MtcExtendTables(table);
+
+        if (R_FAILED(MtcValidateAllTables(table, newEmcList.data(), newEmcList.size()))) {
+            AbortInvalidMtc("Failed mtc validation");
+        }
+
+        for (u32 i = mariko::MtcTableCountDefault; i < newEmcList.size(); ++i) {
+            MemMtcTableAutoAdjust(&table[i]);
+            MemMtcPllmbDivisor(&table[i]);
+        }
+
+        R_SUCCEED();
+    }
+
+    Result MemFreqDvbTable(u32 *ptr) {
+        DvbEntry *default_end = reinterpret_cast<DvbEntry *>(ptr);
+        DvbEntry *new_start   = default_end + 1;
+
+        // Validate existing table
+        void *mem_dvb_table_head = reinterpret_cast<u8 *>(new_start) - sizeof(EmcDvbTableDefault);
+        bool validated           = std::memcmp(mem_dvb_table_head, EmcDvbTableDefault, sizeof(EmcDvbTableDefault)) == 0;
+        R_UNLESS(validated, ldr::ResultInvalidDvbTable());
+
+        if (C.marikoEmcMaxClock <= EmcClkOSLimit) {
+            R_SKIP();
+        }
+
+        s32 max0    = 1050;
+        s32 max1    = 1025;
+        s32 max2    = 1000;
+
+        if (C.marikoSocVmax && C.marikoSocVmax > 1000) {
+            max0 = C.marikoSocVmax;
+            max1 = C.marikoSocVmax;
+            max2 = C.marikoSocVmax;
+        }
+
+        constexpr s32 MinVolt = 637;
+
+        auto ClampVolt = [&](s32 value, s32 max, s32 voltAdd) {
+            return std::clamp(value + voltAdd, MinVolt, max);
+        };
+
+        auto DvbVolt = [&](s32 zero, s32 one, s32 two, u32 index) {
+            const s32 overrideVoltage = C.marikoSocVoltArray[index];
+            s32 voltAdd = 25 * C.emcDvbShift;
+
+            if (overrideVoltage) {
+                zero = one = two = overrideVoltage;
+                voltAdd = 0;
+            }
+
+            return std::array<s32, 3>{
+                ClampVolt(zero, max0, voltAdd),
+                ClampVolt(one,  max1, voltAdd),
+                ClampVolt(two,  max2, voltAdd)
+            };
+        };
+
+        #define DVB(v) \
+            static_cast<u32>((v)[0]), \
+            static_cast<u32>((v)[1]), \
+            static_cast<u32>((v)[2])
+
+        #define DVB_OC(one, zero, two, idx) \
+            DVB(DvbVolt(one, zero, two, idx))
+
+        DvbEntry emcDvbOcTableBrackets[] = {
+            {  204000, {         637,  637,  637,     }, },
+            { 1331200, {         650,  637,  637,     }, },
+            { 1600000, {         675,  650,  637,     }, },
+            { 1866000, { DVB_OC( 700,  675,  650,  0) }, },
+            { 2000000, { DVB_OC( 712,  687,  662,  1) }, },
+            { 2133000, { DVB_OC( 725,  700,  675,  2) }, },
+            { 2200000, { DVB_OC( 737,  712,  687,  3) }, },
+            { 2266000, { DVB_OC( 750,  725,  700,  4) }, },
+            { 2333000, { DVB_OC( 762,  737,  712,  5) }, },
+            { 2400000, { DVB_OC( 775,  750,  725,  6) }, },
+            { 2433000, { DVB_OC( 787,  762,  737,  7) }, },
+            { 2466000, { DVB_OC( 800,  775,  750,  8) }, },
+            { 2533000, { DVB_OC( 812,  787,  762,  9) }, },
+            { 2566000, { DVB_OC( 825,  800,  775, 10) }, },
+            { 2600000, { DVB_OC( 837,  812,  787, 11) }, },
+            { 2666000, { DVB_OC( 850,  825,  800, 12) }, },
+            { 2700000, { DVB_OC( 875,  850,  825, 13) }, },
+            { 2733000, { DVB_OC( 887,  862,  837, 14) }, },
+            { 2766000, { DVB_OC( 912,  887,  862, 15) }, },
+            { 2800000, { DVB_OC( 925,  900,  875, 16) }, },
+            { 2833000, { DVB_OC( 937,  912,  887, 17) }, },
+            { 2900000, { DVB_OC( 950,  925,  900, 18) }, },
+            { 2933000, { DVB_OC( 962,  937,  912, 19) }, },
+            { 3000000, { DVB_OC( 975,  950,  925, 20) }, },
+            { 3033000, { DVB_OC( 987,  962,  937, 21) }, },
+            { 3100000, { DVB_OC(1000,  975,  950, 22) }, },
+            { 3133000, { DVB_OC(1025, 1000,  975, 23) }, },
+            { 3166000, { DVB_OC(1037, 1012,  987, 24) }, },
+            { 3200000, { DVB_OC(1050, 1025, 1000, 25) }, },
+            { 3266000, { DVB_OC(1075, 1050, 1025, 26) }, },
+            { 3333000, { DVB_OC(1100, 1075, 1050, 27) }, },
+            {     ~0u, {                              }, },
+        };
+        #undef DVB
+        #undef DVB_OC
+
+        const size_t dvbCount = std::min(newEmcList.size(), DvbTableCapacity);
+        DvbEntry emcDvbTableOc[DvbTableCapacity] = {};
+
+        u32 bracketIndex = 0;
+        for (size_t i = 0; i < dvbCount; ++i) {
+            const u32 freq = (i == dvbCount - 1) ? static_cast<u32>(newEmcList.back()) : newEmcList[i];
+            while (freq >= emcDvbOcTableBrackets[bracketIndex + 1].freq) {
+                ++bracketIndex;
+            }
+
+            emcDvbTableOc[i].freq = freq;
+            std::memcpy(emcDvbTableOc[i].volt, emcDvbOcTableBrackets[bracketIndex].volt, sizeof(emcDvbTableOc[i].volt));
+        }
+
+        /* Clear the entire 32-entry region */
+        std::memset(mem_dvb_table_head, 0, DvbTableCapacity * sizeof(DvbEntry));
+        std::memcpy(mem_dvb_table_head, emcDvbTableOc, dvbCount * sizeof(DvbEntry));
+
+        R_SUCCEED();
+    }
+
+    Result MemFreqMax(u32 *ptr) {
+        if (C.marikoEmcMaxClock <= EmcClkOSLimit) {
+            R_SKIP();
+        }
+
+        PATCH_OFFSET(ptr, C.marikoEmcMaxClock);
+        R_SUCCEED();
+    }
+
+    Result MemMtcTableAsm(u32 *ptr) {
+        constexpr u32 AddpOffset = 1;
+        constexpr u32 BrOffset   = 12;
+        constexpr u32 MovOffset  = 10;
+
+        /* Ensure we don't dereference memory before nso start. */
+        R_UNLESS(ptr - BrOffset >= nsoStart, ldr::ResultInvalidMtcTablePattern());
+
+        u32 adrp = *(ptr - AddpOffset);
+        R_UNLESS(AsmCompareAdrpNoImm(adrp, MtcAdrpAsm), ldr::ResultInvalidMtcTablePattern());
+
+        /* We don't check for matching register because both registers must be x0 in order to pass the previous checks. */
+        /* The correct instructions will always be x0 since the mtcTable pointer is returned. */
+
+        /* Pray this does not break. */
+        u32 br = *(ptr - BrOffset);
+        R_UNLESS(AsmCompareBrNoRd(br, MtcBrAsm), ldr::ResultInvalidMtcTablePattern());
+
+        /* Pray this does not break either. */
+        u32 mov = *(ptr - MovOffset);
+        R_UNLESS(asm_compare_no_rd(mov, MtcMovAsm), ldr::ResultInvalidMtcTablePattern());
+
+        u8  movRd         = asm_get_rd(mov);
+        u32 movCountPatch = asm_set_rd(asm_set_imm16(MtcMovAsm, newEmcList.size()), movRd);
+
+        PATCH_OFFSET(ptr - BrOffset,  NopIns);
+        PATCH_OFFSET(ptr - MovOffset, movCountPatch);
+
+        R_SUCCEED();
+    }
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/mariko/pcv_mariko_mtc.hpp

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) Switch-OC-Suite
+ *
+ * Copyright (c) 2023 hanai3Bi
+ *
+ * Copyright (c) B3711
+ *
+ * Copyright (c) Souldbminer and Horizon OC Contributors
+ *
+ * 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 "../pcv.hpp"
+
+namespace ams::ldr::hoc::pcv::mariko {
+
+    void MtcGenerateFreqTables();
+    Result MemFreqMtcTable(u32 *ptr);
+    Result MemFreqDvbTable(u32 *ptr);
+    Result MemFreqMax(u32 *ptr);
+    Result MemMtcTableAsm(u32 *ptr);
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/mariko/timing_tables.cpp

@@ -1,47 +1,47 @@
-/*
- * Copyright (c) Lightos_
- *
- * 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 "../mtc_timing_value.hpp"
-#include "timing_tables.hpp"
-
-namespace ams::ldr::hoc::pcv::mariko {
-
-    const ReplacePatch g_rext_table[] = {
-        {2'133'000, 0x1A}, {2'166'000, 0x19}, {2'200'000, 0x19},
-        {2'233'000, 0x19}, {2'266'000, 0x1A}, {2'300'000, 0x1B},
-        {2'333'000, 0x1B}, {2'366'000, 0x1B}, {2'400'000, 0x1B},
-        {2'433'000, 0x1B}, {2'466'000, 0x1B}, {2'500'000, 0x1A},
-        {2'533'000, 0x1C}, {2'566'000, 0x1B}, {2'600'000, 0x1B},
-        {2'633'000, 0x1B}, {2'666'000, 0x1B}, {2'700'000, 0x1C},
-        {2'733'000, 0x1C}, {2'766'000, 0x1D}, {2'800'000, 0x1D},
-        {2'833'000, 0x1D}, {2'866'000, 0x1D}, {2'900'000, 0x1D},
-        {2'933'000, 0x1C}, {2'966'000, 0x1D}, {3'000'000, 0x1D},
-        {3'033'000, 0x1D}, {3'066'000, 0x1D}, {3'100'000, 0x1D},
-        {3'133'000, 0x1D}, {3'166'000, 0x1C}, {3'200'000, 0x1C},
-    };
-
-    const u32 g_rext_table_size = sizeof(g_rext_table) / sizeof(g_rext_table[0]);
-
-    const ReplacePatch *FindRext() {
-        for (u32 i = 0; i < g_rext_table_size; i++) {
-            if (g_rext_table[i].freq >= C.marikoEmcMaxClock) {
-                return &g_rext_table[i];
-            }
-        }
-        return nullptr;
-    }
-
-}
+/*
+ * Copyright (c) Lightos_
+ *
+ * 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 "../../oc_common.hpp"
+#include "timing_tables.hpp"
+
+namespace ams::ldr::hoc::pcv::mariko {
+
+    const ReplacePatch g_rext_table[] = {
+        {2'133'000, 0x1A}, {2'166'000, 0x19}, {2'200'000, 0x19},
+        {2'233'000, 0x19}, {2'266'000, 0x1A}, {2'300'000, 0x1B},
+        {2'333'000, 0x1B}, {2'366'000, 0x1B}, {2'400'000, 0x1B},
+        {2'433'000, 0x1B}, {2'466'000, 0x1B}, {2'500'000, 0x1A},
+        {2'533'000, 0x1C}, {2'566'000, 0x1B}, {2'600'000, 0x1B},
+        {2'633'000, 0x1B}, {2'666'000, 0x1B}, {2'700'000, 0x1C},
+        {2'733'000, 0x1C}, {2'766'000, 0x1D}, {2'800'000, 0x1D},
+        {2'833'000, 0x1D}, {2'866'000, 0x1D}, {2'900'000, 0x1D},
+        {2'933'000, 0x1C}, {2'966'000, 0x1D}, {3'000'000, 0x1D},
+        {3'033'000, 0x1D}, {3'066'000, 0x1D}, {3'100'000, 0x1D},
+        {3'133'000, 0x1D}, {3'166'000, 0x1C}, {3'200'000, 0x1C},
+    };
+
+    const u32 g_rext_table_size = sizeof(g_rext_table) / sizeof(g_rext_table[0]);
+
+    const ReplacePatch *FindRext() {
+        for (u32 i = 0; i < g_rext_table_size; i++) {
+            if (g_rext_table[i].freq >= C.marikoEmcMaxClock) {
+                return &g_rext_table[i];
+            }
+        }
+        return nullptr;
+    }
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/mariko/timing_tables.hpp

@@ -1,31 +1,31 @@
-/*
- * Copyright (c) Lightos_
- *
- * 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 "../mtc_timing_value.hpp"
-
-namespace ams::ldr::hoc::pcv::mariko {
-
-    struct ReplacePatch {
-        u32 freq;
-        u32 rext;
-    };
-
-    extern const ReplacePatch  g_rext_table[];
-    extern const u32           g_rext_table_size;
-    const        ReplacePatch *FindRext();
-
-}
+/*
+ * Copyright (c) Lightos_
+ *
+ * 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.hpp>
+
+namespace ams::ldr::hoc::pcv::mariko {
+
+    struct ReplacePatch {
+        u32 freq;
+        u32 rext;
+    };
+
+    extern const ReplacePatch  g_rext_table[];
+    extern const u32           g_rext_table_size;
+    const        ReplacePatch *FindRext();
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.cpp

@@ -22,8 +22,8 @@
 
 namespace ams::ldr::hoc::pcv {
 
-    Result MemFreqPllmLimit(u32* ptr) {
-        clk_pll_param* entry = reinterpret_cast<clk_pll_param *>(ptr);
+    Result MemFreqPllmLimit(u32 *ptr) {
+        clk_pll_param *entry = reinterpret_cast<clk_pll_param *>(ptr);
         R_UNLESS(entry->freq == entry->vco_max, ldr::ResultInvalidMemPllmEntry());
 
         // Double the max clk simply
@@ -33,27 +33,27 @@ namespace ams::ldr::hoc::pcv {
         R_SUCCEED();
     }
 
-    Result MemVoltHandler(u32* ptr) {
+    Result MemVoltHandler(u32 *ptr) {
         // ptr value might be default_uv or max_uv
-        regulator* entries[2] = {
+        regulator *entries[2] = {
             reinterpret_cast<regulator *>(reinterpret_cast<u8 *>(ptr) - offsetof(regulator, type_1.default_uv)),
             reinterpret_cast<regulator *>(reinterpret_cast<u8 *>(ptr) - offsetof(regulator, type_1.max_uv)),
         };
 
         constexpr u32 uv_step = 12'500;
-        constexpr u32 uv_min  = 600'000;
+        constexpr u32 uv_min = 600'000;
 
-        auto validator = [](regulator* entry) {
-            R_UNLESS(entry->id == 1,                    ldr::ResultInvalidRegulatorEntry());
-            R_UNLESS(entry->type == 1,                  ldr::ResultInvalidRegulatorEntry());
+        auto validator = [](regulator *entry) {
+            R_UNLESS(entry->id              == 1,       ldr::ResultInvalidRegulatorEntry());
+            R_UNLESS(entry->type            == 1,       ldr::ResultInvalidRegulatorEntry());
             R_UNLESS(entry->type_1.volt_reg == 0x17,    ldr::ResultInvalidRegulatorEntry());
-            R_UNLESS(entry->type_1.step_uv == uv_step,  ldr::ResultInvalidRegulatorEntry());
-            R_UNLESS(entry->type_1.min_uv == uv_min,    ldr::ResultInvalidRegulatorEntry());
+            R_UNLESS(entry->type_1.step_uv  == uv_step, ldr::ResultInvalidRegulatorEntry());
+            R_UNLESS(entry->type_1.min_uv   == uv_min,  ldr::ResultInvalidRegulatorEntry());
             R_SUCCEED();
         };
 
-        regulator* entry = nullptr;
-        for (auto& i : entries) {
+        regulator *entry = nullptr;
+        for (auto &i : entries) {
             if (R_SUCCEEDED(validator(i))) {
                 entry = i;
             }
@@ -67,7 +67,7 @@ namespace ams::ldr::hoc::pcv {
         }
 
         if (emc_uv % uv_step) {
-            emc_uv = emc_uv / uv_step * uv_step; // rounding
+            emc_uv = emc_uv / uv_step * uv_step;  // rounding
         }
 
         PATCH_OFFSET(ptr, emc_uv);
@@ -76,23 +76,25 @@ namespace ams::ldr::hoc::pcv {
     }
 
     void SafetyCheck() {
-        // if (C.custRev != CUST_REV)
-        //     CRASH("Triggered");
-
-        struct sValidator {
+        struct Validator {
             volatile u32 value;
             u32 min;
             u32 max;
+            u32 panic;
             bool value_required = false;
 
-            Result check() {
-                if (!value_required && !value)
+            Result Check() {
+                if (!value_required && !value) {
                     R_SUCCEED();
+                }
 
-                if (min && value < min)
+                if (min && value < min) {
                     R_THROW(ldr::ResultSafetyCheckFailure());
-                if (max && value > max)
+                }
+
+                if (max && value > max) {
                     R_THROW(ldr::ResultSafetyCheckFailure());
+                }
 
                 R_SUCCEED();
             }
@@ -100,29 +102,26 @@ namespace ams::ldr::hoc::pcv {
 
         u32 eristaCpuDvfsMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(C.eristaCpuDvfsTable)->freq);
         u32 marikoCpuDvfsMaxFreq;
-            if (C.marikoCpuUVHigh) {
-                marikoCpuDvfsMaxFreq = static_cast<u32>(
-                    GetDvfsTableLastEntry(C.marikoCpuDvfsTableSLT)->freq
-                );
-            } else {
-                marikoCpuDvfsMaxFreq = static_cast<u32>(
-                    GetDvfsTableLastEntry(C.marikoCpuDvfsTable)->freq
-                );
-            }
+        if (C.marikoCpuUVHigh) {
+            marikoCpuDvfsMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(C.marikoCpuDvfsTableSLT)->freq);
+        } else {
+            marikoCpuDvfsMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(C.marikoCpuDvfsTable)->freq);
+        }
+
         u32 eristaGpuDvfsMaxFreq;
         switch (C.eristaGpuUV) {
-        case 0:
-            eristaGpuDvfsMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(C.eristaGpuDvfsTable)->freq);
-            break;
-        case 1:
-            eristaGpuDvfsMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(C.eristaGpuDvfsTableSLT)->freq);
-            break;
-        case 2:
-            eristaGpuDvfsMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(C.eristaGpuDvfsTableHiOPT)->freq);
-            break;
-        default:
-            eristaGpuDvfsMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(C.eristaGpuDvfsTable)->freq);
-            break;
+            case 0:
+                eristaGpuDvfsMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(C.eristaGpuDvfsTable)->freq);
+                break;
+            case 1:
+                eristaGpuDvfsMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(C.eristaGpuDvfsTableSLT)->freq);
+                break;
+            case 2:
+                eristaGpuDvfsMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(C.eristaGpuDvfsTableHiOPT)->freq);
+                break;
+            default:
+                eristaGpuDvfsMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(C.eristaGpuDvfsTable)->freq);
+                break;
         }
 
         u32 marikoGpuDvfsMaxFreq;
@@ -136,43 +135,64 @@ namespace ams::ldr::hoc::pcv {
             case 2:
                 marikoGpuDvfsMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(C.marikoGpuDvfsTableHiOPT)->freq);
                 break;
+            case 3:
+                marikoGpuDvfsMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(C.marikoGpuDvfsTableHiOPT15)->freq);
+                break;
+            case 4:
+                marikoGpuDvfsMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(C.marikoGpuDvfsTableHighUV)->freq);
+                break;
             default:
-                marikoGpuDvfsMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(C.marikoGpuDvfsTable)->freq);
+                marikoGpuDvfsMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(C.marikoGpuDvfsTableHiOPT)->freq);
                 break;
         }
 
-        using namespace ams::ldr::hoc::pcv;
-        sValidator validators[] = {
-            { C.eristaCpuBoostClock, 1020'000, 2295'000, true },
-            { C.marikoCpuBoostClock, 1020'000, 2703'000, true },
-            { C.commonEmcMemVolt,                 912'500, 1350'000 }, // Official burst vmax for the RAMs is 1500mV
-            { C.eristaCpuMaxVolt,                    1000,     1260 },
-            { GET_MAX_OF_ARR(erista::maxEmcClocks), 1600'000, 2600'000 },
-            { C.marikoCpuMaxVolt,                    1000,     1200 },
-            { C.marikoEmcMaxClock,               1600'000, 3500'000 },
-            { C.marikoEmcVddqVolt,                250'000,  700'000 },
-            { eristaCpuDvfsMaxFreq,              1785'000, 2295'000 },
-            { marikoCpuDvfsMaxFreq,              1785'000, 2703'000 },
-            { eristaGpuDvfsMaxFreq,               768'000, 1152'000 },
-            { marikoGpuDvfsMaxFreq,               768'000, 1536'000 },
+        Validator validators[] = {
+            { C.eristaCpuBoostClock, 1020'000, 2397'000, panic::Cpu, true },
+            { C.marikoCpuBoostClock, 1020'000, 2703'000, panic::Cpu, true },
+            { C.eristaCpuMaxVolt,        1000,     1260, panic::Cpu,      },
+            { C.marikoCpuMaxVolt,        1000,     1200, panic::Cpu,      },
+            { eristaCpuDvfsMaxFreq,  1785'000, 2397'000, panic::Cpu,      },
+            { marikoCpuDvfsMaxFreq,  1785'000, 2703'000, panic::Cpu,      },
+            { C.commonEmcMemVolt,     912'500, 1350'000, panic::Emc,      }, /* Official vmax for the RAMs is 1400-1500mV */
+            { C.eristaEmcMaxClock,   1600'000, 2600'000, panic::Emc,      },
+            { C.marikoEmcMaxClock,   1600'000, 3500'000, panic::Emc,      },
+            { C.marikoEmcVddqVolt,    400'000,  750'000, panic::Emc,      },
+            { C.marikoSocVmax,           1000,     1200, panic::Emc,      },
+            { eristaGpuDvfsMaxFreq,   768'000, 1152'000, panic::Gpu,      },
+            { marikoGpuDvfsMaxFreq,   768'000, 1536'000, panic::Gpu,      },
+            { C.marikoGpuVmax,            800,      960, panic::Gpu,      },
         };
 
-        for (auto& i : validators) {
-            if (R_FAILED(i.check())) {
+        for (auto &v : validators) {
+            if (R_FAILED(v.Check())) {
+                panic::SmcError(v.panic);
                 CRASH("Validation FAIL");
             }
         }
     }
 
-    void Patch(uintptr_t mapped_nso, size_t nso_size) {
-        #ifdef ATMOSPHERE_IS_STRATOSPHERE
+    void WriteKipLoadToIram() {
+        const u32 hocMagic = 0x686F634D;
+        constexpr uintptr_t LoadMagicAddress = 0x4003DC00; /* Should be a pretty safe address. */
+        R_DISCARD(SmcCopyToIram(LoadMagicAddress, &hocMagic, sizeof(hocMagic)));
+    }
+
+    void Patch(uintptr_t mapped_nso, size_t nso_size, uintptr_t cave, size_t cave_size, uintptr_t nso_address, uintptr_t data_arena) {
         SafetyCheck();
+
+        Hooks().Initialize(mapped_nso, nso_address, cave, cave_size, data_arena);
+
+        g_pcv_cave      = cave;
+        g_pcv_cave_size = cave_size;
+
         bool isMariko = (spl::GetSocType() == spl::SocType_Mariko);
-        if (isMariko)
+        if (isMariko) {
             mariko::Patch(mapped_nso, nso_size);
-        else
+        } else {
             erista::Patch(mapped_nso, nso_size);
-        #endif
+        }
+
+        WriteKipLoadToIram();
     }
 
 }

Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.hpp

@@ -23,275 +23,17 @@
 #include "../oc_common.hpp"
 #include "pcv_common.hpp"
 
+#include "erista/pcv_erista_cpu.hpp"
+#include "erista/pcv_erista_gpu.hpp"
+#include "erista/pcv_erista_mtc.hpp"
+#include "erista/pcv_erista.hpp"
+
+#include "mariko/pcv_mariko.hpp"
+
+#include "pcv_hook.hpp"
+
 namespace ams::ldr::hoc::pcv {
 
-    namespace mariko {
-        constexpr cvb_entry_t CpuCvbTableDefault[] = {
-            {  204000, {  721589, -12695, 27 }, {         } },
-            {  306000, {  747134, -14195, 27 }, {         } },
-            {  408000, {  776324, -15705, 27 }, {         } },
-            {  510000, {  809160, -17205, 27 }, {         } },
-            {  612000, {  845641, -18715, 27 }, {         } },
-            {  714000, {  885768, -20215, 27 }, {         } },
-            {  816000, {  929540, -21725, 27 }, {         } },
-            {  918000, {  976958, -23225, 27 }, {         } },
-            { 1020000, { 1028021, -24725, 27 }, { 1120000 } },
-            { 1122000, { 1082730, -26235, 27 }, { 1120000 } },
-            { 1224000, { 1141084, -27735, 27 }, { 1120000 } },
-            { 1326000, { 1203084, -29245, 27 }, { 1120000 } },
-            { 1428000, { 1268729, -30745, 27 }, { 1120000 } },
-            { 1581000, { 1374032, -33005, 27 }, { 1120000 } },
-            { 1683000, { 1448791, -34505, 27 }, { 1120000 } },
-            { 1785000, { 1527196, -36015, 27 }, { 1120000 } },
-            { 1887000, { 1609246, -37515, 27 }, { 1120000 } },
-            { 1963500, { 1675751, -38635, 27 }, { 1120000 } },
-            {                                               },
-        };
-
-        constexpr u32 CpuClkOfficial  = 1963'500;
-        constexpr u32 CpuVoltOfficial = 1120;
-        constexpr u32 CpuVminOfficial = 620;
-
-        static const u32 cpuVoltagePatchValues[]  = { 850, 38, 1120, 1000, 100, 1000, 0 };
-        static const s32 cpuVoltagePatchOffsets[] = {  -2, -1,    5,    6,   7,    8, 9 };
-        static_assert(sizeof(cpuVoltagePatchValues) == sizeof(cpuVoltagePatchOffsets), "Invalid cpuVoltagePatch size");
-
-        static const u32 cpuVoltThermalData[] = { 620, 1120, 20000, 620, 1120, 70000, 950, 1132, 0, 950, 1227, 0 };
-
-        static const u32 allowedCpuMaxFrequencies[] = { 1'963'000, 2'091'000, 2'193'000, 2'295'000, 2'397'000, 2'499'000, 2'601'000, 2'703'000, };
-
-        constexpr cvb_entry_t GpuCvbTableDefault[] = {
-            // GPUB01_NA_CVB_TABLE
-            {   76800, {}, {  610000,                                 } },
-            {  153600, {}, {  610000,                                 } },
-            {  230400, {}, {  610000,                                 } },
-            {  307200, {}, {  610000,                                 } },
-            {  384000, {}, {  610000,                                 } },
-            {  460800, {}, {  610000,                                 } },
-            {  537600, {}, {  801688, -10900, -163, 298, -10599, 162, } },
-            {  614400, {}, {  824214,  -5743, -452, 238,  -6325,  81, } },
-            {  691200, {}, {  848830,  -3903, -552, 119,  -4030,  -2, } },
-            {  768000, {}, {  891575,  -4409, -584,   0,  -2849,  39, } },
-            {  844800, {}, {  940071,  -5367, -602, -60,    -63, -93, } },
-            {  921600, {}, {  986765,  -6637, -614, -179,  1905, -13, } },
-            {  998400, {}, { 1098475, -13529, -497, -179,  3626,   9, } },
-            { 1075200, {}, { 1163644, -12688, -648,    0,  1077,  40, } },
-            { 1152000, {}, { 1204812,  -9908, -830,    0,  1469, 110, } },
-            { 1228800, {}, { 1277303, -11675, -859,    0,  3722, 313, } },
-            { 1267200, {}, { 1335531, -12567, -867,    0,  3681, 559, } },
-            {                                                           },
-        };
-
-        constexpr u32 GpuClkPllMax = 1300'000'000;
-        constexpr u32 GpuClkPllLimit = 2'600'000;
-        constexpr u32 GpuVminOfficial = 610;
-
-        static const u32 gpuDVFSPattern[] = { 1050, 1000, 100, 1000, 10, };
-        static const u32 gpuVoltThermalPattern[] = { 800, 1120, 0, 610, 1120, 20000, 610, 1120, 30000, 610, 1120, 50000, 610, 1120, 70000, 610, 1120, 90000, };
-        static_assert(sizeof(gpuVoltThermalPattern) == 72, "Invalid gpuVoltThermalPattern");
-
-        struct SpeedoVminTable {
-            u32 speedo;
-            u32 voltage;
-        };
-
-        struct RamVminOffsetTable {
-            u32 maxClock;
-            u32 offset;
-        };
-
-        static const SpeedoVminTable vminTable[] {
-            {1400,       610}, // LOW SPEEDO -> use stock vmin
-            {1560,       590},
-            {1583,       570},
-            {1620,       565},
-            {1670,       560},
-            {1694,       555},
-            {1731,       550},
-            {1750,       540},
-            {0xFFFFFFFF, 530},
-        };
-
-        static const RamVminOffsetTable ramOffset[] {
-            {2400000,     5},
-            {2533000,    10},
-            {2666000,    15},
-            {2800000,    20},
-            {2933000,    25},
-            {3200000,    30},
-            {0xFFFFFFFF, 35},
-        };
-
-        /* GPU Max Clock asm Pattern:
-         *
-         * MOV W11, #0x1000 MOV (wide immediate)                0x1000                              0xB (11)
-         *  sf | opc |                 | hw  |                   imm16                        |      Rd
-         * #31 |30 29|28 27 26 25 24 23|22 21|20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5 |4  3  2  1  0
-         *   0 | 1 0 | 1  0  0  1  0  1| 0  0| 0  0  0  1  0  0  0  0  0  0  0  0  0  0  0  0 |0  1  0  1  1
-         *
-         * MOVK W11, #0xE, LSL#16     <shift>16                    0xE                              0xB (11)
-         *  sf | opc |                 | hw  |                   imm16                        |      Rd
-         * #31 |30 29|28 27 26 25 24 23|22 21|20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5 |4  3  2  1  0
-         *   0 | 1 1 | 1  0  0  1  0  1| 0  1| 0  0  0  0  0  0  0  0  0  0  0  0  1  1  1  0 |0  1  0  1  1
-         */
-
-        inline constexpr u32 asm_pattern[] = {0x52820000, 0x72A001C0};
-
-        inline auto asm_compare_no_rd = [](u32 ins1, u32 ins2) {
-            return ((ins1 ^ ins2) >> 5) == 0;
-        };
-
-        inline auto asm_get_rd = [](u32 ins) {
-            return ins & ((1 << 5) - 1);
-        };
-
-        inline auto asm_set_rd = [](u32 ins, u8 rd) {
-            return (ins & 0xFFFFFFE0) | (rd & 0x1F);
-        };
-
-        inline auto asm_set_imm16 = [](u32 ins, u16 imm) {
-            return (ins & 0xFFE0001F) | ((imm & 0xFFFF) << 5);
-        };
-
-        inline bool GpuMaxClockPatternFn(u32 *ptr32) {
-            return asm_compare_no_rd(*ptr32, asm_pattern[0]);
-        }
-
-        constexpr emc_dvb_dvfs_table_t EmcDvbTableDefault[] = {
-            {  204000, { 637, 637, 637, } },
-            {  408000, { 637, 637, 637, } },
-            {  800000, { 637, 637, 637, } },
-            { 1065600, { 637, 637, 637, } },
-            { 1331200, { 650, 637, 637, } },
-            { 1600000, { 675, 650, 637, } },
-        };
-
-        constexpr u32 EmcClkOSAlt = 1331'200;
-        constexpr u32 EmcClkPllmLimit = 2133'000'000;
-        constexpr u32 EmcVddqDefault = 600'000;
-        constexpr u32 MemVdd2Default = 1100'000;
-
-        constexpr u32 MTC_TABLE_REV = 3;
-
-        void Patch(uintptr_t mapped_nso, size_t nso_size);
-
-    }
-
-    namespace erista {
-        static u32 maxEmcClocks[] = { C.eristaEmcMaxClock2, C.eristaEmcMaxClock1, C.eristaEmcMaxClock, };
-        #define GET_MAX_OF_ARR(ARR) (*std::max_element(ARR, ARR + std::size(ARR)))
-
-        constexpr cvb_entry_t CpuCvbTableDefault[] = {
-            // CPU_PLL_CVB_TABLE_ODN
-            {  204000,  {721094}, {                         } },
-            {  306000,  {754040}, {                         } },
-            {  408000,  {786986}, {                         } },
-            {  510000,  {819932}, {                         } },
-            {  612000,  {852878}, {                         } },
-            {  714000,  {885824}, {                         } },
-            {  816000,  {918770}, {                         } },
-            {  918000,  {951716}, {                         } },
-            { 1020000,  {984662}, { -2875621,  358099, -8585} },
-            { 1122000, {1017608}, {   -52225,  104159, -2816} },
-            { 1224000, {1050554}, {  1076868,    8356,  -727} },
-            { 1326000, {1083500}, {  2208191,  -84659,  1240} },
-            { 1428000, {1116446}, {  2519460, -105063,  1611} },
-            { 1581000, {1130000}, {  2889664, -122173,  1834} },
-            { 1683000, {1168000}, {  5100873, -279186,  4747} },
-            { 1785000, {1227500}, {  5100873, -279186,  4747} },
-            {                                                 },
-        };
-
-        constexpr u32 CpuVoltOfficial = 1227;
-
-        constexpr u32 CpuVminOfficial = 825;
-
-        constexpr u32 CpuVoltL4T = 1257'000;
-
-        static const u32 cpuVoltDvfsPattern[] = { 1227, 1000, 100, 1000, 0 };
-        static_assert(sizeof(cpuVoltDvfsPattern) == 0x14, "invalid cpuVoltDvfsPattern size");
-
-        static const u32 cpuVoltageThermalPattern[] = { 950, 1132, 0, 950, 1227, 0, 825, 1227, 15000, 825, 1170, 60000, 825, 1132, 80000 };
-        static_assert(sizeof(cpuVoltageThermalPattern) == 0x3c, "invalid cpuVoltageThermalPattern size");
-        constexpr u32 GpuClkPllLimit = 2'600'000;
-        constexpr u32 GpuClkPllMax = 921'600'000;
-        constexpr u32 GpuVminOfficial = 810;
-
-        constexpr u16 CpuMinVolts[] = { 950, 850, 825, 810 };
-
-        inline bool CpuMaxVoltPatternFn(u32* ptr32) {
-            u32 val = *ptr32;
-            return (val == 1132 || val == 1170 || val == 1227);
-        }
-
-        static const u32 gpuVoltDvfsPattern[] = { 810, 1150, 1000, 100, 1000, 10, };
-        static_assert(sizeof(gpuVoltDvfsPattern) == (sizeof(u32) * 6), "Invalid gpuVoltDvfsPattern");
-
-        static const u32 gpuVoltThermalPattern[] = { 950, 1132, 0, 810, 1132, 15000, 810, 1132, 30000, 810, 1132, 50000, 810, 1132, 70000, 810, 1132, 105000 };
-        static_assert(sizeof(gpuVoltThermalPattern) == 0x48, "invalid gpuVoltageThermalPattern size");
-
-        /* GPU Max Clock asm Pattern:
-         *
-         * MOV W11, #0x1000 MOV (wide immediate)                0x1000                              0xB (11)
-         *  sf | opc |                 | hw  |                   imm16                        |      Rd
-         * #31 |30 29|28 27 26 25 24 23|22 21|20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5 |4  3  2  1  0
-         *   0 | 1 0 | 1  0  0  1  0  1| 0  0| 0  0  0  1  0  0  0  0  0  0  0  0  0  0  0  0 |0  1  0  1  1
-         *
-         * MOVK W11, #0xE, LSL#16     <shift>16                    0xE                              0xB (11)
-         *  sf | opc |                 | hw  |                   imm16                        |      Rd
-         * #31 |30 29|28 27 26 25 24 23|22 21|20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5 |4  3  2  1  0
-         *   0 | 1 1 | 1  0  0  1  0  1| 0  1| 0  0  0  0  0  0  0  0  0  0  0  0  1  1  1  0 |0  1  0  1  1
-         */
-        inline constexpr u32 asm_pattern[] = {
-            0x52820000, 0x72A001C0
-        };
-
-        inline auto asm_compare_no_rd = [](u32 ins1, u32 ins2) {
-            return ((ins1 ^ ins2) >> 5) == 0;
-        };
-
-        inline auto asm_get_rd = [](u32 ins) {
-            return ins & ((1 << 5) - 1);
-        };
-
-        inline auto asm_set_rd = [](u32 ins, u8 rd) {
-            return (ins & 0xFFFFFFE0) | (rd & 0x1F);
-        };
-
-        inline auto asm_set_imm16 = [](u32 ins, u16 imm) {
-            return (ins & 0xFFE0001F) | ((imm & 0xFFFF) << 5);
-        };
-
-        inline bool GpuMaxClockPatternFn(u32 *ptr32) {
-            return asm_compare_no_rd(*ptr32, asm_pattern[0]);
-        };
-
-        constexpr cvb_entry_t GpuCvbTableDefault[] = {
-            // NA_FREQ_CVB_TABLE
-            {  76800, {}, {  814294, 8144, -940, 808, -21583, 226, } },
-            { 153600, {}, {  856185, 8144, -940, 808, -21583, 226, } },
-            { 230400, {}, {  898077, 8144, -940, 808, -21583, 226, } },
-            { 307200, {}, {  939968, 8144, -940, 808, -21583, 226, } },
-            { 384000, {}, {  981860, 8144, -940, 808, -21583, 226, } },
-            { 460800, {}, { 1023751, 8144, -940, 808, -21583, 226, } },
-            { 537600, {}, { 1065642, 8144, -940, 808, -21583, 226, } },
-            { 614400, {}, { 1107534, 8144, -940, 808, -21583, 226, } },
-            { 691200, {}, { 1149425, 8144, -940, 808, -21583, 226, } },
-            { 768000, {}, { 1191317, 8144, -940, 808, -21583, 226, } },
-            { 844800, {}, { 1233208, 8144, -940, 808, -21583, 226, } },
-            { 921600, {}, { 1275100, 8144, -940, 808, -21583, 226, } },
-            {                                                        },
-        };
-
-        constexpr u32 MemVoltHOS = 1125'000;
-        constexpr u32 EmcClkMinFreq = 40800; /* 40.8 MHz table only exists on erista. */
-        constexpr u32 EmcClkPllmLimit = 1866'000'000;
-
-        constexpr u32 MTC_TABLE_REV = 7;
-
-        void Patch(uintptr_t mapped_nso, size_t nso_size);
-    }
-
     inline auto MatchesPattern = [](u32 *base, const auto &offsets, const auto &values) {
         for (size_t i = 0; i < std::size(values); ++i) {
             if (*(base + offsets[i]) != values[i]) {
@@ -383,33 +125,39 @@ namespace ams::ldr::hoc::pcv {
         cvb_entry_t *customize_table;
         if (isMariko) {
             switch (C.marikoGpuUV) {
-            case 0:
-                customize_table = const_cast<cvb_entry_t *>(C.marikoGpuDvfsTable);
-                break;
-            case 1:
-                customize_table = const_cast<cvb_entry_t *>(C.marikoGpuDvfsTableSLT);
-                break;
-            case 2:
-                customize_table = const_cast<cvb_entry_t *>(C.marikoGpuDvfsTableHiOPT);
-                break;
-            default:
-                customize_table = const_cast<cvb_entry_t *>(C.marikoGpuDvfsTable);
-                break;
+                case 0:
+                    customize_table = const_cast<cvb_entry_t *>(C.marikoGpuDvfsTable);
+                    break;
+                case 1:
+                    customize_table = const_cast<cvb_entry_t *>(C.marikoGpuDvfsTableSLT);
+                    break;
+                case 2:
+                    customize_table = const_cast<cvb_entry_t *>(C.marikoGpuDvfsTableHiOPT);
+                    break;
+                case 3:
+                    customize_table = const_cast<cvb_entry_t *>(C.marikoGpuDvfsTableHiOPT15);
+                    break;
+                case 4:
+                    customize_table = const_cast<cvb_entry_t *>(C.marikoGpuDvfsTableHighUV);
+                    break;
+                default:
+                    customize_table = const_cast<cvb_entry_t *>(C.marikoGpuDvfsTableHiOPT);
+                    break;
             }
         } else {
             switch (C.eristaGpuUV) {
-            case 0:
-                customize_table = const_cast<cvb_entry_t *>(C.eristaGpuDvfsTable);
-                break;
-            case 1:
-                customize_table = const_cast<cvb_entry_t *>(C.eristaGpuDvfsTableSLT);
-                break;
-            case 2:
-                customize_table = const_cast<cvb_entry_t *>(C.eristaGpuDvfsTableHiOPT);
-                break;
-            default:
-                customize_table = const_cast<cvb_entry_t *>(C.eristaGpuDvfsTable);
-                break;
+                case 0:
+                    customize_table = const_cast<cvb_entry_t *>(C.eristaGpuDvfsTable);
+                    break;
+                case 1:
+                    customize_table = const_cast<cvb_entry_t *>(C.eristaGpuDvfsTableSLT);
+                    break;
+                case 2:
+                    customize_table = const_cast<cvb_entry_t *>(C.eristaGpuDvfsTableHiOPT);
+                    break;
+                default:
+                    customize_table = const_cast<cvb_entry_t *>(C.eristaGpuDvfsTable);
+                    break;
             }
         }
 
@@ -434,22 +182,23 @@ namespace ams::ldr::hoc::pcv {
                     PATCH_OFFSET(&(entry->cvb_pll_param.c0), (C.marikoGpuVoltArray[i] * 1000));
                     ClearCvbPllEntry(entry);
                 } else {
-                    PATCH_OFFSET(&(entry->cvb_pll_param.c0), (entry->cvb_pll_param.c0 - C.commonGpuVoltOffset * 1000));
+                    PATCH_OFFSET(&(entry->cvb_pll_param.c0), (u32)((s32)entry->cvb_pll_param.c0 + C.commonGpuVoltOffset * 1000));
                 }
             } else {
                 if (C.eristaGpuVoltArray[i] != 0) {
                     PATCH_OFFSET(&(entry->cvb_pll_param.c0), (C.eristaGpuVoltArray[i] * 1000));
                     ClearCvbPllEntry(entry);
                 } else {
-                    PATCH_OFFSET(&(entry->cvb_pll_param.c0), (entry->cvb_pll_param.c0 - C.commonGpuVoltOffset * 1000));
+                    PATCH_OFFSET(&(entry->cvb_pll_param.c0), (u32)((s32)entry->cvb_pll_param.c0 + C.commonGpuVoltOffset * 1000));
                 }
             }
             ++entry;
         }
+
         if (C.commonGpuVoltOffset && !(isMariko ? C.marikoGpuUV : C.eristaGpuUV)) {
             cvb_entry_t *entry = static_cast<cvb_entry_t *>(gpu_cvb_table_head);
             for (size_t i = 0; i < customize_entry_count; ++i) {
-                PATCH_OFFSET(&(entry->cvb_pll_param.c0), (entry->cvb_pll_param.c0 - C.commonGpuVoltOffset * 1000));
+                PATCH_OFFSET(&(entry->cvb_pll_param.c0), (u32)((s32)entry->cvb_pll_param.c0 + C.commonGpuVoltOffset * 1000));
                 ++entry;
             }
         }
@@ -460,27 +209,11 @@ namespace ams::ldr::hoc::pcv {
     Result MemFreqPllmLimit(u32 *ptr);
     Result MemVoltHandler(u32 *ptr); // Used for Erista MEM Vdd2 + EMC Vddq or Mariko MEM Vdd2
 
-    template <typename T>
-    Result MemMtcCustomizeTable(T *dst, T *src) {
-        constexpr u32 mtc_magic = std::is_same_v<T, MarikoMtcTable> ? MARIKO_MTC_MAGIC : ERISTA_MTC_MAGIC;
-        R_UNLESS(src->rev == mtc_magic, ldr::ResultInvalidMtcMagic());
-
-        constexpr u32 ZERO_VAL = UINT32_MAX;
-        // Skip params from dvfs_ver to clock_src;
-        for (size_t offset = offsetof(T, clk_src_emc); offset < sizeof(T); offset += sizeof(u32)) {
-            u32 *src_ent = reinterpret_cast<u32 *>(reinterpret_cast<size_t>(src) + offset);
-            u32 *dst_ent = reinterpret_cast<u32 *>(reinterpret_cast<size_t>(dst) + offset);
-            u32 src_val = *src_ent;
-
-            if (src_val){
-                PATCH_OFFSET(dst_ent, src_val == ZERO_VAL ? 0 : src_val);
-            }
-        }
-
-        R_SUCCEED();
-    };
+    /* Extra pcv .bss */
+    constexpr size_t HocPcvScratchSize   = 0x2000;
+    constexpr size_t HocBusFreqBufOffset = 0x1000; /* start of the SOC bus region */
 
     void SafetyCheck();
-    void Patch(uintptr_t mapped_nso, size_t nso_size);
+    void Patch(uintptr_t mapped_nso, size_t nso_size, uintptr_t cave, size_t cave_size, uintptr_t nso_address, uintptr_t data_arena);
 
 }

Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_asm.hpp

@@ -0,0 +1,391 @@
+/*
+ * Copyright (C) Switch-OC-Suite
+ *
+ * Copyright (c) 2023 hanai3Bi
+ *
+ * Copyright (c) Souldbminer, Lightos_ and Horizon OC Contributors
+ *
+ * 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.hpp>
+
+namespace ams::ldr::hoc::pcv {
+
+    constexpr u32 NopIns = 0xD503201F;
+
+    template <typename Compare>
+    u32 *ScanAssembly(u32 *ptr, u32 scanLimit, u32 pattern, Compare comp) {
+        for (u32 i = 0; i < scanLimit; ++i) {
+            if (comp(pattern, ptr[i])) {
+                return ptr + i;
+            }
+        }
+        return nullptr;
+    }
+
+    inline auto asm_compare_no_rd = [](u32 ins1, u32 ins2) {
+        return ((ins1 ^ ins2) >> 5) == 0;
+    };
+
+    inline auto asm_get_rd = [](u32 ins) {
+        return ins & ((1 << 5) - 1);
+    };
+
+    /* Rn (bits 9:5) and Rm (bits 20:16) to get registers. */
+    inline auto AsmGetRn = [](u32 ins) -> u32 { return (ins >> 5) & 0x1Fu; };
+    inline auto AsmGetRm = [](u32 ins) -> u32 { return (ins >> 16) & 0x1Fu; };
+
+    /* Add (shifted register), 64-bit: sf=1 op=0 S=0 01011 shift(2) 0 Rm imm6 Rn Rd. */
+    inline auto AsmIsAddShiftedReg64 = [](u32 ins) {
+        return (ins & 0xFF200000u) == 0x8B000000u;
+    };
+
+    inline auto asm_set_rd = [](u32 ins, u8 rd) {
+        return (ins & 0xFFFFFFE0) | (rd & 0x1F);
+    };
+
+    inline auto asm_set_imm16 = [](u32 ins, u16 imm) {
+        return (ins & 0xFFE0001F) | ((imm & 0xFFFF) << 5);
+    };
+
+    inline auto AsmGetImm16 = [](u32 ins) {
+        return static_cast<u16>((ins >> 5) & 0xFFFF);
+    };
+
+    inline auto AsmCompareBrNoRd = [](u32 ins1, u32 ins2) {
+        constexpr u32 RegMask = ~(((1 << 5) - 1) << 5);
+        return ((ins1 & RegMask) ^ (ins2 & RegMask)) == 0;
+    };
+
+    inline auto AsmCompareAddNoImm12 = [](u32 ins1, u32 ins2) {
+        constexpr u32 Imm12Mask = ~(((1 << 12) - 1) << 10);
+        return ((ins1 & Imm12Mask) ^ (ins2 & Imm12Mask)) == 0;
+    };
+
+    inline auto AsmCompareAdrpNoImm = [](u32 ins1, u32 ins2) {
+        constexpr u32 ImmMask = ~((((1 << 2) - 1) << 29) | (((1 << 19) - 1) << 5));
+        return ((ins1 & ImmMask) ^ (ins2 & ImmMask)) == 0;
+    };
+
+    /* Csel (Conditional Select) */
+    /*
+        SF | Op | S  |                   | RM             | Cond        | 0  | 0  | Rn        | Rd
+        31 | 30 | 29 | 28 27 26 25 24 23 | 20 19 18 17 16 | 15 14 13 12 | 11 | 10 | 9 8 7 6 5 | 4 3 2 1 0
+    */
+    inline auto AsmCbzCompareOpcodeOnly = [](u32 ins1, u32 ins2) {
+        return ((ins1 ^ ins2) >> 24) == 0;
+    };
+
+    inline auto AsmBlCompareOpcodeOnly = [](u32 ins1, u32 ins2) {
+        return ((ins1 ^ ins2) >> 26) == 0;
+    };
+
+    inline auto AsmIsAdrX0 = [](u32 ins) {
+        return (ins & 0x9F00001Fu) == 0x10000000u;
+    };
+
+    inline auto AsmAdrTarget = [](u32 ins, uintptr_t pc) -> uintptr_t {
+        s64 imm = static_cast<s64>((((ins >> 5) & 0x7FFFFu) << 2) | ((ins >> 29) & 0x3u));
+        imm = (imm << 43) >> 43;
+        return static_cast<uintptr_t>(static_cast<s64>(pc) + imm);
+    };
+
+    /* adrp Rd, target */
+    inline auto AsmMakeAdrp = [](uintptr_t pc, uintptr_t target, u32 rd) -> u32 {
+        const s64 delta = static_cast<s64>(target & ~static_cast<uintptr_t>(0xFFF))
+                        - static_cast<s64>(pc & ~static_cast<uintptr_t>(0xFFF));
+        const u32 imm   = static_cast<u32>((delta >> 12) & 0x1FFFFF);   /* 21-bit page */
+        const u32 immlo = imm & 0x3;
+        const u32 immhi = (imm >> 2) & 0x7FFFF;
+        return 0x90000000u | (immlo << 29) | (immhi << 5) | (rd & 0x1Fu);
+    };
+
+    inline auto AsmSetAdrTarget = [](u32 ins, uintptr_t pc, uintptr_t target) -> u32 {
+        const s64 delta = static_cast<s64>(target) - static_cast<s64>(pc);
+        const u32 immlo = static_cast<u32>(delta & 0x3);
+        const u32 immhi = static_cast<u32>((delta >> 2) & 0x7FFFF);
+        return (ins & ~((0x3u << 29) | (0x7FFFFu << 5))) | (immlo << 29) | (immhi << 5);
+    };
+
+    /* adrp: bit31=1, bits 28:24 = 10000. */
+    inline auto AsmIsAdrp = [](u32 ins) -> bool {
+        return (ins & 0x9F000000u) == 0x90000000u;
+    };
+
+    inline auto AsmAdrpPageOffset = [](u32 ins) -> s64 {
+        s64 imm = static_cast<s64>((((ins >> 5) & 0x7FFFFu) << 2) | ((ins >> 29) & 0x3u));
+        imm = (imm << 43) >> 43;   /* sign-extend the 21-bit immediate */
+        return imm << 12;
+    };
+
+    /* add (immediate), 64-bit: sf=1 op=0 S=0 100010 sh imm12 Rn Rd. */
+    inline auto AsmIsAddImm64 = [](u32 ins) -> bool {
+        return (ins & 0xFF800000u) == 0x91000000u;
+    };
+
+    inline auto AsmGetImm12 = [](u32 ins) -> u32 {
+        return (ins >> 10) & 0xFFFu;
+    };
+
+    inline auto AsmMakeAddImm64 = [](u32 rd, u32 rn, u32 imm12) -> u32 {
+        return 0x91000000u | ((imm12 & 0xFFFu) << 10) | ((rn & 0x1Fu) << 5) | (rd & 0x1Fu);
+    };
+
+    /* movz Wd,#imm16 (no shift). */
+    inline auto AsmMakeMovzW = [](u32 rd, u16 imm16) -> u32 {
+        return 0x52800000u | (static_cast<u32>(imm16) << 5) | (rd & 0x1Fu);
+    };
+
+    /* mov Xd,Xm  ==  orr Xd,XZR,Xm. */
+    inline auto AsmMakeMovReg = [](u32 rd, u32 rm) -> u32 {
+        return 0xAA0003E0u | ((rm & 0x1Fu) << 16) | (rd & 0x1Fu);
+    };
+
+    /* ldr Xt,[Xn,#byteOff] */
+    inline auto AsmMakeLdrImm64 = [](u32 rt, u32 rn, u32 byteOff) -> u32 {
+        return 0xF9400000u | (((byteOff / 8u) & 0xFFFu) << 10) | ((rn & 0x1Fu) << 5) | (rt & 0x1Fu);
+    };
+
+    /* b <target> (PC-relative, +-128MB). */
+    inline auto AsmMakeB = [](uintptr_t pc, uintptr_t target) -> u32 {
+        const s64 off = (static_cast<s64>(target) - static_cast<s64>(pc)) >> 2;
+        return 0x14000000u | (static_cast<u32>(off) & 0x03FFFFFFu);
+    };
+
+    /* b.<cond> <target> (cond: LO/CC=0x3, LE=0xD, NE=0x1, ...). */
+    inline auto AsmMakeBCond = [](uintptr_t pc, uintptr_t target, u32 cond) -> u32 {
+        const s64 off = (static_cast<s64>(target) - static_cast<s64>(pc)) >> 2;
+        return 0x54000000u | ((static_cast<u32>(off) & 0x7FFFFu) << 5) | (cond & 0xFu);
+    };
+
+    /* sub Xd,Xn,#imm12 (shift 0). */
+    inline auto AsmMakeSubImm64 = [](u32 rd, u32 rn, u32 imm12) -> u32 {
+        return 0xD1000000u | ((imm12 & 0xFFFu) << 10) | ((rn & 0x1Fu) << 5) | (rd & 0x1Fu);
+    };
+
+    /* cmp Wn,#imm12  ==  subs WZR,Wn,#imm12. */
+    inline auto AsmMakeCmpImm32 = [](u32 rn, u32 imm12) -> u32 {
+        return 0x7100001Fu | ((imm12 & 0xFFFu) << 10) | ((rn & 0x1Fu) << 5);
+    };
+
+    /* str Wt,[Xn,#byteOff] (32-bit, unsigned scaled by 4). */
+    inline auto AsmMakeStrImm32 = [](u32 rt, u32 rn, u32 byteOff) -> u32 {
+        return 0xB9000000u | (((byteOff / 4u) & 0xFFFu) << 10) | ((rn & 0x1Fu) << 5) | (rt & 0x1Fu);
+    };
+
+    /* ldr Wt,[Xn,#byteOff] (32-bit, unsigned scaled by 4). */
+    inline auto AsmMakeLdrImm32 = [](u32 rt, u32 rn, u32 byteOff) -> u32 {
+        return 0xB9400000u | (((byteOff / 4u) & 0xFFFu) << 10) | ((rn & 0x1Fu) << 5) | (rt & 0x1Fu);
+    };
+
+    /* add Xd,Xn,Xm,LSL #shift (64-bit shifted register, shift 0-63). */
+    inline auto AsmMakeAddShiftedReg64 = [](u32 rd, u32 rn, u32 rm, u32 shift) -> u32 {
+        return 0x8B000000u | ((rm & 0x1Fu) << 16) | ((shift & 0x3Fu) << 10) | ((rn & 0x1Fu) << 5) | (rd & 0x1Fu);
+    };
+
+    /* stp Xt1,Xt2,[Xn,#imm]  (signed offset, scaled by 8). */
+    inline auto AsmMakeStpImm64 = [](u32 rt1, u32 rt2, u32 rn, s32 imm) -> u32 {
+        return 0xA9000000u | ((static_cast<u32>(imm / 8) & 0x7Fu) << 15) | ((rt2 & 0x1Fu) << 10) | ((rn & 0x1Fu) << 5) | (rt1 & 0x1Fu);
+    };
+
+    /* stp Qt1,Qt2,[Xn,#imm]  (128-bit SIMD, signed offset scaled by 16). */
+    inline auto AsmMakeStpqImm = [](u32 qt1, u32 qt2, u32 rn, s32 imm) -> u32 {
+        return 0xAD000000u | ((static_cast<u32>(imm / 16) & 0x7Fu) << 15) | ((qt2 & 0x1Fu) << 10) | ((rn & 0x1Fu) << 5) | (qt1 & 0x1Fu);
+    };
+
+    /* str Xt,[Xn,#byteOff]  (unsigned scaled by 8). */
+    inline auto AsmMakeStrImm64 = [](u32 rt, u32 rn, u32 byteOff) -> u32 {
+        return 0xF9000000u | (((byteOff / 8u) & 0xFFFu) << 10) | ((rn & 0x1Fu) << 5) | (rt & 0x1Fu);
+    };
+
+    /* movn Wd,#imm16 (no shift): loads ~imm16, e.g. movn Wd,#0x37 == -56. */
+    inline auto AsmMakeMovnW = [](u32 rd, u16 imm16) -> u32 {
+        return 0x12800000u | (static_cast<u32>(imm16) << 5) | (rd & 0x1Fu);
+    };
+
+    /* bl <target>  (PC-relative, +-128MB). */
+    inline auto AsmMakeBl = [](uintptr_t pc, uintptr_t target) -> u32 {
+        const s64 off = (static_cast<s64>(target) - static_cast<s64>(pc)) >> 2;
+        return 0x94000000u | (static_cast<u32>(off) & 0x03FFFFFFu);
+    };
+
+    /* svc #imm16. */
+    inline auto AsmMakeSvc = [](u16 imm16) -> u32 {
+        return 0xD4000001u | (static_cast<u32>(imm16) << 5);
+    };
+
+    constexpr u32 RetIns = 0xD65F03C0u; /* ret (x30) */
+
+    /* ldrb Wt,[Xn,#imm] (unsigned byte, scale 1). */
+    inline auto AsmMakeLdrbImm = [](u32 rt, u32 rn, u32 byteOff) -> u32 {
+        return 0x39400000u | ((byteOff & 0xFFFu) << 10) | ((rn & 0x1Fu) << 5) | (rt & 0x1Fu);
+    };
+
+    /* cbz Wt,<target>. */
+    inline auto AsmMakeCbz = [](uintptr_t pc, uintptr_t target, u32 rt) -> u32 {
+        const s64 off = (static_cast<s64>(target) - static_cast<s64>(pc)) >> 2;
+        return 0x34000000u | ((static_cast<u32>(off) & 0x7FFFFu) << 5) | (rt & 0x1Fu);
+    };
+
+    /* strb Wt,[Xn,#imm] (unsigned byte, scale 1). */
+    inline auto AsmMakeStrbImm = [](u32 rt, u32 rn, u32 byteOff) -> u32 {
+        return 0x39000000u | ((byteOff & 0xFFFu) << 10) | ((rn & 0x1Fu) << 5) | (rt & 0x1Fu);
+    };
+
+    /* mov Xd,X<rm>  ==  orr Xd,XZR,X<rm>  (matches any Rd). */
+    inline auto AsmIsMovReg = [](u32 ins, u32 rm) -> bool {
+        return (ins & 0xFFFFFFE0u) == (0xAA0003E0u | ((rm & 0x1Fu) << 16));
+    };
+
+    /* add Xd,sp,#imm12 (shift 0). */
+    inline auto AsmIsAddSpImm = [](u32 ins) -> bool {
+        return (ins & 0xFFC003E0u) == 0x910003E0u;
+    };
+
+    /* sub Xd,x29,#imm12 (shift 0). */
+    inline auto AsmIsSubX29Imm = [](u32 ins) -> bool {
+        return (ins & 0xFFC003E0u) == 0xD10003A0u;
+    };
+
+    inline auto AsmIsB     = [](u32 ins) -> bool { return (ins & 0xFC000000u) == 0x14000000u; }; /* b   */
+    inline auto AsmIsBl    = [](u32 ins) -> bool { return (ins & 0xFC000000u) == 0x94000000u; }; /* bl  */
+    inline auto AsmIsBCond = [](u32 ins) -> bool { return (ins & 0xFF000010u) == 0x54000000u; }; /* b.c */
+
+    /* ldr/str Xt,[Xn,#imm] (64-bit, unsigned scaled offset). */
+    inline auto AsmIsLdrImm64      = [](u32 ins) -> bool { return (ins & 0xFFC00000u) == 0xF9400000u; };
+    inline auto AsmIsStrImm64      = [](u32 ins) -> bool { return (ins & 0xFFC00000u) == 0xF9000000u; };
+    inline auto AsmGetLdStImm64Off = [](u32 ins) -> u32  { return ((ins >> 10) & 0xFFFu) * 8u; };
+
+    /* Byte target address of a b/bl at pc. */
+    inline auto AsmBranchTarget = [](u32 ins, uintptr_t pc) -> uintptr_t {
+        s64 off = static_cast<s64>((ins & 0x03FFFFFFu) << 2);
+        off = (off << 36) >> 36;   /* sign-extend the 28-bit branch offset */
+        return static_cast<uintptr_t>(static_cast<s64>(pc) + off);
+    };
+
+    /* Rewrite a scaled immediate-offset load/store (`op Wt,[Xn,#imm]`) into its register-offset form */
+    inline auto AsmSetLdStRegOffset = [](u32 ldstImm, u32 rm) -> u32 {
+        return (ldstImm & 0xC0C003FFu) | 0x38207800u | ((rm & 0x1Fu) << 16);
+    };
+
+    inline auto AsmIsLdpX = [](u32 ins) {
+        return (ins & 0xFE400000u) == 0xA8400000u;
+    };
+
+    inline bool AsmComparePrologue(u32 ins1, u32 ins2, u32 ins3, u32 cmp1, u32 cmp2, u32 cmp3) {
+        constexpr u32 StpImmMask = ~((((1u << 7) - 1u) << 15));
+
+        bool firstMatch = (ins1 & StpImmMask) == (cmp1 & StpImmMask);
+
+        constexpr u32 StpRegsImmMask = ~(((1u << 5) - 1u) |(((1u << 5) - 1u) << 10) | (((1u << 7) - 1u) << 15));
+
+        bool secondMatch = (ins2 & StpRegsImmMask) == (cmp2 & StpRegsImmMask);
+
+        constexpr u32 MovMask = ~((1u << 5) - 1u);
+
+        bool thirdMatch = (ins3 & MovMask) == (cmp3 & MovMask);
+
+        return firstMatch && secondMatch && thirdMatch;
+    }
+
+    inline auto AsmCompareCselNoReg = [](u32 ins1, u32 ins2) {
+        constexpr u32 ClearReg = ~(((1 << 10) - 1) | (((1 << 5) - 1) << 16));
+        return ((ins1 & ClearReg) ^ (ins2 & ClearReg)) == 0;
+    };
+
+    /* Mul */
+    /*
+        SF | Op54                 | Op31     | RM             | o0 | RA             | RN        | RD
+        31 | 30 29 28 27 26 25 24 | 23 22 21 | 20 19 18 17 16 | 15 | 14 13 12 11 10 | 9 8 7 6 5 | 4 3 2 1 0
+    */
+    inline auto AsmCompareMullNoReg = [](u32 ins1, u32 ins2) {
+        constexpr u32 ClearReg = ~(((1 << 10) - 1) | (((1 << 5) - 1) << 16));
+        return ((ins1 & ClearReg) ^ (ins2 & ClearReg)) == 0;
+    };
+
+    /* Mul */
+    /* MUL W11, W24, W26 */
+    /* multiplies by 1000, mV -> uV */
+    /*
+        SF | Op54                 | Op31     | RM             | o0 | RA             | RN        | RD
+        31 | 30 29 28 27 26 25 24 | 23 22 21 | 20 19 18 17 16 | 15 | 14 13 12 11 10 | 9 8 7 6 5 | 4 3 2 1 0
+    */
+    inline auto AsmGetMullRn = [](u32 ins) {
+        constexpr u32 Mask = ((1 << 5) - 1) << 5;
+        return (ins & Mask) >> 5;
+    };
+
+    inline auto AsmGetMullRm = [](u32 ins) {
+        constexpr u32 Mask = ((1 << 5) - 1) << 16;
+        return (ins & Mask) >> 16;
+    };
+
+    /* Subs (Shifted register) */
+    /*
+        SF | Op | S  |                | Shift | 0  | RM             | Imm6              | Rn        | Rd
+        31 | 30 | 29 | 28 27 26 25 24 | 23 22 | 21 | 20 19 18 17 16 | 15 14 13 12 11 10 | 9 8 7 6 5 | 4 3 2 1 0
+    */
+    inline auto AsmSubsSetRn = [](u32 ins, u8 rn) {
+        constexpr u32 RnMaskClear = ~(((1u << 5) - 1u) << 5);
+        constexpr u32 RnMaskSet = (1u << 5) - 1u;
+
+        return (ins & RnMaskClear) | ((static_cast<u32>(rn) & RnMaskSet) << 5);
+    };
+
+    /* Subs (Immediate) */
+
+    /*
+        SF | Op | S  |                   | Sh | Imm12                               | Rn        | Rd
+        31 | 30 | 29 | 28 27 26 25 24 23 | 22 | 21 20 19 18 17 16 15 14 13 12 11 10 | 9 8 7 6 5 | 4 3 2 1 0
+    */
+    inline auto AsmSubsSetImm12 = [](u32 ins, u16 imm12) {
+        constexpr u32 ClearMask    = ~(((1u << 12) - 1) << 10);
+        constexpr u32 SetImm12Mask =   ( 1u << 12) - 1;
+
+        return (ins & ClearMask) | ((imm12 & SetImm12Mask) << 10);
+    };
+
+    inline auto AsmSubsCompareNoReg = [](u32 ins1, u32 ins2) {
+        return ((ins1 ^ ins2) >> 10) == 0;
+    };
+
+    inline auto AsmCompareBrConNoImm19 = [](u32 ins1, u32 ins2) {
+        constexpr u32 ClearImm19 = ~(((1 << 19) - 1) << 5);
+        return (ins1 & ClearImm19) == (ins2 & ClearImm19);
+    };
+
+    inline bool AsmIsFramePush(u32 ins) {
+        constexpr u32 FramePushMask  = 0xFFC07FFF;
+        constexpr u32 FramePushValue = 0xA9807BFD;
+        return (ins & FramePushMask) == FramePushValue;
+    }
+
+    inline u32 *FindFnPrologue(u32 *ptr, u32 margin, u32 *nsoStart) {
+        for (u32 i = 0; i <= margin; ++i) {
+            u32 *candidate = ptr - i;
+            if (candidate < nsoStart) {
+                break;
+            }
+
+            if (AsmIsFramePush(*candidate)) {
+                return candidate;
+            }
+        }
+
+        return nullptr;
+    }
+
+}

Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_common.hpp

@@ -18,40 +18,66 @@
 
 #pragma once
 
+#include "../mtc_timing_table.hpp"
+
 namespace ams::ldr::hoc::pcv {
 
-    typedef struct cvb_coefficients {
+    struct cvb_coefficients {
         s32 c0 = 0;
         s32 c1 = 0;
         s32 c2 = 0;
         s32 c3 = 0;
         s32 c4 = 0;
         s32 c5 = 0;
-    } cvb_coefficients;
+    };
 
-    typedef struct cvb_entry_t {
+    struct cvb_entry_t {
         u64 freq;
         cvb_coefficients cvb_dfll_param;
         cvb_coefficients cvb_pll_param;
-    } cvb_entry_t;
+    };
     static_assert(sizeof(cvb_entry_t) == 0x38);
 
-    typedef struct cvb_cpu_dfll_data {
+    struct CvbCpuDfllData {
         u32 tune0_low;
         u32 tune0_high;
         u32 tune1_low;
         u32 tune1_high;
-        unsigned int tune_high_min_millivolts;
-        unsigned int tune_high_margin_millivolts;
-        unsigned long dvco_calibration_max;
-    } cvb_cpu_dfll_data;
+        u32 tune_high_min_millivolts;
+        u32 tune_high_margin_millivolts;
+        u64 dvco_calibration_max;
+    };
 
-    typedef struct emc_dvb_dvfs_table_t {
-        u64 freq;
-        s32 volt[4] = {0};
-    } emc_dvb_dvfs_table_t;
+    /*
+    struct CvbCpuDfllData {
+        u32 tune0_low;
+        u32 tune0_high;
+        u32 tune1_low;
+        u32 tune1_high;
+        u64 padding;
+        u64 dvco_calibration_max;
+    };
 
-    typedef struct __attribute__((packed)) div_nmp {
+    struct CpuCvbTable {
+        u64 socType;
+        CvbCpuDfllData dfllData;
+        u64 padding[3];
+        u64 unk;
+        u32 tune_high_min_millivolts;
+        u32 tune_high_margin_millivolts;
+        u32 vmin;
+        u32 padding_1[3];
+        u32 pll_min_millivolts;
+        u32 vmax;
+        u32 unkScale;
+        u32 speedoScale;
+        u32 voltageScale;
+        u32 zero;
+        cvb_entry_t cvb_entry[32];
+    };
+    */
+
+    struct __attribute__((packed)) div_nmp {
         u8 divn_shift;
         u8 divn_width;
         u8 divm_shift;
@@ -61,9 +87,9 @@ namespace ams::ldr::hoc::pcv {
         u8 override_divn_shift;
         u8 override_divm_shift;
         u8 override_divp_shift;
-    } div_nmp;
+    };
 
-    typedef struct __attribute__((packed)) clk_pll_param {
+    struct __attribute__((packed)) clk_pll_param {
         u32 freq;
         u32 input_min;
         u32 input_max;
@@ -76,10 +102,10 @@ namespace ams::ldr::hoc::pcv {
         u32 unk_0;
         struct div_nmp *div_nmp;
         u32 unk_1[4];
-        void (*unk_fn)(u64* unk_struct); // set_defaults?
-    } clk_pll_param;
+        void (*unk_fn)(u64 *unk_struct); // set_defaults?
+    };
 
-    typedef struct __attribute__((packed)) dvfs_rail {
+    struct __attribute__((packed)) dvfs_rail {
         u32 id;
         u32 unk_0[5];
         u32 freq;
@@ -89,11 +115,11 @@ namespace ams::ldr::hoc::pcv {
         u32 step_mv;
         u32 max_mv;
         u32 unk_2[11];
-    } dvfs_rail;
+    };
 
-    typedef struct __attribute__((packed)) regulator {
+    struct __attribute__((packed)) regulator {
         u64 id;
-        const char* name;
+        const char *name;
         u32 type;
         union {
             struct {
@@ -115,11 +141,30 @@ namespace ams::ldr::hoc::pcv {
             } type_2_3;
         };
         u32 unk_x[60];
-    } regulator;
+    };
     static_assert(sizeof(regulator) == 0x120);
 
-    constexpr u32 CpuClkOSLimit = 1785'000;
+    struct __attribute__((packed)) CvbMeta {
+        u64 socType;
+        CvbCpuDfllData dfllData; /* Maybe? */
+        u32 unkZero2[6];
+        u32 unkMagic;
+        u32 unkZero3;
+        u32 highVmin;
+        u32 unkStepMaybe;
+        u32 vmin;
+        u32 unkZero4[3];
+        u32 pllMinMilliVolts;
+        u32 vmax;
+        u32 unkScale2;
+        u32 speedoScale;
+        u32 voltageScale;
+        u32 unkZero5;
+    };
+    static_assert(sizeof(CvbMeta) == 0x78);
 
+    constexpr u32 CpuClkOSLimit = 1785'000;
+    constexpr u32 GpuClkOsLimit = 921'600;
     constexpr u32 EmcClkOSLimit = 1600'000;
 
     #define R_SKIP() R_SUCCEED()
@@ -128,12 +173,25 @@ namespace ams::ldr::hoc::pcv {
     constexpr size_t DvfsTableEntryCount = 32;
     constexpr size_t DvfsTableEntryLimit = DvfsTableEntryCount - 1;
 
+    // EMC-only limit.
+    constexpr size_t EmcDvfsTableEntryCount = 64;
+    constexpr size_t EmcDvfsTableEntryLimit = EmcDvfsTableEntryCount - 1;
+
+    // The pcv SoC-voltage DVB table is a fixed 32-entry region. (it doesn't need to be larger)
+    constexpr size_t DvbTableCapacity = 32;
+
+    // extra .bss location, 0 until Patch() runs.
+    inline uintptr_t g_pcv_scratch = 0;
+
+    inline uintptr_t g_pcv_cave      = 0;
+    inline size_t    g_pcv_cave_size = 0;
+
     template<typename T>
-    size_t GetDvfsTableEntryCount(T* table_head) {
+    size_t GetDvfsTableEntryCount(T *table_head) {
         using NT = std::remove_const_t<std::remove_volatile_t<T>>;
 
-        auto is_empty = [](NT* entry) {
-            uint8_t* m = reinterpret_cast<uint8_t *>(entry);
+        auto is_empty = [](NT *entry) {
+            u8 *m = reinterpret_cast<u8 *>(entry);
             for (size_t i = 0; i < sizeof(NT); i++) {
                 if (*(m + i)) {
                     return false;
@@ -142,7 +200,7 @@ namespace ams::ldr::hoc::pcv {
             return true;
         };
 
-        NT* table = const_cast<NT *>(table_head);
+        NT *table = const_cast<NT *>(table_head);
         size_t count = 0;
         while (count < DvfsTableEntryLimit) {
             if (is_empty(table++)) {
@@ -154,10 +212,10 @@ namespace ams::ldr::hoc::pcv {
     }
 
     template<typename T>
-    T* GetDvfsTableLastEntry(T* table_head) {
+    T *GetDvfsTableLastEntry(T *table_head) {
         using NT = std::remove_const_t<std::remove_volatile_t<T>>;
 
-        NT* table = const_cast<NT *>(table_head);
+        NT *table = const_cast<NT *>(table_head);
         size_t count = GetDvfsTableEntryCount(table_head);
         if (!count) {
             return nullptr;

Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_hook.hpp

@@ -0,0 +1,367 @@
+/*
+ * Copyright (c) Lightos_
+ *
+ * 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 "../oc_common.hpp"
+
+#define HOOK_PAYLOAD_FN __attribute__((section("hoc_hookpayload"), used, noinline, visibility("hidden")))
+
+/* Inline asm because fuck compilers: GCC refuses to put a variable and a function in the same section. */
+/* It wants alloc+write for one and alloc+exec for the other.                                           */
+/* You are supposed to be able to override that by writing the flags into the section name yourself,    */
+/* like section("hoc_hookpayload,\"ax\",%progbits"), instead of letting GCC pick them.                  */
+/* But GCC takes that whole string as the name and never reads the flags out of it, so it appends the   */
+/* ones it wanted anyway: the .section directive it emits ends up carrying two sets of flags, and the   */
+/* assembler rejects it. The failure lands in the generated assembly, not in anything we wrote.         */
+/* Therefore we must use inline assembly, which reaches the assembler exactly as written.               */
+#define DEFINE_HOOK_PAYLOAD_PTR(type, name)                     \
+    asm(".section hoc_hookpayload,\"ax\",%progbits\n"           \
+        ".balign 8\n"                                           \
+        ".global " #name "\n"                                   \
+        ".hidden " #name "\n"                                   \
+        #name ": .zero 8\n"                                     \
+        ".text\n");                                             \
+    extern "C" __attribute__((visibility("hidden"))) type *name
+
+#define DECLARE_HOOK_PAYLOAD_PTR(type, name)                    \
+    extern "C" __attribute__((visibility("hidden"))) type *name
+
+#define HOOK_PAYLOAD_PTR(type, name)                            \
+    ([]() -> type * {                                           \
+        type **_hoc_pp;                                         \
+        __asm__("adr %0, " #name : "=r"(_hoc_pp));              \
+        return *_hoc_pp;                                        \
+    }())
+
+extern "C" const u8 __start_hoc_hookpayload[];
+extern "C" const u8 __stop_hoc_hookpayload[];
+
+namespace ams::ldr::hoc::pcv {
+
+    constexpr size_t HookPageSize     = 0x1000;
+    constexpr size_t PcvDataArenaSize = 0x1000;
+
+    inline s64 SignExtend(u64 value, int bits) {
+        const int shift = 64 - bits;
+        return static_cast<s64>(value << shift) >> shift;
+    }
+
+    inline u32 EncodeRelBranch(u32 opc, uintptr_t site_va, uintptr_t target_va) {
+        const s64 delta = static_cast<s64>(target_va) - static_cast<s64>(site_va);
+        AMS_ABORT_UNLESS((delta & 0x3) == 0);
+        AMS_ABORT_UNLESS(delta >= -0x08000000 && delta <= 0x07FFFFFC);
+        return opc | (static_cast<u32>(delta >> 2) & 0x03FFFFFFu);
+    }
+
+    inline u32 EncodeB(uintptr_t site_va, uintptr_t target_va)  { return EncodeRelBranch(0x14000000u, site_va, target_va); }
+    inline u32 EncodeBL(uintptr_t site_va, uintptr_t target_va) { return EncodeRelBranch(0x94000000u, site_va, target_va); }
+
+    inline u32 EncodePairSp(bool load, u32 rt1, u32 rt2, s32 imm) {
+        const u32 base = load ? 0xA9400000u : 0xA9000000u;
+        const u32 imm7 = static_cast<u32>((imm / 8) & 0x7F);
+        return base | (imm7 << 15) | (rt2 << 10) | (31u << 5) | rt1;
+    }
+
+    inline u32 EncodeSpAdjust(bool sub, u32 imm12) {
+        const u32 base = sub ? 0xD1000000u : 0x91000000u;
+        return base | ((imm12 & 0xFFFu) << 10) | (31u << 5) | 31u;
+    }
+
+    inline Result RelocateInstruction(u32 insn, uintptr_t old_site_va, uintptr_t new_site_va, u32 *out) {
+        const u32 top6 = insn & 0xFC000000u;
+        if (top6 == 0x14000000u || top6 == 0x94000000u) {
+            const s64 old_imm      = SignExtend(static_cast<u64>(insn & 0x03FFFFFFu) << 2, 28);
+            const uintptr_t target = old_site_va + old_imm;
+            *out = EncodeRelBranch(top6, new_site_va, target);
+            R_SUCCEED();
+        }
+
+        R_UNLESS((insn & 0xFF000010u) != 0x54000000u, ldr::ResultHookRelocationUnsupported()); /* b.cond      */
+        R_UNLESS((insn & 0x7E000000u) != 0x34000000u, ldr::ResultHookRelocationUnsupported()); /* cbz/cbnz    */
+        R_UNLESS((insn & 0x7E000000u) != 0x36000000u, ldr::ResultHookRelocationUnsupported()); /* tbz/tbnz    */
+        R_UNLESS((insn & 0x1F000000u) != 0x10000000u, ldr::ResultHookRelocationUnsupported()); /* adr/adrp    */
+        R_UNLESS((insn & 0x3B000000u) != 0x18000000u, ldr::ResultHookRelocationUnsupported()); /* ldr literal */
+
+        *out = insn;
+        R_SUCCEED();
+    }
+
+    class HookContext {
+        private:
+            uintptr_t m_map_base   = 0; /* loader-side base of pcv's NSO mapping.    */
+            uintptr_t m_va_base    = 0; /* pcv-side base of the same memory.         */
+            uintptr_t m_cave       = 0; /* loader-side cave base. (0 if unavailable) */
+            size_t    m_cave_size  = 0;
+            uintptr_t m_payload    = 0; /* loader-side base of the payload copy. */
+            size_t    m_payload_sz = 0;
+            size_t    m_used       = 0;
+            uintptr_t m_data       = 0; /* loader-side data arena base, 0 if none. */
+            size_t    m_data_used  = 0;
+        public:
+            constexpr HookContext() = default;
+
+            void Initialize(uintptr_t map_base, uintptr_t va_base, uintptr_t cave, size_t cave_size, uintptr_t data) {
+                m_map_base   = map_base;
+                m_va_base    = va_base;
+                m_cave       = cave;
+                m_cave_size  = cave_size;
+                m_payload    = 0;
+                m_payload_sz = 0;
+                m_used       = 0;
+                m_data       = data;
+                m_data_used  = 0;
+            }
+
+            bool IsEnabled() const { return m_cave != 0 && m_cave_size != 0; }
+
+            Result CheckEnabled() const {
+                R_UNLESS(this->IsEnabled(), ldr::ResultHookUnavailable());
+                R_SUCCEED();
+            }
+
+            size_t CaveSize() const { return m_cave_size; }
+            size_t CaveUsed() const { return m_used; }
+            size_t CaveFree() const { return m_cave_size > m_used ? m_cave_size - m_used : 0; }
+
+            size_t DataSize() const { return m_data != 0 ? PcvDataArenaSize : 0; }
+            size_t DataUsed() const { return m_data_used; }
+            size_t DataFree() const { return this->DataSize() - m_data_used; }
+
+            /* Convert loader mapped address to pcv-side address. */
+            uintptr_t ToVa(const void *loader_ptr) const {
+                return m_va_base + (reinterpret_cast<uintptr_t>(loader_ptr) - m_map_base);
+            }
+
+            uintptr_t CaveVa() const { return ToVa(reinterpret_cast<const void *>(m_cave)); }
+
+            Result CopyPayload() {
+                R_TRY(this->CheckEnabled());
+
+                const size_t size = static_cast<size_t>(__stop_hoc_hookpayload - __start_hoc_hookpayload);
+
+                /*  Zero length: Linker garbage collected the payload .(happens when nothing references it) */
+                /* __start_ and _stop_ don't prevent this. */
+                /* Copying here would succeed at first but fail later by jumping to empty memory. */
+                R_UNLESS(size != 0,           ldr::ResultUninitializedPatcher());
+                R_UNLESS(size <= m_cave_size, ldr::ResultHookPayloadTooLarge());
+
+                m_payload    = m_cave;
+                m_payload_sz = size;
+                std::memcpy(reinterpret_cast<void *>(m_payload), __start_hoc_hookpayload, size);
+
+                m_used = util::AlignUp(size, sizeof(u32));
+                R_SUCCEED();
+            }
+
+            /* pcv-side address of a payload symbol's copy. */
+            uintptr_t PayloadVa(const void *loader_sym) const {
+                const uintptr_t offset = reinterpret_cast<uintptr_t>(loader_sym) - reinterpret_cast<uintptr_t>(__start_hoc_hookpayload);
+                return this->ToVa(reinterpret_cast<void *>(m_payload + offset));
+            }
+
+            /* Loader-side, writable pointer to a payload variable's copy in the cave. */
+            template<typename T>
+            T *PayloadCopyOf(T &loader_sym) const {
+                const uintptr_t offset = reinterpret_cast<uintptr_t>(std::addressof(loader_sym)) - reinterpret_cast<uintptr_t>(__start_hoc_hookpayload);
+                return reinterpret_cast<T *>(m_payload + offset);
+            }
+
+            /* Reserves space in the writable data arena past pcv's .bss. */
+            /* Returns a zeroed, loader-side pointer. */
+            /* The data arena is too far from the cave to be addressed directly by symbol, so we must store a pointer to it in the cave section. */
+            template<typename T>
+            T *DataAlloc() {
+                const size_t size = util::AlignUp(sizeof(T), alignof(T) > 8 ? alignof(T) : 8);
+                if (m_data == 0 || m_data_used + size > PcvDataArenaSize) {
+                    return nullptr;
+                }
+
+                T *p = reinterpret_cast<T *>(m_data + m_data_used);
+                m_data_used += size;
+
+                std::memset(p, 0, sizeof(T));
+                return p;
+            }
+
+            template<typename T>
+            T *BindData(T *&loader_sym) {
+                T *block = this->DataAlloc<T>();
+                if (block != nullptr) {
+                    *this->PayloadCopyOf(loader_sym) = reinterpret_cast<T *>(this->ToVa(block));
+                }
+                return block;
+            }
+
+            /* Replaces the function entirely starting at function prologue. */
+            /* Preserves the function arguments. */
+            Result InstallImpl(u32 *site, const void *fn, uintptr_t *out_orig = nullptr) {
+                R_TRY(this->CheckEnabled());
+                R_UNLESS(site != nullptr,   ldr::ResultHookSiteInvalid());
+                R_UNLESS(m_payload != 0,    ldr::ResultUninitializedPatcher());
+                R_TRY(this->ValidatePayloadFn(fn));
+
+                if (out_orig != nullptr) {
+                    u32 *tramp = this->AllocCode(2);
+                    R_UNLESS(tramp != nullptr, ldr::ResultHookArenaOutOfMemory());
+
+                    u32 relocated;
+                    R_TRY(RelocateInstruction(site[0], this->ToVa(site), this->ToVa(&tramp[0]), std::addressof(relocated)));
+                    tramp[0] = relocated;
+                    tramp[1] = EncodeB(this->ToVa(&tramp[1]), this->ToVa(site) + sizeof(u32));
+
+                    *out_orig = this->ToVa(tramp);
+                }
+
+                site[0] = EncodeB(this->ToVa(site), this->PayloadVa(fn));
+
+                R_SUCCEED();
+            }
+
+            /* Takes the same arguments as the hooked function, does not replace. */
+            Result InstallIntercept(u32 *site, const void *fn) {
+                R_TRY(this->CheckEnabled());
+                R_UNLESS(site != nullptr, ldr::ResultHookSiteInvalid());
+                R_UNLESS(m_payload != 0,  ldr::ResultUninitializedPatcher());
+                R_TRY(this->ValidatePayloadFn(fn));
+
+                /* x0-x7: arguments */
+                /* x8: result pointer */
+                /* x18: platform register */
+                /* x30: return address */
+                /* x29: keeps pairs clean */
+                /* x9-x17: scratch */
+                constexpr u32 FrameSize = 0x60;
+                constexpr u32 Pairs[][2] = { {0, 1}, {2, 3}, {4, 5}, {6, 7}, {8, 18}, {29, 30} };
+                constexpr u32 PairCount  = sizeof(Pairs) / sizeof(Pairs[0]);
+                constexpr u32 StubWords  = 1 + PairCount + 1 + PairCount + 1 + 1 + 1;
+
+                u32 *stub = this->AllocCode(StubWords);
+                R_UNLESS(stub != nullptr, ldr::ResultHookArenaOutOfMemory());
+
+                u32 i = 0;
+                stub[i++] = EncodeSpAdjust(true, FrameSize);
+                for (u32 p = 0; p < PairCount; ++p) {
+                    stub[i++] = EncodePairSp(false, Pairs[p][0], Pairs[p][1], static_cast<s32>(p * 16));
+                }
+
+                stub[i] = EncodeBL(this->ToVa(&stub[i]), this->PayloadVa(fn));
+                ++i;
+
+                for (u32 p = 0; p < PairCount; ++p) {
+                    stub[i++] = EncodePairSp(true, Pairs[p][0], Pairs[p][1], static_cast<s32>(p * 16));
+                }
+                stub[i++] = EncodeSpAdjust(false, FrameSize);
+
+                u32 relocated;
+                R_TRY(RelocateInstruction(site[0], this->ToVa(site), this->ToVa(&stub[i]), std::addressof(relocated)));
+                stub[i] = relocated;
+                ++i;
+
+                stub[i] = EncodeB(this->ToVa(&stub[i]), this->ToVa(site) + sizeof(u32));
+                ++i;
+
+                AMS_ABORT_UNLESS(i == StubWords);
+
+                site[0] = EncodeB(this->ToVa(site), this->ToVa(stub));
+                R_SUCCEED();
+            }
+
+            /* Checks entry to first ret that everything still points to valid data. */
+            Result ValidatePayloadFn(const void *fn) const {
+                constexpr u32 MaxInstructions = 512;
+                constexpr u32 RetInsn         = 0xD65F03C0u;
+
+                const uintptr_t lo = m_payload;
+                const uintptr_t hi = m_payload + m_payload_sz;
+
+                const u32 *insns = reinterpret_cast<const u32 *>(fn);
+                const uintptr_t base = m_payload + (reinterpret_cast<uintptr_t>(fn) - reinterpret_cast<uintptr_t>(__start_hoc_hookpayload));
+
+                auto check = [&](uintptr_t target) -> Result {
+                    if (target < lo || target >= hi) {
+                        R_THROW(ldr::ResultHookPayloadEscapes());
+                    }
+                    R_SUCCEED();
+                };
+
+                for (u32 i = 0; i < MaxInstructions; ++i) {
+                    const u32 insn      = insns[i];
+                    const uintptr_t site = base + i * sizeof(u32);
+
+                    if (insn == RetInsn) {
+                        R_SUCCEED();
+                    }
+
+                    const u32 top6 = insn & 0xFC000000u;
+                    if (top6 == 0x14000000u || top6 == 0x94000000u) {                        /* b / bl      */
+                        const uintptr_t target = site + SignExtend(static_cast<u64>(insn & 0x03FFFFFFu) << 2, 28);
+                        R_TRY(check(target));
+                    } else if ((insn & 0xFF000010u) == 0x54000000u ||                        /* b.cond      */
+                               (insn & 0x7E000000u) == 0x34000000u ||                        /* cbz / cbnz  */
+                               (insn & 0x3B000000u) == 0x18000000u) {                        /* ldr literal */
+                        const uintptr_t target = site + SignExtend(static_cast<u64>((insn >> 5) & 0x7FFFFu) << 2, 21);
+                        R_TRY(check(target));
+                    } else if ((insn & 0x7E000000u) == 0x36000000u) {                        /* tbz / tbnz  */
+                        const uintptr_t target = site + SignExtend(static_cast<u64>((insn >> 5) & 0x3FFFu) << 2, 16);
+                        R_TRY(check(target));
+                    } else if ((insn & 0x9F000000u) == 0x10000000u) {                        /* adr         */
+                        const u64 imm          = (static_cast<u64>((insn >> 5) & 0x7FFFFu) << 2) | ((insn >> 29) & 0x3u);
+                        const uintptr_t target = site + SignExtend(imm, 21);
+                        R_TRY(check(target));
+                    } else if ((insn & 0x9F000000u) == 0x90000000u) {                        /* adrp        */
+                        /* ADRP is page-relative and the cave is at an arbitrary offset, any adrp would point to potential garbage. */
+                        R_THROW(ldr::ResultHookPayloadEscapes());
+                    }
+                }
+
+                /* No return found. */
+                R_THROW(ldr::ResultHookPayloadEscapes());
+            }
+        private:
+            u32 *AllocCode(size_t words) {
+                const size_t bytes = words * sizeof(u32);
+                if (!this->IsEnabled() || m_used + bytes > m_cave_size) {
+                    return nullptr;
+                }
+
+                u32 *p = reinterpret_cast<u32 *>(m_cave + m_used);
+                m_used += bytes;
+                return p;
+            }
+    };
+
+    inline HookContext &Hooks() {
+        static HookContext s_context;
+        return s_context;
+    }
+
+}
+
+/* Hook custom impl. Original becomes unreachable. */
+/* Starts at function entry. Preserves arguments. */
+#define INSTALL_IMPL_HOOK(site, fn) \
+    (::ams::ldr::hoc::pcv::Hooks().InstallImpl((site), reinterpret_cast<const void *>(&(fn))))
+
+/* Maintains original function. */
+/* Starts at function entry. Preserves arguments. */
+#define INSTALL_IMPL_HOOK_ORIG(site, fn, out_orig) \
+    (::ams::ldr::hoc::pcv::Hooks().InstallImpl((site), reinterpret_cast<const void *>(&(fn)), (out_orig)))
+
+/* Takes the same arguments as the hooked function, does not replace it and cannot change what it does */
+/* but it can be placed anywhere, not just at a function entry. */
+#define INSTALL_INTERC_HOOK(site, fn) \
+    (::ams::ldr::hoc::pcv::Hooks().InstallIntercept((site), reinterpret_cast<const void *>(&(fn))))

Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_mariko.cpp

@@ -1,818 +0,0 @@
-/*
- * Copyright (C) Switch-OC-Suite
- *
- * Copyright (c) 2023 hanai3Bi
- *
- * Copyright (c) Souldbminer and Horizon OC Contributors
- *
- * 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 "pcv.hpp"
-#include "../mtc_timing_value.hpp"
-#include "../mariko/calculate_timings.hpp"
-
-namespace ams::ldr::hoc::pcv::mariko {
-
-    u32 GetGpuVminVoltage() {
-        for (auto e : vminTable) {
-            if (C.gpuSpeedo <= e.speedo) {
-                return e.voltage;
-            }
-        }
-
-        return 530;
-    }
-
-    u32 GetRamVminAdjustment(u32 vmin) {
-        if (C.marikoEmcMaxClock < 2133000) {
-            return vmin;
-        }
-
-        const u32 ramScale = (((C.marikoEmcMaxClock / 1000) - 2133) / 33) * 5 + vmin;
-
-        for (auto r : ramOffset) {
-            if (C.marikoEmcMaxClock < r.maxClock) {
-                return ramScale + r.offset;
-            }
-        }
-
-        return ramScale;
-    }
-
-    /* Note: EOS (probably?) has a bug in this function that always results in high vmin, this is fixed here. */
-    u32 GetAutoVoltage() {
-        u32 voltage = GetGpuVminVoltage();
-        voltage = GetRamVminAdjustment(voltage);
-
-        u32 voltageOffset = 590 - C.commonGpuVoltOffset;
-
-        if (voltageOffset < voltage) {
-            voltage = voltageOffset;
-        }
-
-        return voltage;
-    }
-
-    Result GpuVoltDVFS(u32 *ptr) {
-        /* Check for valid pattern. */
-        for (size_t i = 0; i < std::size(gpuDVFSPattern); ++i) {
-            if (*(ptr + i + 1) != gpuDVFSPattern[i]) {
-                R_THROW(ldr::ResultInvalidGpuDvfs());
-            }
-        }
-
-        /* Default value is 800mV. */
-        if (C.marikoGpuVmax) {
-            PATCH_OFFSET(ptr + 1, C.marikoGpuVmax);
-        }
-
-        /* C.marikoGpuVmin is non zero, user sets manual voltage. */
-        if (C.marikoGpuVmin) {
-            PATCH_OFFSET(ptr, C.marikoGpuVmin);
-            R_SUCCEED();
-        }
-
-        /* C.marikoGpuVmin is zero, auto voltage is applied. */
-        u32 autoVmin = GetAutoVoltage();
-        PATCH_OFFSET(ptr, autoVmin);
-        R_SUCCEED();
-    }
-
-    Result GpuVoltThermals(u32 *ptr) {
-        if (std::memcmp(ptr - 3, gpuVoltThermalPattern, sizeof(gpuVoltThermalPattern))) {
-            R_THROW(ldr::ResultInvalidGpuDvfs());
-        }
-
-        u32 vmin = C.marikoGpuVmin;
-
-        /* Automatic voltage. */
-        if (!C.marikoGpuVmin) {
-            vmin = GetAutoVoltage();
-            PATCH_OFFSET(ptr,     vmin);
-            PATCH_OFFSET(ptr + 3, vmin);
-            PATCH_OFFSET(ptr + 6, vmin);
-            PATCH_OFFSET(ptr + 9, vmin);
-        } else {
-            /* Manual voltage. */
-            PATCH_OFFSET(ptr,     vmin);
-            PATCH_OFFSET(ptr + 3, vmin);
-            PATCH_OFFSET(ptr + 6, vmin);
-            PATCH_OFFSET(ptr + 9, vmin);
-        }
-
-        PATCH_OFFSET(ptr + 12, vmin);
-
-        R_SUCCEED();
-    }
-
-    u32 CapCpuClock() {
-        u32 cpuCap = allowedCpuMaxFrequencies[0];
-
-        for (u32 freq : allowedCpuMaxFrequencies) {
-            if (C.marikoCpuMaxClock >= freq) {
-                cpuCap = freq;
-            } else {
-                break;
-            }
-        }
-        return cpuCap;
-    }
-
-    Result CpuFreqVdd(u32 *ptr) {
-        dvfs_rail *entry = reinterpret_cast<dvfs_rail *>(reinterpret_cast<u8 *>(ptr) - offsetof(dvfs_rail, freq));
-
-        R_UNLESS(entry->id == 1, ldr::ResultInvalidCpuFreqVddEntry());
-        R_UNLESS(entry->min_mv == 250'000, ldr::ResultInvalidCpuFreqVddEntry());
-        R_UNLESS(entry->step_mv == 5000, ldr::ResultInvalidCpuFreqVddEntry());
-        R_UNLESS(entry->max_mv == 1525'000, ldr::ResultInvalidCpuFreqVddEntry());
-
-        if (C.marikoCpuUVHigh) {
-            PATCH_OFFSET(ptr, CapCpuClock());
-        } else {
-            PATCH_OFFSET(ptr, GetDvfsTableLastEntry(C.marikoCpuDvfsTable)->freq);
-        }
-        R_SUCCEED();
-    }
-
-    Result CpuVoltDVFS(u32 *ptr) {
-        if (MatchesPattern(ptr, cpuVoltagePatchOffsets, cpuVoltagePatchValues)) {
-            if (C.marikoCpuLowVmin) {
-                PATCH_OFFSET(ptr, C.marikoCpuLowVmin);
-            }
-
-            if (C.marikoCpuHighVmin) {
-                PATCH_OFFSET(ptr - 2, C.marikoCpuHighVmin);
-            }
-
-            if (C.marikoCpuMaxVolt) {
-                PATCH_OFFSET(ptr + 5, C.marikoCpuMaxVolt);
-            }
-
-            R_SUCCEED();
-        }
-
-        R_THROW(ldr::ResultInvalidCpuMinVolt());
-    }
-
-    Result CpuVoltThermals(u32 *ptr) {
-        if (std::memcmp(ptr, cpuVoltThermalData, sizeof(cpuVoltThermalData))) {
-            R_THROW(ldr::ResultInvalidCpuMinVolt());
-        }
-
-        if (C.marikoCpuLowVmin) {
-            PATCH_OFFSET(ptr,     C.marikoCpuLowVmin);
-            PATCH_OFFSET(ptr + 3, C.marikoCpuLowVmin);
-        }
-
-        if (C.marikoCpuMaxVolt) {
-            PATCH_OFFSET(ptr - 2, C.marikoCpuMaxVolt);
-            PATCH_OFFSET(ptr - 5, C.marikoCpuMaxVolt);
-            PATCH_OFFSET(ptr + 1, C.marikoCpuMaxVolt);
-            PATCH_OFFSET(ptr + 4, C.marikoCpuMaxVolt);
-        }
-
-        R_SUCCEED();
-    }
-
-    Result CpuVoltDfll(u32 *ptr) {
-        cvb_cpu_dfll_data *entry = reinterpret_cast<cvb_cpu_dfll_data *>(ptr);
-
-        R_UNLESS(entry->tune0_low == 0xFFCF, ldr::ResultInvalidCpuVoltDfllEntry());
-        R_UNLESS(entry->tune0_high == 0x0, ldr::ResultInvalidCpuVoltDfllEntry());
-        R_UNLESS(entry->tune1_low == 0x12207FF, ldr::ResultInvalidCpuVoltDfllEntry());
-        R_UNLESS(entry->tune1_high == 0x3FFF7FF, ldr::ResultInvalidCpuVoltDfllEntry());
-
-        switch (C.marikoCpuUVLow) {
-            case 1:
-                PATCH_OFFSET(&(entry->tune0_low), 0xffa0);
-                PATCH_OFFSET(&(entry->tune0_high), 0xffff);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21107ff);
-                PATCH_OFFSET(&(entry->tune1_high), 0);
-                break;
-            case 2:
-                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21107ff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27207ff);
-                break;
-            case 3:
-                PATCH_OFFSET(&(entry->tune0_low), 0xffdf);
-                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21107ff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27307ff);
-                break;
-            case 4:
-                PATCH_OFFSET(&(entry->tune0_low), 0xffff);
-                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21107ff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27407ff);
-                break;
-            case 5:
-                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21607ff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27707ff);
-                break;
-            case 6:
-                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21607ff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27807ff);
-                break;
-            case 7:
-                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21607ff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27b07ff);
-                break;
-            case 8:
-                PATCH_OFFSET(&(entry->tune0_low), 0xdfff);
-                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21707ff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27b07ff);
-                break;
-            case 9:
-                PATCH_OFFSET(&(entry->tune0_low), 0xdfff);
-                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21707ff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27c07ff);
-                break;
-            case 10:
-                PATCH_OFFSET(&(entry->tune0_low), 0xdfff);
-                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21707ff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27d07ff);
-                break;
-            case 11:
-                PATCH_OFFSET(&(entry->tune0_low), 0xdfff);
-                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21707ff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27e07ff);
-                break;
-            case 12:
-                PATCH_OFFSET(&(entry->tune0_low), 0xdfff);
-                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21707ff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27f07ff);
-                break;
-            default:
-                break;
-        }
-
-        switch (C.marikoCpuUVHigh) {
-            case 1:
-                PATCH_OFFSET(&(entry->tune1_high), 0);
-                PATCH_OFFSET(&(entry->tune0_high), 0xffff);
-                break;
-            case 2:
-                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27207ff);
-                break;
-            case 3:
-                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27307ff);
-                break;
-            case 4:
-                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27407ff);
-                break;
-            case 5:
-                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27707ff);
-                break;
-            case 6:
-                PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27807ff);
-                break;
-            case 7:
-            case 8:
-                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27b07ff);
-                break;
-            case 9:
-                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27c07ff);
-                break;
-            case 10:
-                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27d07ff);
-                break;
-            case 11:
-                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27e07ff);
-                break;
-            case 12:
-                PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
-                PATCH_OFFSET(&(entry->tune1_high), 0x27f07ff);
-                break;
-            default:
-                break;
-        }
-
-        R_SUCCEED();
-    }
-
-    Result GpuFreqMaxAsm(u32 *ptr32) {
-        // Check if both two instructions match the pattern
-        u32 ins1 = *ptr32, ins2 = *(ptr32 + 1);
-        if (!(asm_compare_no_rd(ins1, asm_pattern[0]) && asm_compare_no_rd(ins2, asm_pattern[1])))
-            R_THROW(ldr::ResultInvalidGpuFreqMaxPattern());
-
-        // Both instructions should operate on the same register
-        u8 rd = asm_get_rd(ins1);
-        if (rd != asm_get_rd(ins2))
-            R_THROW(ldr::ResultInvalidGpuFreqMaxPattern());
-
-        u32 max_clock;
-        switch (C.marikoGpuUV) {
-        case 0:
-            max_clock = GetDvfsTableLastEntry(C.marikoGpuDvfsTable)->freq;
-            break;
-        case 1:
-            max_clock = GetDvfsTableLastEntry(C.marikoGpuDvfsTableSLT)->freq;
-            break;
-        case 2:
-            max_clock = GetDvfsTableLastEntry(C.marikoGpuDvfsTableHiOPT)->freq;
-            break;
-        default:
-            max_clock = GetDvfsTableLastEntry(C.marikoGpuDvfsTable)->freq;
-            break;
-        }
-        u32 asm_patch[2] = {
-            asm_set_rd(asm_set_imm16(asm_pattern[0], max_clock), rd),
-            asm_set_rd(asm_set_imm16(asm_pattern[1], max_clock >> 16), rd)
-        };
-
-        PATCH_OFFSET(ptr32, asm_patch[0]);
-        PATCH_OFFSET(ptr32 + 1, asm_patch[1]);
-
-        R_SUCCEED();
-    }
-
-    Result GpuFreqPllMax(u32 *ptr) {
-        clk_pll_param *entry = reinterpret_cast<clk_pll_param *>(ptr);
-
-        // All zero except for freq
-        for (size_t i = 1; i < sizeof(clk_pll_param) / sizeof(u32); i++) {
-            R_UNLESS(*(ptr + i) == 0, ldr::ResultInvalidGpuPllEntry());
-        }
-
-        // Double the max clk simply
-        u32 max_clk = entry->freq * 2;
-        entry->freq = max_clk;
-        R_SUCCEED();
-    }
-
-    Result GpuFreqPllLimit(u32 *ptr) {
-        u32 prev_freq = *(ptr - 1);
-
-        if (prev_freq != 128000 && prev_freq != 1300000 && prev_freq != 76800) {
-            R_THROW(ldr::ResultInvalidGpuPllEntry());
-        }
-
-        PATCH_OFFSET(ptr, 3600000);
-
-        R_SUCCEED();
-    }
-
-    void MemMtcTableAutoAdjust(MarikoMtcTable *table) {
-        /* Official Tegra X1 TRM, sign up for nvidia developer program (free) to download:
-         *     https://developer.nvidia.com/embedded/dlc/tegra-x1-technical-reference-manual
-         *     Section 18.11.1:  MC Registers
-         *     Section 18.11.2: EMC Registers
-         */
-
-        #define WRITE_PARAM_ALL_REG(TABLE, PARAM, VALUE) \
-            TABLE->burst_regs.PARAM = VALUE;             \
-            TABLE->shadow_regs_ca_train.PARAM   = VALUE; \
-            TABLE->shadow_regs_rdwr_train.PARAM = VALUE;
-
-        #define GET_CYCLE_CEIL(PARAM) u32(CEIL(double(PARAM) / tCK_avg))
-
-        /* Ram power down       */
-        /* B31: DRAM_CLKSTOP_PD */
-        /* B30: DRAM_CLKSTOP_SR */
-        /* B29: DRAM_ACPD       */
-        if (C.hpMode) {
-            WRITE_PARAM_ALL_REG(table, emc_cfg, 0x13200000);
-        } else {
-            WRITE_PARAM_ALL_REG(table, emc_cfg, 0xF3200000);
-        }
-
-        u32 refresh_raw = 0xFFFF;
-        if (C.t8_tREFI != 6) {
-            refresh_raw = CEIL(tREFpb_values[C.t8_tREFI] / tCK_avg) - 0x40;
-            refresh_raw = MIN(refresh_raw, static_cast<u32>(0xFFFF));
-        }
-
-        u32 trefbw = refresh_raw + 0x40;
-        trefbw = MIN(trefbw, static_cast<u32>(0x3FFF));
-
-        CalculateTimings();
-
-        WRITE_PARAM_ALL_REG(table, emc_rd_rcd, GET_CYCLE_CEIL(tRCD));
-        WRITE_PARAM_ALL_REG(table, emc_wr_rcd, GET_CYCLE_CEIL(tRCD));
-        WRITE_PARAM_ALL_REG(table, emc_rc, MIN(GET_CYCLE_CEIL(tRC), static_cast<u32>(0xB8)));
-        WRITE_PARAM_ALL_REG(table, emc_ras, MIN(GET_CYCLE_CEIL(tRAS), static_cast<u32>(0x7F)));
-        WRITE_PARAM_ALL_REG(table, emc_rrd, GET_CYCLE_CEIL(tRRD));
-        WRITE_PARAM_ALL_REG(table, emc_rfcpb, GET_CYCLE_CEIL(tRFCpb));
-        WRITE_PARAM_ALL_REG(table, emc_rfc, GET_CYCLE_CEIL(tRFCab));
-        WRITE_PARAM_ALL_REG(table, emc_rp, GET_CYCLE_CEIL(tRPpb));
-        WRITE_PARAM_ALL_REG(table, emc_txsr, MIN(GET_CYCLE_CEIL(tXSR), static_cast<u32>(0x3fe)));
-        WRITE_PARAM_ALL_REG(table, emc_txsrdll, MIN(GET_CYCLE_CEIL(tXSR), static_cast<u32>(0x3fe)));
-        WRITE_PARAM_ALL_REG(table, emc_tfaw, GET_CYCLE_CEIL(tFAW));
-        WRITE_PARAM_ALL_REG(table, emc_trpab, MIN(GET_CYCLE_CEIL(tRPab), static_cast<u32>(0x3F)));
-        WRITE_PARAM_ALL_REG(table, emc_tckesr, GET_CYCLE_CEIL(tSR));
-        WRITE_PARAM_ALL_REG(table, emc_tcke, GET_CYCLE_CEIL(7.425) + 2);
-        WRITE_PARAM_ALL_REG(table, emc_tpd, GET_CYCLE_CEIL(tXP));
-        WRITE_PARAM_ALL_REG(table, emc_tclkstop, tCLKSTOP);
-        WRITE_PARAM_ALL_REG(table, emc_r2p, tR2P);
-        WRITE_PARAM_ALL_REG(table, emc_r2w, tR2W);
-        WRITE_PARAM_ALL_REG(table, emc_trtm, tRTM);
-        WRITE_PARAM_ALL_REG(table, emc_tratm, tRATM);
-        WRITE_PARAM_ALL_REG(table, emc_w2p, tW2P);
-        WRITE_PARAM_ALL_REG(table, emc_w2r, tW2R);
-        WRITE_PARAM_ALL_REG(table, emc_twtm, tWTM);
-        WRITE_PARAM_ALL_REG(table, emc_twatm, tWATM);
-        WRITE_PARAM_ALL_REG(table, emc_rext, rext);
-        WRITE_PARAM_ALL_REG(table, emc_wext, (C.marikoEmcMaxClock >= 2533000) ? 0x19 : 0x16);
-        WRITE_PARAM_ALL_REG(table, emc_refresh, refresh_raw);
-        WRITE_PARAM_ALL_REG(table, emc_pre_refresh_req_cnt, refresh_raw / 4);
-        WRITE_PARAM_ALL_REG(table, emc_trefbw, trefbw);
-        const u32 dyn_self_ref_control = (static_cast<u32>(7605.0 / tCK_avg) + 260) | (table->burst_regs.emc_dyn_self_ref_control & 0xffff0000);
-        WRITE_PARAM_ALL_REG(table, emc_dyn_self_ref_control, dyn_self_ref_control);
-        WRITE_PARAM_ALL_REG(table, emc_pdex2wr, pdex2rw);
-        WRITE_PARAM_ALL_REG(table, emc_pdex2rd, pdex2rw);
-        WRITE_PARAM_ALL_REG(table, emc_pchg2pden, GET_CYCLE_CEIL(1.763));
-        WRITE_PARAM_ALL_REG(table, emc_ar2pden, GET_CYCLE_CEIL(1.75));
-        WRITE_PARAM_ALL_REG(table, emc_pdex2cke, GET_CYCLE_CEIL(1.05));
-        WRITE_PARAM_ALL_REG(table, emc_act2pden, GET_CYCLE_CEIL(14.0));
-        WRITE_PARAM_ALL_REG(table, emc_cke2pden, GET_CYCLE_CEIL(8.499));
-        WRITE_PARAM_ALL_REG(table, emc_pdex2mrr, GET_CYCLE_CEIL(pdex2mrr));
-        WRITE_PARAM_ALL_REG(table, emc_rw2pden, tWTPDEN);
-        WRITE_PARAM_ALL_REG(table, emc_einput, einput);
-        WRITE_PARAM_ALL_REG(table, emc_einput_duration, einput_duration);
-        WRITE_PARAM_ALL_REG(table, emc_obdly, obdly);
-        WRITE_PARAM_ALL_REG(table, emc_ibdly, ibdly);
-        WRITE_PARAM_ALL_REG(table, emc_wdv_mask, wdv);
-        WRITE_PARAM_ALL_REG(table, emc_quse_width, quse_width);
-        WRITE_PARAM_ALL_REG(table, emc_quse, quse);
-        WRITE_PARAM_ALL_REG(table, emc_wdv, wdv);
-        WRITE_PARAM_ALL_REG(table, emc_wsv, wsv);
-        WRITE_PARAM_ALL_REG(table, emc_wev, wev);
-        WRITE_PARAM_ALL_REG(table, emc_qrst, qrst);
-        WRITE_PARAM_ALL_REG(table, emc_tr_qrst, qrst);
-        WRITE_PARAM_ALL_REG(table, emc_qsafe, qsafe);
-        WRITE_PARAM_ALL_REG(table, emc_tr_qsafe, qsafe);
-        WRITE_PARAM_ALL_REG(table, emc_tr_qpop, qpop);
-        WRITE_PARAM_ALL_REG(table, emc_qpop, qpop);
-        WRITE_PARAM_ALL_REG(table, emc_rdv, rdv);
-        WRITE_PARAM_ALL_REG(table, emc_tr_rdv_mask, rdv + 2);
-        WRITE_PARAM_ALL_REG(table, emc_rdv_early, rdv - 2);
-        WRITE_PARAM_ALL_REG(table, emc_rdv_early_mask, rdv);
-        WRITE_PARAM_ALL_REG(table, emc_rdv_mask, rdv + 2);
-        WRITE_PARAM_ALL_REG(table, emc_tr_rdv, rdv);
-        WRITE_PARAM_ALL_REG(table, emc_cmd_brlshft_2, 0x24)
-        WRITE_PARAM_ALL_REG(table, emc_cmd_brlshft_3, 0x24)
-
-        /* This needs some clean up. */
-        constexpr double MC_ARB_DIV = 4.0;
-        constexpr u32 MC_ARB_SFA = 2;
-
-        table->burst_mc_regs.mc_emem_arb_cfg          = C.marikoEmcMaxClock         / (33.3 * 1000) / MC_ARB_DIV;
-        table->burst_mc_regs.mc_emem_arb_timing_rcd   = CEIL(GET_CYCLE_CEIL(tRCD)   / MC_ARB_DIV) - 2;
-        table->burst_mc_regs.mc_emem_arb_timing_rp    = CEIL(GET_CYCLE_CEIL(tRPpb)  / MC_ARB_DIV) - 1;
-        table->burst_mc_regs.mc_emem_arb_timing_rc    = CEIL(GET_CYCLE_CEIL(tRC)    / MC_ARB_DIV) - 1;
-        table->burst_mc_regs.mc_emem_arb_timing_ras   = CEIL(GET_CYCLE_CEIL(tRAS)   / MC_ARB_DIV) - 2;
-        table->burst_mc_regs.mc_emem_arb_timing_faw   = CEIL(GET_CYCLE_CEIL(tFAW)   / MC_ARB_DIV) - 1;
-        table->burst_mc_regs.mc_emem_arb_timing_rrd   = CEIL(GET_CYCLE_CEIL(tRRD)   / MC_ARB_DIV) - 1;
-        table->burst_mc_regs.mc_emem_arb_timing_rfcpb = CEIL(GET_CYCLE_CEIL(tRFCpb) / MC_ARB_DIV) - 1;
-        table->burst_mc_regs.mc_emem_arb_timing_rap2pre = CEIL(tR2P / MC_ARB_DIV);
-        table->burst_mc_regs.mc_emem_arb_timing_wap2pre = CEIL(tW2P / MC_ARB_DIV) + MC_ARB_SFA;
-
-        /* Two consecutive reads between two different dram modules. */
-        /* Only be above 1 for 8gb ram. */
-        if (table->burst_mc_regs.mc_emem_arb_timing_r2r > 1) {
-            table->burst_mc_regs.mc_emem_arb_timing_r2r = CEIL(table->burst_regs.emc_rext / 4) - 1 + MC_ARB_SFA;
-        }
-
-        /* Same as r2r but for write. */
-        if (table->burst_mc_regs.mc_emem_arb_timing_w2w > 1) {
-            table->burst_mc_regs.mc_emem_arb_timing_w2w = CEIL(table->burst_regs.emc_wext / MC_ARB_DIV) - 1 + MC_ARB_SFA;
-        }
-
-        table->burst_mc_regs.mc_emem_arb_timing_r2w = CEIL(tR2W / MC_ARB_DIV) - 1 + MC_ARB_SFA;
-        table->burst_mc_regs.mc_emem_arb_timing_w2r = CEIL(tW2R / MC_ARB_DIV) - 1 + MC_ARB_SFA;
-
-        u32 da_turns = 0;
-        da_turns |= u8(table->burst_mc_regs.mc_emem_arb_timing_r2w / 2) << 16;
-        da_turns |= u8(table->burst_mc_regs.mc_emem_arb_timing_w2r / 2) << 24;
-        table->burst_mc_regs.mc_emem_arb_da_turns = da_turns;
-
-        u32 da_covers = 0;
-        u8 r_cover = (table->burst_mc_regs.mc_emem_arb_timing_rap2pre + table->burst_mc_regs.mc_emem_arb_timing_rp + table->burst_mc_regs.mc_emem_arb_timing_rcd) / 2;
-        u8 w_cover = (table->burst_mc_regs.mc_emem_arb_timing_wap2pre + table->burst_mc_regs.mc_emem_arb_timing_rp + table->burst_mc_regs.mc_emem_arb_timing_rcd) / 2;
-        da_covers |= (table->burst_mc_regs.mc_emem_arb_timing_rc / 2);
-        da_covers |= (r_cover << 8);
-        da_covers |= (w_cover << 16);
-        table->burst_mc_regs.mc_emem_arb_da_covers = da_covers;
-
-        table->burst_mc_regs.mc_emem_arb_misc0 = (table->burst_mc_regs.mc_emem_arb_misc0 & 0xFFE08000) | (table->burst_mc_regs.mc_emem_arb_timing_rc + 1);
-
-        table->la_scale_regs.mc_mll_mpcorer_ptsa_rate = 0x115;
-
-        if (C.marikoEmcMaxClock >= 2133000) {
-            table->la_scale_regs.mc_ftop_ptsa_rate = 0x1F;
-        } else {
-            table->la_scale_regs.mc_ftop_ptsa_rate = 0x1B;
-        }
-
-        table->la_scale_regs.mc_ptsa_grant_decrement = 0x17ff;
-
-        constexpr u32 MaskHigh = 0xFF00FFFF;
-        constexpr u32 Mask2 = 0xFFFFFF00;
-        constexpr u32 Mask3 = 0xFF00FF00;
-
-        const u32 allowance1 = static_cast<u32>(0x32000 / (C.marikoEmcMaxClock / 0x3E8)) & 0xFF;
-        const u32 allowance2 = static_cast<u32>(0x9C40  / (C.marikoEmcMaxClock / 0x3E8)) & 0xFF;
-        const u32 allowance3 = static_cast<u32>(0xB540  / (C.marikoEmcMaxClock / 0x3E8)) & 0xFF;
-        const u32 allowance4 = static_cast<u32>(0x9600  / (C.marikoEmcMaxClock / 0x3E8)) & 0xFF;
-        const u32 allowance5 = static_cast<u32>(0x8980  / (C.marikoEmcMaxClock / 0x3E8)) & 0xFF;
-
-        table->la_scale_regs.mc_latency_allowance_xusb_0    =              (table->la_scale_regs.mc_latency_allowance_xusb_0    & MaskHigh) | (allowance1 << 16);
-        table->la_scale_regs.mc_latency_allowance_xusb_1    =              (table->la_scale_regs.mc_latency_allowance_xusb_1    & MaskHigh) | (allowance1 << 16);
-        table->la_scale_regs.mc_latency_allowance_tsec_0    =              (table->la_scale_regs.mc_latency_allowance_tsec_0    & MaskHigh) | (allowance1 << 16);
-        table->la_scale_regs.mc_latency_allowance_sdmmcaa_0 =              (table->la_scale_regs.mc_latency_allowance_sdmmcaa_0 & MaskHigh) | (allowance1 << 16);
-        table->la_scale_regs.mc_latency_allowance_sdmmcab_0 =              (table->la_scale_regs.mc_latency_allowance_sdmmcab_0 & MaskHigh) | (allowance1 << 16);
-        table->la_scale_regs.mc_latency_allowance_sdmmc_0   =              (table->la_scale_regs.mc_latency_allowance_sdmmc_0   & MaskHigh) | (allowance1 << 16);
-        table->la_scale_regs.mc_latency_allowance_sdmmca_0  =              (table->la_scale_regs.mc_latency_allowance_sdmmca_0  & MaskHigh) | (allowance1 << 16);
-        table->la_scale_regs.mc_latency_allowance_ppcs_1    =              (table->la_scale_regs.mc_latency_allowance_ppcs_1    & MaskHigh) | (allowance1 << 16);
-        table->la_scale_regs.mc_latency_allowance_nvdec_0   =              (table->la_scale_regs.mc_latency_allowance_nvdec_0   & MaskHigh) | (allowance1 << 16);
-        table->la_scale_regs.mc_latency_allowance_mpcore_0  =              (table->la_scale_regs.mc_latency_allowance_mpcore_0  & MaskHigh) | (allowance1 << 16);
-        table->la_scale_regs.mc_latency_allowance_avpc_0    =              (table->la_scale_regs.mc_latency_allowance_avpc_0    & MaskHigh) | (allowance1 << 16);
-        table->la_scale_regs.mc_latency_allowance_isp2_1    = allowance1 | (table->la_scale_regs.mc_latency_allowance_isp2_1    & Mask3)    | (allowance1 << 16);
-        table->la_scale_regs.mc_latency_allowance_gpu_0     = allowance2 | (table->la_scale_regs.mc_latency_allowance_gpu_0     & Mask3)    | (allowance1 << 16);
-        table->la_scale_regs.mc_latency_allowance_gpu2_0    = allowance2 | (table->la_scale_regs.mc_latency_allowance_gpu2_0    & Mask3)    | (allowance1 << 16);
-        table->la_scale_regs.mc_latency_allowance_vic_0     = allowance3 | (table->la_scale_regs.mc_latency_allowance_vic_0     & Mask3)    | (allowance1 << 16);
-        table->la_scale_regs.mc_latency_allowance_nvenc_0   = allowance4 | (table->la_scale_regs.mc_latency_allowance_nvenc_0   & Mask3)    | (allowance1 << 16);
-        table->la_scale_regs.mc_latency_allowance_hc_0      =              (table->la_scale_regs.mc_latency_allowance_hc_0      & Mask2)    |  allowance5;
-        table->la_scale_regs.mc_latency_allowance_hc_1      =              (table->la_scale_regs.mc_latency_allowance_hc_1      & Mask2)    |  allowance1;
-        table->la_scale_regs.mc_latency_allowance_vi2_0     =              (table->la_scale_regs.mc_latency_allowance_vi2_0     & Mask2)    |  allowance1;
-
-        table->dram_timings.t_rp = tRFCpb;
-        table->dram_timings.t_rfc = tRFCab;
-        table->dram_timings.rl = RL;
-
-        table->emc_mrw2 = (table->emc_mrw2 & ~0xFFu) | static_cast<u32>(mrw2);
-        table->emc_cfg_2 = 0x11083D;
-    }
-
-    void MemMtcPllmbDivisor(MarikoMtcTable *table) {
-        constexpr u32 PllOscInKHz   = 38400;
-        constexpr u32 PllOscHalfKHz = 19200;
-
-        double target_freq_d = static_cast<double>(C.marikoEmcMaxClock);
-
-        s32 divm_candidate_half = static_cast<u8>(C.marikoEmcMaxClock / PllOscHalfKHz);
-
-        bool remainder_check = (C.marikoEmcMaxClock - PllOscInKHz * (C.marikoEmcMaxClock / PllOscInKHz)) > (C.marikoEmcMaxClock - PllOscHalfKHz * divm_candidate_half) && static_cast<int>(((target_freq_d / PllOscHalfKHz - divm_candidate_half - 0.5) * 8192.0)) != 0;
-
-        u32 divm_final = remainder_check + 1;
-        table->pllmb_divm = divm_final;
-
-        double div_step_d = static_cast<double>(PllOscInKHz) / divm_final;
-        s32 divn_integer = static_cast<u8>(C.marikoEmcMaxClock / div_step_d);
-        table->pllmb_divn = divn_integer;
-
-        u32 divn_fraction = static_cast<s32>((target_freq_d / div_step_d - divn_integer - 0.5) * 8192.0);
-
-        u32 actual_freq_khz = static_cast<u32>((divn_integer + 0.5 + divn_fraction * 0.000122070312) * div_step_d);
-
-        if (C.marikoEmcMaxClock - 2366001 < 133999) {
-            s32 divn_fraction_ssc = static_cast<s32>((actual_freq_khz * 0.997 / div_step_d - divn_integer - 0.5) * 8192.0);
-
-            double delta_scaled = (0.3 / div_step_d + 0.3 / div_step_d) * (divn_fraction - divn_fraction_ssc);
-            s32 delta_int = static_cast<s32>(delta_scaled);
-            double delta_frac = delta_scaled - delta_int;
-
-            u32 setup_value = 0;
-            if (delta_frac <= 0.5) {
-                double round_val = (delta_int + ROUND(delta_frac + delta_frac)) ? 0.5 : 0.0;
-                setup_value = ROUND(delta_frac + delta_frac) ? static_cast<u32>(round_val + round_val) | 0x1000 : static_cast<u32>(round_val);
-            } else {
-                s32 frac_doubled = ROUND(delta_frac - 0.5 + delta_frac - 0.5);
-                double round_val = 1.0;
-                setup_value = frac_doubled ? static_cast<u32>(round_val) : static_cast<u32>(round_val + round_val) | 0x1000;
-            }
-
-            u32 ctrl1 = static_cast<u16>(divn_fraction_ssc) | (static_cast<u16>(divn_fraction) << 16);
-            u32 ctrl2 = static_cast<u16>(divn_fraction) | (static_cast<u16>(setup_value) << 16);
-
-            table->pllm_ss_ctrl1 = ctrl1;
-            table->pllm_ss_ctrl2 = ctrl2;
-            table->pllmb_ss_ctrl1 = ctrl1;
-            table->pllmb_ss_ctrl2 = ctrl2;
-        } else {
-            table->pllm_ss_cfg &= 0xBFFFFFFF;
-            table->pllmb_ss_cfg &= 0xBFFFFFFF;
-
-            u64 pair = (static_cast<u64>(divn_fraction) << 32) | static_cast<u64>(C.marikoEmcMaxClock);
-            u32 pll_misc = (table->pllm_ss_ctrl2 & 0xFFFF0000) | static_cast<u32>((pair - actual_freq_khz) >> 32);
-
-            table->pllm_ss_ctrl2 = pll_misc;
-            table->pllmb_ss_ctrl2 = pll_misc;
-        }
-    }
-
-    Result MemFreqMtcTable(u32 *ptr) {
-        u32 khz_list[] = {1600000, 1331200, 204000};
-        u32 khz_list_size = sizeof(khz_list) / sizeof(u32);
-
-        // Generate list for mtc table pointers
-        MarikoMtcTable *table_list[khz_list_size];
-        for (u32 i = 0; i < khz_list_size; i++) {
-            u8 *table = reinterpret_cast<u8 *>(ptr) - offsetof(MarikoMtcTable, rate_khz) - i * sizeof(MarikoMtcTable);
-            table_list[i] = reinterpret_cast<MarikoMtcTable *>(table);
-            R_UNLESS(table_list[i]->rate_khz == khz_list[i], ldr::ResultInvalidMtcTable());
-            R_UNLESS(table_list[i]->rev == MTC_TABLE_REV, ldr::ResultInvalidMtcTable());
-        }
-
-        if (C.marikoEmcMaxClock <= EmcClkOSLimit)
-            R_SKIP();
-
-        MarikoMtcTable *table_alt = table_list[1], *table_max = table_list[0];
-        MarikoMtcTable *tmp = new MarikoMtcTable;
-
-        // Copy unmodified 1600000 table to tmp
-        std::memcpy(reinterpret_cast<void *>(tmp), reinterpret_cast<void *>(table_max), sizeof(MarikoMtcTable));
-        
-        /* Adjust timings properly according to the new frequency. */
-        MemMtcTableAutoAdjust(table_max);
-
-        MemMtcPllmbDivisor(table_max);
-        // Overwrite 13312000 table with unmodified 1600000 table copied back
-        std::memcpy(reinterpret_cast<void *>(table_alt), reinterpret_cast<void *>(tmp), sizeof(MarikoMtcTable));
-
-        delete tmp;
-
-        PATCH_OFFSET(ptr, C.marikoEmcMaxClock);
-        R_SUCCEED();
-    }
-
-    Result MemFreqDvbTable(u32 *ptr) {
-        emc_dvb_dvfs_table_t *default_end = reinterpret_cast<emc_dvb_dvfs_table_t *>(ptr);
-        emc_dvb_dvfs_table_t *new_start = default_end + 1;
-
-        // Validate existing table
-        void *mem_dvb_table_head = reinterpret_cast<u8 *>(new_start) - sizeof(EmcDvbTableDefault);
-        bool validated = std::memcmp(mem_dvb_table_head, EmcDvbTableDefault, sizeof(EmcDvbTableDefault)) == 0;
-        R_UNLESS(validated, ldr::ResultInvalidDvbTable());
-
-        if (C.marikoEmcMaxClock <= EmcClkOSLimit)
-            R_SKIP();
-
-        int32_t voltAdd = 25 * C.emcDvbShift;
-
-        #define DVB_VOLT(zero, one, two) std::min(zero + voltAdd, 1050), std::min(one + voltAdd, 1025), std::min(two + voltAdd, 1000),
-
-        /* TODO: More fine tuned values? */
-        if (C.marikoEmcMaxClock < 1862400) {
-            std::memcpy(new_start, default_end, sizeof(emc_dvb_dvfs_table_t));
-        } else if (C.marikoEmcMaxClock < 2131200) {
-            emc_dvb_dvfs_table_t oc_table = {1862400, {700, 675, 650, }};
-            std::memcpy(new_start, &oc_table, sizeof(emc_dvb_dvfs_table_t));
-        } else if (C.marikoEmcMaxClock < 2400000) {
-            emc_dvb_dvfs_table_t oc_table = {2131200, { 725, 700, 675} };
-            std::memcpy(new_start, &oc_table, sizeof(emc_dvb_dvfs_table_t));
-        } else if (C.marikoEmcMaxClock < 2665600) {
-            emc_dvb_dvfs_table_t oc_table = {2400000, {DVB_VOLT(750, 725, 700)}};
-            std::memcpy(new_start, &oc_table, sizeof(emc_dvb_dvfs_table_t));
-        } else if (C.marikoEmcMaxClock < 2931200) {
-            emc_dvb_dvfs_table_t oc_table = {2665600, {DVB_VOLT(775, 750, 725)}};
-            std::memcpy(new_start, &oc_table, sizeof(emc_dvb_dvfs_table_t));
-        } else if (C.marikoEmcMaxClock < 3200000) {
-            emc_dvb_dvfs_table_t oc_table = {2931200, {DVB_VOLT(800, 775, 750)}};
-            std::memcpy(new_start, &oc_table, sizeof(emc_dvb_dvfs_table_t));
-        } else {
-            emc_dvb_dvfs_table_t oc_table = {3200000, {DVB_VOLT(800, 800, 775)}};
-            std::memcpy(new_start, &oc_table, sizeof(emc_dvb_dvfs_table_t));
-        }
-        new_start->freq = C.marikoEmcMaxClock;
-        /* Max dvfs entry is 32, but HOS doesn't seem to boot if exact freq doesn't exist in dvb table,
-           reason why it's like this
-        */
-
-        R_SUCCEED();
-    }
-
-    Result MemFreqMax(u32 *ptr) {
-        if (C.marikoEmcMaxClock <= EmcClkOSLimit)
-            R_SKIP();
-
-        PATCH_OFFSET(ptr, C.marikoEmcMaxClock);
-        R_SUCCEED();
-    }
-
-    Result I2cSet_U8(I2cDevice dev, u8 reg, u8 val) {
-        struct {
-            u8 reg;
-            u8 val;
-        } __attribute__((packed)) cmd;
-
-        I2cSession _session;
-        Result res = i2cOpenSession(&_session, dev);
-        if (R_FAILED(res))
-            return res;
-
-        cmd.reg = reg;
-        cmd.val = val;
-        res = i2csessionSendAuto(&_session, &cmd, sizeof(cmd), I2cTransactionOption_All);
-        i2csessionClose(&_session);
-        return res;
-    }
-
-    Result EmcVddqVolt(u32 *ptr) {
-        regulator *entry = reinterpret_cast<regulator *>(reinterpret_cast<u8 *>(ptr) - offsetof(regulator, type_2_3.default_uv));
-
-        constexpr u32 uv_step = 5'000;
-        constexpr u32 uv_min = 250'000;
-
-        auto validator = [entry]() {
-            R_UNLESS(entry->id == 2, ldr::ResultInvalidRegulatorEntry());
-            R_UNLESS(entry->type == 3, ldr::ResultInvalidRegulatorEntry());
-            R_UNLESS(entry->type_2_3.step_uv == uv_step, ldr::ResultInvalidRegulatorEntry());
-            R_UNLESS(entry->type_2_3.min_uv == uv_min, ldr::ResultInvalidRegulatorEntry());
-            R_SUCCEED();
-        };
-
-        R_TRY(validator());
-
-        u32 emc_uv = C.marikoEmcVddqVolt;
-        if (!emc_uv)
-            R_SKIP();
-
-        if (emc_uv % uv_step)
-            emc_uv = (emc_uv + uv_step - 1) / uv_step * uv_step; // rounding
-
-        PATCH_OFFSET(ptr, emc_uv);
-
-        i2cInitialize();
-        Result resultI2C = I2cSet_U8(I2cDevice_Max77812_2, 0x25, (emc_uv - uv_min) / uv_step);
-        i2cExit();
-
-        if (R_SUCCEEDED(resultI2C)) {
-            R_SUCCEED();
-        }
-
-        return resultI2C;
-    }
-
-    void Patch(uintptr_t mapped_nso, size_t nso_size) {
-        u32 CpuCvbDefaultMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(CpuCvbTableDefault)->freq);
-        u32 GpuCvbDefaultMaxFreq = static_cast<u32>(GetDvfsTableLastEntry(GpuCvbTableDefault)->freq);
-
-        PatcherEntry<u32> patches[] = {
-            {"CPU Freq Vdd", &CpuFreqVdd, 1, nullptr, CpuClkOSLimit},
-            {"CPU Freq Table", CpuFreqCvbTable<true>, 1, nullptr, CpuCvbDefaultMaxFreq},
-            {"CPU Volt DVFS", &CpuVoltDVFS, 1, nullptr, CpuVminOfficial},
-            {"CPU Volt Thermals", &CpuVoltThermals, 1, nullptr, CpuVminOfficial},
-            {"CPU Volt Dfll", &CpuVoltDfll, 1, nullptr, 0x0000FFCF},
-            {"GPU Volt DVFS", &GpuVoltDVFS, 1, nullptr, GpuVminOfficial},
-            {"GPU Volt Thermals", &GpuVoltThermals, 1, nullptr, GpuVminOfficial},
-            {"GPU Freq Table", GpuFreqCvbTable<true>, 1, nullptr, GpuCvbDefaultMaxFreq},
-            {"GPU Freq Asm", &GpuFreqMaxAsm, 2, &GpuMaxClockPatternFn},
-            {"GPU PLL Max", &GpuFreqPllMax, 1, nullptr, GpuClkPllMax},
-            {"GPU PLL Limit", &GpuFreqPllLimit, 4, nullptr, GpuClkPllLimit},
-            {"MEM Freq Mtc", &MemFreqMtcTable, 0, nullptr, EmcClkOSLimit},
-            {"MEM Freq Dvb", &MemFreqDvbTable, 1, nullptr, EmcClkOSLimit},
-            {"MEM Freq Max", &MemFreqMax, 0, nullptr, EmcClkOSLimit},
-            {"MEM Freq PLLM", &MemFreqPllmLimit, 2, nullptr, EmcClkPllmLimit},
-            {"MEM Vddq", &EmcVddqVolt, 2, nullptr, EmcVddqDefault},
-            {"MEM Vdd2", &MemVoltHandler, 2, nullptr, MemVdd2Default},
-        };
-
-        for (uintptr_t ptr = mapped_nso; ptr <= mapped_nso + nso_size - sizeof(MarikoMtcTable); ptr += sizeof(u32)) {
-            u32 *ptr32 = reinterpret_cast<u32 *>(ptr);
-            for (auto &entry : patches) {
-                if (R_SUCCEEDED(entry.SearchAndApply(ptr32))) {
-                    break;
-                }
-            }
-        }
-
-        for (auto &entry : patches) {
-            LOGGING("%s Count: %zu", entry.description, entry.patched_count);
-            if (R_FAILED(entry.CheckResult())) {
-                CRASH(entry.description);
-            }
-        }
-    }
-
-}

Source/Atmosphere/stratosphere/loader/source/oc/ptm/ptm.cpp

@@ -20,12 +20,8 @@
 
 namespace ams::ldr::hoc::ptm {
 
-    Result CpuPtmBoost(perf_conf_entry* entry) {
-        #ifdef ATMOSPHERE_IS_STRATOSPHERE
+    Result CpuPtmBoost(perf_conf_entry *entry) {
         bool isMariko = (spl::GetSocType() == spl::SocType_Mariko);
-        #else
-        bool isMariko = true;
-        #endif
 
         if (!C.eristaCpuBoostClock || !C.marikoCpuBoostClock) {
             R_SUCCEED();
@@ -39,19 +35,19 @@ namespace ams::ldr::hoc::ptm {
         R_SUCCEED();
     }
 
-    Result MemPtm(perf_conf_entry* entry) {
+    Result MemPtm(perf_conf_entry *entry) {
         PATCH_OFFSET(&(entry->emc_freq_1), memPtmLimit);
         PATCH_OFFSET(&(entry->emc_freq_2), memPtmLimit);
 
         R_SUCCEED();
     }
 
-    bool PtmEntryIsValid(perf_conf_entry* entry) {
+    bool PtmEntryIsValid(perf_conf_entry *entry) {
         return (entry->cpu_freq_1 == entry->cpu_freq_2 && entry->gpu_freq_1 == entry->gpu_freq_2 && entry->emc_freq_1 == entry->emc_freq_2);
     }
 
-    bool PtmTablePatternFn(u32* ptr) {
-        perf_conf_entry* entry = reinterpret_cast<perf_conf_entry *>(ptr);
+    bool PtmTablePatternFn(u32 *ptr) {
+        perf_conf_entry *entry = reinterpret_cast<perf_conf_entry *>(ptr);
         if (!PtmEntryIsValid(entry)) {
             return false;
         }
@@ -60,9 +56,9 @@ namespace ams::ldr::hoc::ptm {
     }
 
     void Patch(uintptr_t mapped_nso, size_t nso_size) {
-        perf_conf_entry* confTable = nullptr;
+        perf_conf_entry *confTable = nullptr;
         for (uintptr_t ptr = mapped_nso; ptr <= mapped_nso + nso_size - sizeof(perf_conf_entry) * entryCnt; ptr += sizeof(u32)) {
-            u32* ptr32 = reinterpret_cast<u32 *>(ptr);
+            u32 *ptr32 = reinterpret_cast<u32 *>(ptr);
             if (PtmTablePatternFn(ptr32)) {
                 confTable = reinterpret_cast<perf_conf_entry *>(ptr);
                 break;
@@ -76,11 +72,7 @@ namespace ams::ldr::hoc::ptm {
         PatcherEntry<perf_conf_entry> cpuPtmBoostPatch = { "CPU Ptm Boost", &CpuPtmBoost, 2, };
         PatcherEntry<perf_conf_entry> memPtmPatch = { "MEM Ptm", &MemPtm, 16, };
 
-        #ifdef ATMOSPHERE_IS_STRATOSPHERE
         bool isMariko = (spl::GetSocType() == spl::SocType_Mariko);
-        #else
-        bool isMariko = true;
-        #endif
 
         for (u32 i = 0; i < entryCnt; i++) {
             perf_conf_entry *entry = confTable + i;
@@ -92,7 +84,7 @@ namespace ams::ldr::hoc::ptm {
 
             switch (entry->cpu_freq_1) {
                 case cpuPtmBoost:
-                    cpuPtmBoostPatch.Apply(entry);
+                    R_DISCARD(cpuPtmBoostPatch.Apply(entry));
                     break;
                 case cpuPtmDefault:
                 case cpuPtmDevOC:
@@ -107,7 +99,7 @@ namespace ams::ldr::hoc::ptm {
                 case memPtmAlt:
                 case memPtmClamp:
                     if (isMariko) {
-                        memPtmPatch.Apply(entry);
+                        R_DISCARD(memPtmPatch.Apply(entry));
                     }
                     break;
                 default:
@@ -117,13 +109,15 @@ namespace ams::ldr::hoc::ptm {
         }
 
         LOGGING("%s Count: %zu", cpuPtmBoostPatch.description, cpuPtmBoostPatch.patched_count);
-        if (R_FAILED(cpuPtmBoostPatch.CheckResult()))
+        if (R_FAILED(cpuPtmBoostPatch.CheckResult())) {
             CRASH(cpuPtmBoostPatch.description);
+        }
 
         if (isMariko) {
             LOGGING("%s Count: %zu", memPtmPatch.description, memPtmPatch.patched_count);
-            if (R_FAILED(memPtmPatch.CheckResult()))
+            if (R_FAILED(memPtmPatch.CheckResult())) {
                 CRASH(memPtmPatch.description);
+            }
         }
     }
 

Source/Atmosphere/stratosphere/loader/source/oc/ptm/ptm.hpp

@@ -22,7 +22,7 @@
 
 namespace ams::ldr::hoc::ptm {
 
-    typedef struct {
+    struct perf_conf_entry {
         u32 conf_id;
         u32 cpu_freq_1; // min-max pair?
         u32 cpu_freq_2;
@@ -31,7 +31,7 @@ namespace ams::ldr::hoc::ptm {
         u32 emc_freq_1;
         u32 emc_freq_2;
         u32 padding;
-    } perf_conf_entry;
+    };
 
     constexpr u32 entryCnt      = 16;
     constexpr u32 cpuPtmDefault = 1020'000'000;

Source/Atmosphere/stratosphere/loader/system_module.mk

@@ -0,0 +1,136 @@
+#---------------------------------------------------------------------------------
+# pull in common stratosphere sysmodule configuration
+#---------------------------------------------------------------------------------
+THIS_MAKEFILE := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
+include $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../../libraries/config/templates/stratosphere.mk
+
+ifneq ($(strip $(HOC_UART_LOG)),)
+	export CFLAGS   += -DHOC_UART_LOG=$(HOC_UART_LOG)
+	export CXXFLAGS += -DHOC_UART_LOG=$(HOC_UART_LOG)
+endif
+
+ATMOSPHERE_SYSTEM_MODULE_TARGETS := kip
+
+#---------------------------------------------------------------------------------
+# no real need to edit anything past this point unless you need to add additional
+# rules for different file extensions
+#---------------------------------------------------------------------------------
+ifneq ($(__RECURSIVE__),1)
+#---------------------------------------------------------------------------------
+
+export TOPDIR	:=	$(CURDIR)
+
+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)
+
+BINFILES	:=	$(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
+
+#---------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#---------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CC)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CXX)
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+export OFILES	:=	$(addsuffix .o,$(BINFILES)) \
+			$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+			$(foreach dir,$(AMS_LIBDIRS),-I$(dir)/include) \
+			-I$(CURDIR)/$(ATMOSPHERE_BUILD_DIR)
+
+export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/lib) $(foreach dir,$(AMS_LIBDIRS),-L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
+
+export BUILD_EXEFS_SRC := $(TOPDIR)/$(EXEFS_SRC)
+
+ifeq ($(strip $(CONFIG_JSON)),)
+	jsons := $(wildcard *.json)
+	ifneq (,$(findstring $(TARGET).json,$(jsons)))
+		export APP_JSON := $(TOPDIR)/$(TARGET).json
+	else
+		ifneq (,$(findstring config.json,$(jsons)))
+			export APP_JSON := $(TOPDIR)/config.json
+		endif
+	endif
+else
+	export APP_JSON := $(TOPDIR)/$(CONFIG_JSON)
+endif
+
+.PHONY: clean all check_lib
+
+#---------------------------------------------------------------------------------
+all: $(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_LIBRARIES_DIR)/libstratosphere/$(ATMOSPHERE_LIBRARY_DIR)/libstratosphere.a
+	@$(MAKE) __RECURSIVE__=1 OUTPUT=$(CURDIR)/$(ATMOSPHERE_OUT_DIR)/$(TARGET) \
+	DEPSDIR=$(CURDIR)/$(ATMOSPHERE_BUILD_DIR) \
+	--no-print-directory -C $(ATMOSPHERE_BUILD_DIR) \
+	-f $(THIS_MAKEFILE)
+
+$(ATMOSPHERE_LIBRARIES_DIR)/libstratosphere/$(ATMOSPHERE_LIBRARY_DIR)/libstratosphere.a: check_lib
+	@$(SILENTCMD)echo "Checked library."
+
+ifeq ($(ATMOSPHERE_CHECKED_LIBSTRATOSPHERE),1)
+check_lib:
+else
+check_lib:
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libstratosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libstratosphere/libstratosphere.mk
+endif
+
+$(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR):
+	@[ -d $@ ] || mkdir -p $@
+
+#---------------------------------------------------------------------------------
+clean:
+	@echo clean ...
+	@rm -fr $(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR)
+
+
+#---------------------------------------------------------------------------------
+else
+.PHONY:	all
+
+DEPENDS	:=	$(OFILES:.o=.d)
+
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+all	:	$(foreach target,$(ATMOSPHERE_SYSTEM_MODULE_TARGETS),$(OUTPUT).$(target))
+
+$(OUTPUT).kip :	$(OUTPUT).elf
+$(OUTPUT).nsp :	$(OUTPUT).nso $(OUTPUT).npdm
+$(OUTPUT).nso :	$(OUTPUT).elf
+
+$(OUTPUT).elf :	$(OFILES)
+
+$(OFILES) : $(ATMOSPHERE_LIBRARIES_DIR)/libstratosphere/$(ATMOSPHERE_LIBRARY_DIR)/libstratosphere.a
+
+%.npdm  :   %.npdm.json
+	@echo built ... $< $@
+	@npdmtool $< $@
+	@echo built ... $(notdir $@)
+
+#---------------------------------------------------------------------------------
+# you need a rule like this for each extension you use as binary data
+#---------------------------------------------------------------------------------
+%.bin.o	:	%.bin
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+-include $(DEPENDS)
+
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------

Source/Benchmark-Toolbox/.gitignore

@@ -0,0 +1,9 @@
+# build artifacts
+build/
+*.nro
+*.elf
+*.nacp
+*.map
+
+# generated nanovg shaders (regenerated by the build)
+resources/shaders/

Source/Benchmark-Toolbox/Makefile

@@ -0,0 +1,207 @@
+#---------------------------------------------------------------------------------
+.SUFFIXES:
+#---------------------------------------------------------------------------------
+
+ifeq ($(strip $(DEVKITPRO)),)
+$(error "Please set DEVKITPRO in your environment. export DEVKITPRO=<path to>/devkitpro")
+endif
+
+TOPDIR ?= $(CURDIR)
+include $(DEVKITPRO)/libnx/switch_rules
+
+#---------------------------------------------------------------------------------
+TARGET		:=	Benchmark-Toolbox
+BUILD		:=	build
+SOURCES		:=	source source/furmark source/memtester source/cpustress
+DATA		:=	data
+ICON		:=	icon.jpg
+INCLUDES	:=	source source/furmark source/memtester source/cpustress ../hoc-clk/common/include
+
+APP_TITLE	:=	Benchmark Toolbox
+APP_AUTHOR	:=	Horizon-OC
+APP_VERSION	:=	2.0.0
+
+ROMFS			:=	resources
+BOREALIS_PATH	:=	lib/borealis
+
+# Output folder (in romfs) for borealis' autogenerated nanovg shaders
+OUT_SHADERS	:=	shaders
+
+#---------------------------------------------------------------------------------
+# options for code generation
+#---------------------------------------------------------------------------------
+ARCH	:=	-march=armv8-a+crc+crypto -mtune=cortex-a57 -mtp=soft -fPIE
+
+CFLAGS	:=	-g -Wall -O2 -ffunction-sections \
+			$(ARCH) $(DEFINES)
+
+CFLAGS	+=	$(INCLUDE) -D__SWITCH__ -pthread
+
+# -include optional: borealis' nanovg dk_renderer.hpp uses std::optional without
+# including <optional> (newer libstdc++ dropped the transitive include).
+CXXFLAGS	:= $(CFLAGS) -std=gnu++17 -O2 -Wno-volatile -fexceptions -include optional
+
+ASFLAGS	:=	-g $(ARCH)
+LDFLAGS	=	-specs=$(DEVKITPRO)/libnx/switch.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map) -pthread
+
+# borealis.mk prepends -ldeko3d -lm. gpu_bw.c uses EGL/GLES; the Furmark tests
+# use desktop GL via glad. Add the full GL stack.
+LIBS	:= -lglad -lGLESv2 -lEGL -lglapi -ldrm_nouveau -lnx
+
+#---------------------------------------------------------------------------------
+LIBDIRS	:= $(PORTLIBS) $(LIBNX)
+
+# Pull in borealis: appends its SOURCES / INCLUDES / LIBS / CXXFLAGS.
+# Run `git submodule update --init --recursive` so lib/borealis is populated.
+include $(TOPDIR)/$(BOREALIS_PATH)/library/borealis.mk
+
+#---------------------------------------------------------------------------------
+ifneq ($(BUILD),$(notdir $(CURDIR)))
+#---------------------------------------------------------------------------------
+
+export OUTPUT	:=	$(CURDIR)/$(TARGET)
+export TOPDIR	:=	$(CURDIR)
+
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
+			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
+
+export DEPSDIR	:=	$(CURDIR)/$(BUILD)
+
+CFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
+CPPFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
+SFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
+GLSLFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.glsl)))
+BINFILES	:=	$(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
+
+#---------------------------------------------------------------------------------
+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 .,_,$(BINFILES)))
+
+ifneq ($(strip $(ROMFS)),)
+	ROMFS_TARGETS :=
+	ROMFS_FOLDERS :=
+	ifneq ($(strip $(OUT_SHADERS)),)
+		ROMFS_SHADERS := $(ROMFS)/$(OUT_SHADERS)
+		ROMFS_TARGETS += $(patsubst %.glsl, $(ROMFS_SHADERS)/%.dksh, $(GLSLFILES))
+		ROMFS_FOLDERS += $(ROMFS_SHADERS)
+	endif
+
+	export ROMFS_DEPS := $(foreach file,$(ROMFS_TARGETS),$(CURDIR)/$(file))
+endif
+
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+			-I$(CURDIR)/$(BUILD)
+
+export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/lib)
+
+export APP_ICON := $(TOPDIR)/$(ICON)
+
+ifeq ($(strip $(NO_ICON)),)
+	export NROFLAGS += --icon=$(APP_ICON)
+endif
+
+ifeq ($(strip $(NO_NACP)),)
+	export NROFLAGS += --nacp=$(CURDIR)/$(TARGET).nacp
+endif
+
+ifneq ($(APP_TITLEID),)
+	export NACPFLAGS += --titleid=$(APP_TITLEID)
+endif
+
+ifneq ($(ROMFS),)
+	export NROFLAGS += --romfsdir=$(CURDIR)/$(ROMFS)
+endif
+
+.PHONY: all clean
+
+#---------------------------------------------------------------------------------
+all: $(ROMFS_TARGETS) | $(BUILD)
+	@MSYS2_ARG_CONV_EXCL="-D;$(MSYS2_ARG_CONV_EXCL)" $(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
+
+$(BUILD):
+	@mkdir -p $@
+
+ifneq ($(strip $(ROMFS_TARGETS)),)
+
+$(ROMFS_TARGETS): | $(ROMFS_FOLDERS)
+
+$(ROMFS_FOLDERS):
+	@mkdir -p $@
+
+$(ROMFS_SHADERS)/%_vsh.dksh: %_vsh.glsl
+	@echo {vert} $(notdir $<)
+	@uam -s vert -o $@ $<
+
+$(ROMFS_SHADERS)/%_tcsh.dksh: %_tcsh.glsl
+	@echo {tess_ctrl} $(notdir $<)
+	@uam -s tess_ctrl -o $@ $<
+
+$(ROMFS_SHADERS)/%_tesh.dksh: %_tesh.glsl
+	@echo {tess_eval} $(notdir $<)
+	@uam -s tess_eval -o $@ $<
+
+$(ROMFS_SHADERS)/%_gsh.dksh: %_gsh.glsl
+	@echo {geom} $(notdir $<)
+	@uam -s geom -o $@ $<
+
+$(ROMFS_SHADERS)/%_fsh.dksh: %_fsh.glsl
+	@echo {frag} $(notdir $<)
+	@uam -s frag -o $@ $<
+
+$(ROMFS_SHADERS)/%.dksh: %.glsl
+	@echo {comp} $(notdir $<)
+	@uam -s comp -o $@ $<
+
+endif
+
+#---------------------------------------------------------------------------------
+clean:
+	@echo clean ...
+	@rm -fr $(BUILD) $(ROMFS_FOLDERS) $(TARGET).nro $(TARGET).nacp $(TARGET).elf
+
+#---------------------------------------------------------------------------------
+else
+.PHONY:	all
+
+DEPENDS	:=	$(OFILES:.o=.d)
+
+#---------------------------------------------------------------------------------
+all	:	$(OUTPUT).nro
+
+ifeq ($(strip $(NO_NACP)),)
+$(OUTPUT).nro	:	$(OUTPUT).elf $(OUTPUT).nacp $(ROMFS_DEPS)
+else
+$(OUTPUT).nro	:	$(OUTPUT).elf $(ROMFS_DEPS)
+endif
+
+$(OUTPUT).elf	:	$(OFILES)
+
+$(OFILES_SRC)	: $(HFILES_BIN)
+
+#---------------------------------------------------------------------------------
+%.bin.o	%_bin.h :	%.bin
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+#---------------------------------------------------------------------------------
+%.png.o	%_png.h :	%.png
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+-include $(DEPENDS)
+
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------

Source/Benchmark-Toolbox/lib/borealis/.clang-format

@@ -0,0 +1,21 @@
+---
+AccessModifierOffset: -2
+AlignConsecutiveAssignments: 'true'
+BasedOnStyle: WebKit
+BreakBeforeBraces: Allman
+IncludeBlocks: Regroup
+IncludeCategories: 
+  - Regex: '^<borealis/.*\.hpp>'
+    Priority: 2
+  - Regex: '^<.*\.h>'
+    Priority: 1
+  - Regex: '^<.*'
+    Priority: 2
+  - Regex: '.*'
+    Priority: 3
+IndentCaseLabels: 'true'
+PointerAlignment: Left
+SortIncludes: 'true'
+Standard: Cpp11
+
+...

Source/Benchmark-Toolbox/lib/borealis/AUTHORS

@@ -0,0 +1,12 @@
+# List of borealis's significant contributors
+#
+# This does not necessarily list everyone who has contributed code.
+# To see the full list of contributors, see the contributors page on GitHub
+# https://github.com/natinusala/borealis/graphs/contributors
+natinusala
+p-sam
+WerWolv
+bylaws
+H0neyBadger
+D3fau4
+Behemoth

Source/Benchmark-Toolbox/lib/borealis/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Source/Benchmark-Toolbox/lib/borealis/Makefile

@@ -37,24 +37,34 @@ include $(DEVKITPRO)/libnx/switch_rules
 #   of a homebrew executable (.nro). This is intended to be used for sysmodules.
 #   NACP building is skipped as well.
 #---------------------------------------------------------------------------------
-TARGET		:=	$(notdir $(CURDIR))
-BUILD		:=	build
-SOURCES		:=	source
+TARGET		:=	borealis_demo
+BUILD		:=	build.nx
+SOURCES		:=	demo
 DATA		:=	data
-INCLUDES	:=	include
-#ROMFS	:=	romfs
+ICON		:=	resources/img/demo_icon.jpg
+INCLUDES	:=	demo
+
+APP_TITLE	:=	borealis demo
+APP_AUTHOR	:=	natinusala
+APP_VERSION	:=	1.0
+
+ROMFS				:=	resources
+BOREALIS_PATH		:=	.
+
+# Output folders for autogenerated files in romfs
+OUT_SHADERS	:=	shaders
 
 #---------------------------------------------------------------------------------
 # options for code generation
 #---------------------------------------------------------------------------------
-ARCH	:=	-march=armv8-a+crc+crypto -mtune=cortex-a57 -mtp=soft -fPIE -fPIC
+ARCH	:=	-march=armv8-a+crc+crypto -mtune=cortex-a57 -mtp=soft -fPIE
 
 CFLAGS	:=	-g -Wall -O2 -ffunction-sections \
 			$(ARCH) $(DEFINES)
 
 CFLAGS	+=	$(INCLUDE) -D__SWITCH__
 
-CXXFLAGS	:= $(CFLAGS) -fno-rtti -fno-exceptions
+CXXFLAGS	:= $(CFLAGS) -std=c++1z -O2 -Wno-volatile
 
 ASFLAGS	:=	-g $(ARCH)
 LDFLAGS	=	-specs=$(DEVKITPRO)/libnx/switch.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
@@ -67,6 +77,7 @@ LIBS	:= -lnx
 #---------------------------------------------------------------------------------
 LIBDIRS	:= $(PORTLIBS) $(LIBNX)
 
+include $(TOPDIR)/library/borealis.mk
 
 #---------------------------------------------------------------------------------
 # no real need to edit anything past this point unless you need to add additional
@@ -86,6 +97,7 @@ export DEPSDIR	:=	$(CURDIR)/$(BUILD)
 CFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
 CPPFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
 SFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
+GLSLFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.glsl)))
 BINFILES	:=	$(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
 
 #---------------------------------------------------------------------------------
@@ -107,6 +119,18 @@ export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
 export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
 export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(BINFILES)))
 
+ifneq ($(strip $(ROMFS)),)
+	ROMFS_TARGETS :=
+	ROMFS_FOLDERS :=
+	ifneq ($(strip $(OUT_SHADERS)),)
+		ROMFS_SHADERS := $(ROMFS)/$(OUT_SHADERS)
+		ROMFS_TARGETS += $(patsubst %.glsl, $(ROMFS_SHADERS)/%.dksh, $(GLSLFILES))
+		ROMFS_FOLDERS += $(ROMFS_SHADERS)
+	endif
+
+	export ROMFS_DEPS := $(foreach file,$(ROMFS_TARGETS),$(CURDIR)/$(file))
+endif
+
 export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
 			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
 			-I$(CURDIR)/$(BUILD)
@@ -155,22 +179,55 @@ ifneq ($(ROMFS),)
 	export NROFLAGS += --romfsdir=$(CURDIR)/$(ROMFS)
 endif
 
-.PHONY: $(BUILD) clean all
+.PHONY: all clean
 
 #---------------------------------------------------------------------------------
-all: $(BUILD)
+all: $(ROMFS_TARGETS) | $(BUILD)
+	@MSYS2_ARG_CONV_EXCL="-D;$(MSYS2_ARG_CONV_EXCL)" $(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
 
 $(BUILD):
-	@[ -d $@ ] || mkdir -p $@
-	@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
+	@mkdir -p $@
+
+ifneq ($(strip $(ROMFS_TARGETS)),)
+
+$(ROMFS_TARGETS): | $(ROMFS_FOLDERS)
+
+$(ROMFS_FOLDERS):
+	@mkdir -p $@
+
+$(ROMFS_SHADERS)/%_vsh.dksh: %_vsh.glsl
+	@echo {vert} $(notdir $<)
+	@uam -s vert -o $@ $<
+
+$(ROMFS_SHADERS)/%_tcsh.dksh: %_tcsh.glsl
+	@echo {tess_ctrl} $(notdir $<)
+	@uam -s tess_ctrl -o $@ $<
+
+$(ROMFS_SHADERS)/%_tesh.dksh: %_tesh.glsl
+	@echo {tess_eval} $(notdir $<)
+	@uam -s tess_eval -o $@ $<
+
+$(ROMFS_SHADERS)/%_gsh.dksh: %_gsh.glsl
+	@echo {geom} $(notdir $<)
+	@uam -s geom -o $@ $<
+
+$(ROMFS_SHADERS)/%_fsh.dksh: %_fsh.glsl
+	@echo {frag} $(notdir $<)
+	@uam -s frag -o $@ $<
+
+$(ROMFS_SHADERS)/%.dksh: %.glsl
+	@echo {comp} $(notdir $<)
+	@uam -s comp -o $@ $<
+
+endif
 
 #---------------------------------------------------------------------------------
 clean:
 	@echo clean ...
 ifeq ($(strip $(APP_JSON)),)
-	@rm -fr $(BUILD) $(TARGET).nro $(TARGET).nacp $(TARGET).elf
+	@rm -fr $(BUILD) $(ROMFS_FOLDERS) $(TARGET).nro $(TARGET).nacp $(TARGET).elf
 else
-	@rm -fr $(BUILD) $(TARGET).nsp $(TARGET).nso $(TARGET).npdm $(TARGET).elf
+	@rm -fr $(BUILD) $(ROMFS_FOLDERS) $(TARGET).nsp $(TARGET).nso $(TARGET).npdm $(TARGET).elf
 endif
 
 
@@ -188,9 +245,9 @@ ifeq ($(strip $(APP_JSON)),)
 all	:	$(OUTPUT).nro
 
 ifeq ($(strip $(NO_NACP)),)
-$(OUTPUT).nro	:	$(OUTPUT).elf $(OUTPUT).nacp
+$(OUTPUT).nro	:	$(OUTPUT).elf $(OUTPUT).nacp $(ROMFS_DEPS)
 else
-$(OUTPUT).nro	:	$(OUTPUT).elf
+$(OUTPUT).nro	:	$(OUTPUT).elf $(ROMFS_DEPS)
 endif
 
 else
@@ -219,4 +276,4 @@ $(OFILES_SRC)	: $(HFILES_BIN)
 
 #---------------------------------------------------------------------------------------
 endif
-#---------------------------------------------------------------------------------------
+#---------------------------------------------------------------------------------------

Source/Benchmark-Toolbox/lib/borealis/NOTICE

@@ -0,0 +1,13 @@
+Copyright 2019-2021 borealis contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

Source/Benchmark-Toolbox/lib/borealis/README.md

@@ -0,0 +1,79 @@
+![borealis logo](https://github.com/natinusala/borealis/blob/main/resources/img/borealis_96.png?raw=true)
+# borealis
+
+Controller and TV oriented UI library for PC and Nintendo Switch (libnx).
+
+⚠️ Warning: the project is a WIP - See the Projects tab to follow the journey towards a stable version!
+
+The code for the old version is available in the `legacy` branch.
+
+⚠️ The wiki only contains the documentation for the old version of the library, it has yet to be updated!
+
+- Mimicks the Nintendo Switch system UI, but can also be used to make anything else painlessly
+- Hardware acceleration and vector graphics with automatic scaling for TV usage (powered by nanovg)
+- Can be ported to new platforms and graphics APIs by providing a nanovg implementation
+- Powerful layout engine using flex box as a base for everything (powered by Yoga Layout)
+- Automated navigation paths for out-of-the-box controller navigation
+- Out of the box touch support
+- Define user interfaces using XML and only write code when it matters
+- Use and restyle built-in components or make your own from scratch
+- Display large amount of data efficiently using recycling lists
+- Integrated internationalization and storage systems
+- Integrated toolbox (logger, animations, timers, background tasks...)
+
+## Building the demo for Switch
+
+To build for Switch, a standard development environment must first be set up. In order to do so, [refer to the Getting Started guide](https://devkitpro.org/wiki/Getting_Started).
+
+```bash
+(sudo) (dkp-)pacman -S switch-glfw switch-mesa switch-glm
+make -j
+nxlink -s borealis_demo.nro
+```
+
+## Building the demo for PC
+
+To build for PC, the following components are required:
+
+- meson/ninja build system
+- A C++ compiler supporting the C++17 standard
+- GLFW version 3.3 or higher (as a static library)
+- GLM version 0.9.8 or higher
+
+Please refer to the usual sources of information for your particular operating system. Usually the commands needed to build this project will look like this:
+
+```bash
+meson build
+ninja -C build
+./build/borealis_demo
+```
+
+Also, please note that the `resources` folder must be available in the working directory, otherwise the program will fail to find the shaders.
+
+### Building the demo for Windows using msys2
+
+msys2 provides all packages needed to build this project:
+
+```bash
+pacman -S mingw-w64-x86_64-gcc mingw-w64-x86_64-meson mingw-w64-x86_64-ninja mingw-w64-x86_64-pkg-config mingw-w64-x86_64-glfw mingw-w64-x86_64-glm
+meson build
+ninja -C build
+./build/borealis_demo
+```
+
+### Including in your project (TL;DR: see the demo makefile in this repo)
+0. Your project must be built as C++17 (`-std=c++1z`). You also need to remove `-fno-rtti` and `-fno-exceptions` if you have them
+1. Use a submodule (or even better, a [subrepo](https://github.com/ingydotnet/git-subrepo)) to clone this repository in your project
+2. Copy the `resources` folder to the root of your project
+3. For PC (meson):
+    1. take a standard meson file
+    2. use `subdir` to import the library folder
+    3. use the `borealis_files`, `borealis_dependencies`, `borealis_include` and `borealis_cpp_args` variables for respectively objects to build, dependencies (glfw...), includes directory and cpp args
+    4. add a `BRLS_RESOURCES` define pointing to the resources folder at runtime (so `resources`)
+4. For Switch:
+    1. take a standard deko3d homebrew makefile (from the switch-examples repo)
+    2. add a `BOREALIS_PATH` variable containing the subfolder you put the library in
+    3. set `ROMFS` to the resources folder - borealis resources path is set to `romfs:/` in borealis.mk
+    4. use `include` to load `borealis.mk` (after `LIBDIRS` and `BOREALIS_PATH`)
+    5. it's important for `OUT_SHADERS` to be set to `shaders` since nanovg will look for the shaders there
+    6. if you have issues with the `BRLS_RESOURCES` define (missing quote terminator), change the `@$(MAKE)` line to `@MSYS2_ARG_CONV_EXCL="-D;$(MSYS2_ARG_CONV_EXCL)" $(MAKE)` in the Makefile (as in the demo Makefile)

Source/Benchmark-Toolbox/lib/borealis/demo/captioned_image.cpp

@@ -0,0 +1,65 @@
+/*
+    Copyright 2020-2021 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#include "captioned_image.hpp"
+
+CaptionedImage::CaptionedImage()
+{
+    // Load the XML file and inflate ourself with its content
+    // The top-level Box in the XML corresponds to us, and every XML child
+    // is added to our children (and the attributes are applied)
+    // The CaptionedImage instance basically becomes what's written in the XML
+    this->inflateFromXMLRes("xml/views/captioned_image.xml");
+
+    // The label stays hidden until focused, so hide it right away
+    this->label->hide([] {});
+
+    // Forward Image and Label XML attributes
+    this->forwardXMLAttribute("scalingType", this->image);
+    this->forwardXMLAttribute("image", this->image);
+    this->forwardXMLAttribute("focusUp", this->image);
+    this->forwardXMLAttribute("focusRight", this->image);
+    this->forwardXMLAttribute("focusDown", this->image);
+    this->forwardXMLAttribute("focusLeft", this->image);
+    this->forwardXMLAttribute("imageWidth", this->image, "width");
+    this->forwardXMLAttribute("imageHeight", this->image, "height");
+
+    this->forwardXMLAttribute("caption", this->label, "text");
+}
+
+void CaptionedImage::onChildFocusGained(brls::View* directChild, brls::View* focusedView)
+{
+    // Called when a child of ours gets focused, in that case it's the Image
+
+    Box::onChildFocusGained(directChild, focusedView);
+
+    this->label->show([] {});
+}
+
+void CaptionedImage::onChildFocusLost(brls::View* directChild, brls::View* focusedView)
+{
+    // Called when a child of ours losts focused, in that case it's the Image
+
+    Box::onChildFocusLost(directChild, focusedView);
+
+    this->label->hide([] {});
+}
+
+brls::View* CaptionedImage::create()
+{
+    // Called by the XML engine to create a new CaptionedImage
+    return new CaptionedImage();
+}

Source/Benchmark-Toolbox/lib/borealis/demo/captioned_image.hpp

@@ -0,0 +1,34 @@
+/*
+    Copyright 2020-2021 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#include <borealis.hpp>
+
+class CaptionedImage : public brls::Box
+{
+  public:
+    CaptionedImage();
+
+    void onChildFocusGained(brls::View* directChild, brls::View* focusedView) override;
+    void onChildFocusLost(brls::View* directChild, brls::View* focusedView) override;
+
+    static brls::View* create();
+
+  private:
+    BRLS_BIND(brls::Image, image, "image");
+    BRLS_BIND(brls::Label, label, "label");
+};

Source/Benchmark-Toolbox/lib/borealis/demo/components_tab.cpp

@@ -0,0 +1,43 @@
+/*
+    Copyright 2021 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#include "components_tab.hpp"
+
+ComponentsTab::ComponentsTab()
+{
+    // Inflate the tab from the XML file
+    this->inflateFromXMLRes("xml/tabs/components.xml");
+
+    // Bind the button click to a method using the macro (just for the sake of showcasing it, it's overkill in this situation)
+    BRLS_REGISTER_CLICK_BY_ID("button_primary", this->onPrimaryButtonClicked);
+
+    // Get a handle to the button and register the action directly
+    brls::Button* highlightButton = (brls::Button*)this->getView("button_highlight");
+    highlightButton->registerAction(
+        "Honk", brls::BUTTON_A, [](brls::View* view) { return true; }, false, brls::SOUND_HONK);
+}
+
+bool ComponentsTab::onPrimaryButtonClicked(brls::View* view)
+{
+    brls::Logger::info("Clicked");
+    return true;
+}
+
+brls::View* ComponentsTab::create()
+{
+    // Called by the XML engine to create a new ComponentsTab
+    return new ComponentsTab();
+}

Source/Benchmark-Toolbox/lib/borealis/demo/components_tab.hpp

@@ -0,0 +1,30 @@
+/*
+    Copyright 2021 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#include <borealis.hpp>
+
+class ComponentsTab : public brls::Box
+{
+  public:
+    ComponentsTab();
+
+    static brls::View* create();
+
+  private:
+    bool onPrimaryButtonClicked(brls::View* view);
+};

Source/Benchmark-Toolbox/lib/borealis/demo/main.cpp

@@ -0,0 +1,82 @@
+/*
+    Copyright 2020-2021 natinusala
+    Copyright 2019 p-sam
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+// Switch include only necessary for demo videos recording
+#ifdef __SWITCH__
+#include <switch.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <borealis.hpp>
+#include <string>
+
+#include "captioned_image.hpp"
+#include "components_tab.hpp"
+#include "main_activity.hpp"
+#include "recycling_list_tab.hpp"
+
+using namespace brls::literals; // for _i18n
+
+int main(int argc, char* argv[])
+{
+    // Enable recording for Twitter memes
+#ifdef __SWITCH__
+    appletInitializeGamePlayRecording();
+#endif
+
+    // Set log level
+    // We recommend to use INFO for real apps
+    brls::Logger::setLogLevel(brls::LogLevel::DEBUG);
+
+    // Init the app and i18n
+    if (!brls::Application::init())
+    {
+        brls::Logger::error("Unable to init Borealis application");
+        return EXIT_FAILURE;
+    }
+
+    brls::Application::createWindow("demo/title"_i18n);
+
+    // Have the application register an action on every activity that will quit when you press BUTTON_START
+    brls::Application::setGlobalQuit(true);
+
+    // Register custom views (including tabs, which are views)
+    brls::Application::registerXMLView("CaptionedImage", CaptionedImage::create);
+    brls::Application::registerXMLView("RecyclingListTab", RecyclingListTab::create);
+    brls::Application::registerXMLView("ComponentsTab", ComponentsTab::create);
+
+    // Add custom values to the theme
+    brls::getLightTheme().addColor("captioned_image/caption", nvgRGB(2, 176, 183));
+    brls::getDarkTheme().addColor("captioned_image/caption", nvgRGB(51, 186, 227));
+
+    // Add custom values to the style
+    brls::getStyle().addMetric("about/padding_top_bottom", 50);
+    brls::getStyle().addMetric("about/padding_sides", 75);
+    brls::getStyle().addMetric("about/description_margin", 50);
+
+    // Create and push the main activity to the stack
+    brls::Application::pushActivity(new MainActivity());
+
+    // Run the app
+    while (brls::Application::mainLoop())
+        ;
+
+    // Exit
+    return EXIT_SUCCESS;
+}

Source/Benchmark-Toolbox/lib/borealis/demo/main_activity.cpp

@@ -0,0 +1,17 @@
+/*
+    Copyright 2020-2021 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#include "main_activity.hpp"

Source/Benchmark-Toolbox/lib/borealis/demo/main_activity.hpp

@@ -0,0 +1,26 @@
+/*
+    Copyright 2020-2021 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#include <borealis.hpp>
+
+class MainActivity : public brls::Activity
+{
+  public:
+    // Declare that the content of this activity is the given XML file
+    CONTENT_FROM_XML_RES("activity/main.xml");
+};

Source/Benchmark-Toolbox/lib/borealis/demo/recycling_list_tab.cpp

@@ -0,0 +1,29 @@
+/*
+    Copyright 2020-2021 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#include "recycling_list_tab.hpp"
+
+RecyclingListTab::RecyclingListTab()
+{
+    // Inflate the tab from the XML file
+    this->inflateFromXMLRes("xml/tabs/recycling_list.xml");
+}
+
+brls::View* RecyclingListTab::create()
+{
+    // Called by the XML engine to create a new RecyclingListTab
+    return new RecyclingListTab();
+}

Source/Benchmark-Toolbox/lib/borealis/demo/recycling_list_tab.hpp

@@ -0,0 +1,27 @@
+/*
+    Copyright 2020-2021 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#include <borealis.hpp>
+
+class RecyclingListTab : public brls::Box
+{
+  public:
+    RecyclingListTab();
+
+    static brls::View* create();
+};

Source/Benchmark-Toolbox/lib/borealis/library/borealis.mk

@@ -0,0 +1,35 @@
+mkfile_path	:=	$(abspath $(lastword $(MAKEFILE_LIST)))
+current_dir	:=	$(BOREALIS_PATH)/$(notdir $(patsubst %/,%,$(dir $(mkfile_path))))
+
+LIBS		:=	-ldeko3d -lm $(LIBS)
+
+include $(TOPDIR)/$(current_dir)/lib/extern/switch-libpulsar/deps.mk
+
+SOURCES		:=	$(SOURCES) \
+				$(current_dir)/lib/core \
+				$(current_dir)/lib/views \
+				$(current_dir)/lib/platforms/switch \
+				$(current_dir)/lib/extern/glad \
+				$(current_dir)/lib/extern/nanovg-deko3d/source \
+				$(current_dir)/lib/extern/nanovg-deko3d/source/framework \
+				$(current_dir)/lib/extern/nanovg-deko3d/shaders \
+				$(current_dir)/lib/extern/libretro-common/compat \
+				$(current_dir)/lib/extern/libretro-common/encodings \
+				$(current_dir)/lib/extern/libretro-common/features \
+				$(current_dir)/lib/extern/nxfmtwrapper \
+				$(current_dir)/lib/extern/yoga/src/yoga/event \
+				$(current_dir)/lib/extern/yoga/src/yoga \
+				$(current_dir)/lib/extern/tinyxml2/ \
+				$(addprefix $(current_dir)/lib/extern/switch-libpulsar/, $(PLSR_SOURCES))
+
+INCLUDES	:=	$(INCLUDES) \
+				$(current_dir)/include \
+				$(current_dir)/lib/extern/fmt/include \
+				$(current_dir)/lib/extern/yoga/src \
+				$(current_dir)/lib/extern/nanovg-deko3d/include \
+				$(current_dir)/lib/extern/tweeny/include \
+				$(current_dir)/include/borealis/extern \
+				$(current_dir)/include/borealis/extern/tinyxml2 \
+				$(addprefix $(current_dir)/lib/extern/switch-libpulsar/, $(PLSR_INCLUDES))
+
+CXXFLAGS := $(CXXFLAGS) -DYG_ENABLE_EVENTS -fdata-sections -DBRLS_RESOURCES="\"romfs:/\""

Source/Benchmark-Toolbox/lib/borealis/library/include/borealis.hpp

@@ -0,0 +1,53 @@
+/*
+    Copyright 2019-2021 natinusala
+    Copyright 2019 p-sam
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+// Core
+#include <borealis/core/actions.hpp>
+#include <borealis/core/activity.hpp>
+#include <borealis/core/animation.hpp>
+#include <borealis/core/application.hpp>
+#include <borealis/core/assets.hpp>
+#include <borealis/core/audio.hpp>
+#include <borealis/core/bind.hpp>
+#include <borealis/core/box.hpp>
+#include <borealis/core/event.hpp>
+#include <borealis/core/font.hpp>
+#include <borealis/core/frame_context.hpp>
+#include <borealis/core/i18n.hpp>
+#include <borealis/core/input.hpp>
+#include <borealis/core/logger.hpp>
+#include <borealis/core/platform.hpp>
+#include <borealis/core/style.hpp>
+#include <borealis/core/task.hpp>
+#include <borealis/core/theme.hpp>
+#include <borealis/core/time.hpp>
+#include <borealis/core/timer.hpp>
+#include <borealis/core/video.hpp>
+#include <borealis/core/view.hpp>
+
+//Views
+#include <borealis/views/applet_frame.hpp>
+#include <borealis/views/button.hpp>
+#include <borealis/views/header.hpp>
+#include <borealis/views/image.hpp>
+#include <borealis/views/label.hpp>
+#include <borealis/views/rectangle.hpp>
+#include <borealis/views/scrolling_frame.hpp>
+#include <borealis/views/sidebar.hpp>
+#include <borealis/views/tab_frame.hpp>

Source/Benchmark-Toolbox/lib/borealis/library/include/borealis/core/actions.hpp

@@ -0,0 +1,52 @@
+/*
+    Copyright 2020 WerWolv
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#include <borealis/core/audio.hpp>
+#include <borealis/core/input.hpp>
+#include <functional>
+#include <string>
+
+namespace brls
+{
+
+class View;
+
+typedef std::function<bool(View*)> ActionListener;
+
+typedef int ActionIdentifier;
+
+#define ACTION_NONE -1
+
+struct Action
+{
+    enum ControllerButton button;
+
+    ActionIdentifier identifier;
+    std::string hintText;
+    bool available;
+    bool hidden;
+    enum Sound sound;
+    ActionListener actionListener;
+
+    bool operator==(const enum ControllerButton other)
+    {
+        return this->button == other;
+    }
+};
+
+} // namespace brls

Source/Benchmark-Toolbox/lib/borealis/library/include/borealis/core/activity.hpp

@@ -0,0 +1,162 @@
+/*
+    Copyright 2020 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#include <borealis/core/view.hpp>
+
+namespace brls
+{
+
+#define CONTENT_FROM_XML_RES(x) \
+    brls::View* createContentView() override { return brls::View::createFromXMLResource(x); }
+#define CONTENT_FROM_XML_FILE(x) \
+    brls::View* createContentView() override { return brls::View::createFromXMLFile(x); }
+#define CONTENT_FROM_XML_STR(x) \
+    brls::View* createContentView() override { return brls::View::createFromXMLString(x); }
+
+// An activity is a "screen" of your app in which the library adds
+// the UI components. The app is made of a stack of activities, each activity
+// containing a views tree.
+class Activity
+{
+  public:
+    Activity();
+    virtual ~Activity();
+
+    /**
+     * Sets the content view of this activity, aka
+     * the root view of the tree.
+     *
+     * When the activity is pushed, setContentView() is
+     * automatically called with the result of createContentView().
+     * As such, you should override createContentView() if you want
+     * to use XML in your activity.
+     */
+    void setContentView(View* view);
+
+    /**
+     * Called when the activity is created. Should return the activity content view, if any.
+     *
+     * Returning nullptr means the content is not known when the activity is created.
+     *
+     * You can use View::createFromXMLFile(), View::createFromXMLResource() and View::createFromXMLString() to load
+     * a view from respectively an XML file path, an XML name in the resources/xml romfs directory and an XML string.
+     *
+     * The CONTENT_FROM_XML_FILE, CONTENT_FROM_XML_RES, CONTENT_FROM_XML_STR macros
+     * are made to make this process simpler: just use them in the public block of your activity
+     * header and it will override createContentView() with the right code for you.
+     *
+     * The onContentAvailable() method will be called once the content has been created, so that
+     * you can get the references to the activity views (by id).
+     */
+    virtual View* createContentView();
+
+    /**
+     * Called when the content view is created, so that
+     * you can get the references to the activity views (by id).
+     */
+    virtual void onContentAvailable() {};
+
+    View* getContentView();
+
+    /**
+     * Returns the view with the corresponding id, or nullptr
+     * if it hasn't been found in the activity.
+     */
+    View* getView(std::string id);
+
+    /**
+     * Resizes the activity to fit the window. Called when the activity
+     * is created and when the window is resized (Switch dock counts as window resize).
+     */
+    void resizeToFitWindow();
+
+    /**
+     * Returns the duration of the activity show / hide animation.
+     */
+    virtual float getShowAnimationDuration(TransitionAnimation animation);
+
+    /**
+     * Is this activity translucent, aka can we see the
+     * activities under it in the stack?
+     */
+    bool isTranslucent();
+
+    void willAppear(bool resetState = false);
+    void willDisappear(bool resetState = false);
+
+    /**
+     * If set to true, will force the activity to be translucent.
+     */
+    void setInFadeAnimation(bool translucent);
+
+    /**
+      * Shows the activity with a fade in animation, or no animation at all.
+      */
+    void show(std::function<void(void)> cb, bool animate, float animationDuration);
+
+    /**
+      * Hides the activity with a fade in animation, or no animation at all.
+      */
+    void hide(std::function<void(void)> cb, bool animate, float animationDuration);
+
+    bool isHidden();
+
+    /**
+     * Registers an action with the given parameters on the content view. The listener will be fired
+     * when the user presses the key.
+     *
+     * The listener should return true if the action was consumed, false otherwise.
+     * The sound will only be played if the listener returned true.
+     *
+     * A hidden action will not show up in the bottom-right hints.
+     *
+     * Must be called after the content view is set.
+     *
+     * Returns the identifier for the action, so it can be unregistered later on. Returns ACTION_NONE if the
+     * action was not registered.
+     */
+    ActionIdentifier registerAction(std::string hintText, enum ControllerButton button, ActionListener actionListener, bool hidden = false, enum Sound sound = SOUND_NONE);
+
+    /**
+     * Unregisters an action with the given identifier on the content view.
+     *
+     * Must be called after the content view is set.
+     */
+    void unregisterAction(ActionIdentifier identifier);
+
+    /**
+     * Registers an action to exit the application with the default button BUTTON_START.
+     *
+     * Must be called after the content view is set.
+     *
+     * Returns the identifier for the action, so it can be unregistered later on. Returns ACTION_NONE if the
+     * action was not registered.
+     */
+    ActionIdentifier registerExitAction(enum ControllerButton button = brls::BUTTON_START);
+
+    void onWindowSizeChanged();
+
+    View* getDefaultFocus();
+
+    void setAlpha(float alpha);
+
+  private:
+    View* contentView = nullptr;
+};
+
+} // namespace brls

Source/Benchmark-Toolbox/lib/borealis/library/include/borealis/core/animation.hpp

@@ -0,0 +1,104 @@
+/*
+    Copyright 2021 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#include <tweeny.h>
+
+#include <borealis/core/time.hpp>
+
+namespace brls
+{
+
+using EasingFunction = tweeny::easing::enumerated;
+
+// An animatable is a float which value can be animated from an initial value to a target value,
+// during a given amount of time. An easing function can also be specified.
+//
+// Declare the animatable and then use reset(initialValue) to reset the animation.
+// Add as many steps as you like by calling addStep(targetValue, duration, easing) one or multiple times.
+// Then, start and stop the animation with start() and stop().
+//
+// setEndCallback() and setTickCallback() allow you to execute code as long as the animation runs and / or once when it finishes.
+// Use .getValue() to get the current value at any time.
+//
+// An animatable has overloads for float conversion, comparison (==) and assignment operator (=) to allow
+// basic usage as a simple float. Assignment operator is a shortcut to the reset() method.
+class Animatable : public FiniteTicking
+{
+  public:
+    /**
+     * Creates an animatable with the given initial value.
+     */
+    Animatable(float value = 0.0f);
+
+    /**
+     * Returns the current animatable value.
+     */
+    float getValue();
+
+    /**
+     * Stops and resets the animation, going back to the given initial value.
+     * All steps are removed.
+     * If an animation was already ongoing for that animatable, its end callback
+     * will be called.
+     */
+    void reset(float initialValue);
+
+    /**
+     * Stops and resets the animation. The value will stay where it's at.
+     * All steps are removed.
+     * If an animation was already ongoing for that animatable, its end callback
+     * will be called.
+     */
+    void reset();
+
+    /**
+     * Adds an animation step to the target value, lasting the specified duration in milliseconds.
+     *
+     * An animation can have multiple steps. Target value can be greater and lower than the previous step (it can go forwards or backwards).
+     * Easing function is optional, default is EasingFunction::linear.
+     *
+     * Duration is int32_t due to internal limitations, so a step cannot last for longer than 2 147 483 647ms.
+     * The sum of the duration of all steps cannot exceed 71582min.
+     */
+    void addStep(float targetValue, int32_t duration, EasingFunction easing = EasingFunction::linear);
+
+    /**
+     * Returns the progress of the animation between 0.0f and 1.0f.
+     */
+    float getProgress();
+
+    operator float() const;
+    operator float();
+    void operator=(const float value);
+    bool operator==(const float value);
+
+  protected:
+    bool onUpdate(Time delta) override;
+
+    void onReset() override;
+    void onRewind() override;
+
+  private:
+    float currentValue = 0.0f;
+    tweeny::tween<float> tween;
+};
+
+void updateHighlightAnimation();
+void getHighlightAnimation(float* gradient_x, float* gradient_y, float* color);
+
+} // namespace brls

Source/Benchmark-Toolbox/lib/borealis/library/include/borealis/core/application.hpp

@@ -0,0 +1,246 @@
+/*
+    Copyright 2019-2021 natinusala
+    Copyright 2019 p-sam
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#include <nanovg.h>
+#include <tinyxml2.h>
+
+#include <borealis/core/activity.hpp>
+#include <borealis/core/audio.hpp>
+#include <borealis/core/font.hpp>
+#include <borealis/core/frame_context.hpp>
+#include <borealis/core/logger.hpp>
+#include <borealis/core/platform.hpp>
+#include <borealis/core/style.hpp>
+#include <borealis/core/theme.hpp>
+#include <borealis/core/view.hpp>
+#include <borealis/views/label.hpp>
+#include <unordered_map>
+#include <vector>
+
+namespace brls
+{
+
+typedef std::function<View*(void)> XMLViewCreator;
+
+class Application
+{
+  public:
+    /**
+     * Inits the borealis application.
+     * Returns true if it succeeded, false otherwise.
+     */
+    static bool init();
+
+    /**
+     * Creates the application window with the given title.
+     * Must be called after calling init().
+     */
+    static void createWindow(std::string title);
+
+    /**
+     * Application main loop iteration.
+     * Must be called in an infinite loop until it returns false.
+     */
+    static bool mainLoop();
+
+    static Platform* getPlatform();
+    static AudioPlayer* getAudioPlayer();
+
+    static NVGcontext* getNVGContext();
+    inline static float contentWidth, contentHeight;
+
+    /**
+     * Called by the video context when the content window is resized
+     * and when the context is ready (to setup the initial content scaling).
+     */
+    static void onWindowResized(int width, int height);
+
+    /**
+      * Pushes a view on this applications's view stack.
+      *
+      * The view will automatically be resized to take
+      * the whole screen.
+      *
+      * The view will gain focus if applicable.
+      *
+      * The first activity to be pushed cannot be popped.
+      */
+    static void pushActivity(Activity* view, TransitionAnimation animation = TransitionAnimation::FADE);
+
+    /**
+      * Pops the last pushed activity from the stack
+      * and gives focus back where it was before.
+      */
+    static void popActivity(
+        TransitionAnimation animation = TransitionAnimation::FADE, std::function<void(void)> cb = [] {});
+
+    /**
+     * Gives the focus to the given view
+     * or clears the focus if given nullptr.
+     */
+    static void giveFocus(View* view);
+
+    inline static Style getStyle()
+    {
+        return brls::getStyle();
+    }
+
+    static Theme getTheme();
+    static ThemeVariant getThemeVariant();
+
+    /**
+     * Loads a font from a given file and stores it in the font stash.
+     * Returns true if the operation succeeded.
+     */
+    static bool loadFontFromFile(std::string fontName, std::string filePath);
+
+    /**
+     * Loads a font from a given memory buffer and stores it in the font stash.
+     * Returns true if the operation succeeded.
+     */
+    static bool loadFontFromMemory(std::string fontName, void* data, size_t size, bool freeData);
+
+    /**
+     * Returns the nanovg handle to the given font name, or FONT_INVALID if
+     * no such font is currently loaded.
+     */
+    static int getFont(std::string fontName);
+
+    static void notify(std::string text);
+
+    static void onControllerButtonPressed(enum ControllerButton button, bool repeating);
+
+    /**
+      * "Crashes" the app (displays a fullscreen CrashFrame)
+      */
+    static void crash(std::string text);
+
+    static void quit();
+
+    /**
+      * Blocks any and all user inputs
+      */
+    static void blockInputs();
+
+    /**
+      * Unblocks inputs after a call to
+      * blockInputs()
+      */
+    static void unblockInputs();
+
+    static void setCommonFooter(std::string footer);
+    static std::string* getCommonFooter();
+
+    static void setDisplayFramerate(bool enabled);
+    static void toggleFramerateDisplay();
+
+    static void setMaximumFPS(unsigned fps);
+
+    inline static float windowScale;
+
+    /**
+     * Sets whether BUTTON_START will globally be used to close the application.
+     */
+    static void setGlobalQuit(bool enabled);
+
+    /**
+     * Sets whether BUTTON_BACK will globally be used to toggle an FPS display.
+     */
+    static void setGlobalFPSToggle(bool enabled);
+
+    static GenericEvent* getGlobalFocusChangeEvent();
+    static VoidEvent* getGlobalHintsUpdateEvent();
+
+    static View* getCurrentFocus();
+
+    static std::string getTitle();
+
+    /**
+     * Registers a view to be created from XML. You must give the name of the XML node as well
+     * as a function that creates the view.
+     *
+     * If you need attributes, register them with the given functions in the view
+     * class constructor directly. They will be called one by one after the view is instantiated.
+     *
+     * You should not add any children in the function, it is already taken care of.
+     */
+    static void registerXMLView(std::string name, XMLViewCreator creator);
+
+    static bool XMLViewsRegisterContains(std::string name);
+    static XMLViewCreator getXMLViewCreator(std::string name);
+
+    /**
+     * Returns the current system locale.
+     */
+    static std::string getLocale();
+
+  private:
+    inline static bool inited        = false;
+    inline static bool quitRequested = false;
+
+    inline static Platform* platform = nullptr;
+
+    inline static std::string title;
+
+    inline static FontStash fontStash;
+
+    inline static std::vector<Activity*> activitiesStack;
+    inline static std::vector<View*> focusStack;
+
+    inline static unsigned windowWidth, windowHeight;
+
+    inline static View* currentFocus;
+
+    inline static unsigned blockInputsTokens = 0; // any value > 0 means inputs are blocked
+
+    inline static std::string commonFooter = "";
+
+    inline static bool globalQuitEnabled                     = false;
+    inline static ActionIdentifier gloablQuitIdentifier      = ACTION_NONE;
+    inline static bool globalFPSToggleEnabled                = false;
+    inline static ActionIdentifier gloablFPSToggleIdentifier = ACTION_NONE;
+
+    inline static View* repetitionOldFocus = nullptr;
+
+    inline static GenericEvent globalFocusChangeEvent;
+    inline static VoidEvent globalHintsUpdateEvent;
+
+    inline static std::unordered_map<std::string, XMLViewCreator> xmlViewsRegister;
+
+    static void navigate(FocusDirection direction);
+
+    static void onWindowSizeChanged();
+
+    static void frame();
+    static void clear();
+    static void exit();
+
+    /**
+     * Handles actions for the currently focused view and
+     * the given button
+     * Returns true if at least one action has been fired
+     */
+    static bool handleAction(char button);
+
+    static void registerBuiltInXMLViews();
+
+    static ActionIdentifier registerFPSToggleAction(Activity* activity);
+};
+
+} // namespace brls

Source/Benchmark-Toolbox/lib/borealis/library/include/borealis/core/assets.hpp

@@ -0,0 +1,23 @@
+/*
+    Copyright 2019-2021 natinusala
+    Copyright 2019 p-sam
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#ifndef BRLS_RESOURCES
+#error BRLS_RESOURCES define missing
+#endif
+#define BRLS_ASSET(_str) BRLS_RESOURCES _str

Source/Benchmark-Toolbox/lib/borealis/library/include/borealis/core/audio.hpp

@@ -0,0 +1,78 @@
+/*
+    Copyright 2021 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+namespace brls
+{
+
+enum Sound
+{
+    SOUND_NONE = 0, // no sound
+
+    SOUND_FOCUS_CHANGE, // played when the focus changes
+    SOUND_FOCUS_ERROR, // played when the user wants to go somewhere impossible (while the highlight wiggles)
+    SOUND_CLICK, // played when the click action runs
+    SOUND_FOCUS_SIDEBAR, // played when the focus changes to a sidebar item
+    SOUND_CLICK_ERROR, // played when the user clicks a disabled button / a view focused with no click action
+    SOUND_HONK, // honk
+    SOUND_CLICK_SIDEBAR, // played when a sidebar item is clicked
+
+    _SOUND_MAX, // not an actual sound, just used to count of many sounds there are
+};
+
+// Platform agnostic Audio player
+// Each platform's AudioPlayer is responsible for managing the enum Sound -> internal representation map
+class AudioPlayer
+{
+  public:
+    virtual ~AudioPlayer() {};
+
+    /**
+     * Preemptively loads the given sound so that it's ready to be played
+     * when needed.
+     *
+     * Returns a boolean indicating if the sound has been loaded or not.
+     */
+    virtual bool load(enum Sound sound) = 0;
+
+    /**
+     * Plays the given sound.
+     *
+     * The AudioPlayer should not assume that the sound has been
+     * loaded already, and must load it if needed.
+     *
+     * Returns a boolean indicating if the sound has been played or not.
+     */
+    virtual bool play(enum Sound sound) = 0;
+};
+
+// An AudioPlayer that does nothing
+class NullAudioPlayer : public AudioPlayer
+{
+  public:
+    bool load(enum Sound sound) override
+    {
+        return false;
+    }
+
+    bool play(enum Sound sound) override
+    {
+        return false;
+    }
+};
+
+} // namespace brls

Source/Benchmark-Toolbox/lib/borealis/library/include/borealis/core/bind.hpp

@@ -0,0 +1,126 @@
+/*
+    Copyright 2021 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#include <borealis/core/activity.hpp>
+#include <borealis/core/view.hpp>
+
+namespace brls
+{
+
+// Exception thrown when using a BoundView with an unknown ID for
+// the given owner.
+class ViewNotFoundException : public std::exception
+{
+  public:
+    ViewNotFoundException(View* owner, std::string searchedId);
+    ViewNotFoundException(Activity* owner, std::string searchedId);
+
+    const char* what() const noexcept;
+
+  private:
+    std::string errorMessage;
+};
+
+#define BRLS_BIND(type, name, id) brls::BoundView<type> name = brls::BoundView<type>(id, this)
+
+// A BoundView represents a "child" view, bound to its "parent" view class.
+// Dereferencing operator has been overridden to directly resolve the view by ID and forward the call to the view pointer for you.
+// Allows easy access of child views inside the parent class when used with the BRLS_BIND macro.
+// Does NOT do any type check - it assumes the type you give it is the same as the view you are trying to get.
+template <typename T>
+class BoundView
+{
+  public:
+    BoundView(std::string id, View* owner)
+        : id(id)
+        , ownerView(owner)
+    {
+    }
+
+    BoundView(std::string id, Activity* owner)
+        : id(id)
+        , ownerActivity(owner)
+    {
+    }
+
+    T* getView()
+    {
+        this->resolve();
+        return this->view;
+    }
+
+    operator T*()
+    {
+        return this->getView();
+    }
+
+    T* operator->()
+    {
+        return this->getView();
+    }
+
+    bool operator==(const T* value)
+    {
+        return this->getView() == value;
+    }
+
+  private:
+    std::string id = "";
+
+    T* view = nullptr;
+
+    View* ownerView         = nullptr;
+    Activity* ownerActivity = nullptr;
+
+    /**
+     * Resolve the view pointer by id.
+     *
+     * Not called in the constructor
+     * on purpose because the owner might now be ready when
+     * the BoundView is constructed, so wait for the first
+     * actual call before resolving the view.
+     */
+    void resolve()
+    {
+        if (this->view)
+            return;
+
+        // Resolve by owner activity first
+        if (this->ownerView)
+        {
+            this->view = (T*)this->ownerView->getView(this->id);
+
+            if (!this->view)
+                throw ViewNotFoundException(this->ownerView, this->id);
+        }
+        // Then resolve by owner view
+        else if (this->ownerActivity)
+        {
+            this->view = (T*)this->ownerActivity->getView(this->id);
+
+            if (!this->view)
+                throw ViewNotFoundException(this->ownerActivity, this->id);
+        }
+        else
+        {
+            throw std::logic_error("No owner view or activity given to BoundView");
+        }
+    }
+};
+
+} // namespace brls

Source/Benchmark-Toolbox/lib/borealis/library/include/borealis/core/box.hpp

@@ -0,0 +1,280 @@
+/*
+    Copyright 2020-2021 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#include <borealis/core/view.hpp>
+
+namespace brls
+{
+
+enum class JustifyContent
+{
+    FLEX_START,
+    CENTER,
+    FLEX_END,
+    SPACE_BETWEEN,
+    SPACE_AROUND,
+    SPACE_EVENLY,
+};
+
+enum class AlignItems
+{
+    AUTO,
+    FLEX_START,
+    CENTER,
+    FLEX_END,
+    STRETCH,
+    BASELINE,
+    SPACE_BETWEEN,
+    SPACE_AROUND,
+};
+
+enum class Axis
+{
+    ROW,
+    COLUMN,
+};
+
+enum class Direction
+{
+    INHERIT,
+    LEFT_TO_RIGHT,
+    RIGHT_TO_LEFT,
+};
+
+// Generic FlexBox layout
+class Box : public View
+{
+  public:
+    Box(Axis flexDirection);
+    Box();
+
+    void draw(NVGcontext* vg, float x, float y, float width, float height, Style style, FrameContext* ctx) override;
+    View* getDefaultFocus() override;
+    View* getNextFocus(FocusDirection direction, View* currentView) override;
+    void willAppear(bool resetState) override;
+    void willDisappear(bool resetState) override;
+    void onWindowSizeChanged() override;
+    void onFocusGained() override;
+    void onFocusLost() override;
+    void onParentFocusGained(View* focusedView) override;
+    void onParentFocusLost(View* focusedView) override;
+    bool applyXMLAttribute(std::string name, std::string value) override;
+
+    static View* create();
+
+    /**
+     * Adds a view to this Box.
+     * Returns the position the view was added at.
+     */
+    virtual void addView(View* view);
+
+    /**
+     * Adds a view to this Box at the given position.
+     * Returns the position the view was added at.
+     */
+    virtual void addView(View* view, size_t position);
+
+    /**
+     * Removes the given view from the Box. It will be freed.
+     */
+    virtual void removeView(View* view);
+
+    /**
+     * Sets the padding of the view, aka the internal space to give
+     * between this view boundaries and its children.
+     *
+     * Only does one layout pass instead of four when using the four methods separately.
+     */
+    virtual void setPadding(float padding);
+
+    /**
+     * Sets the padding of the view, aka the internal space to give
+     * between this view boundaries and its children.
+     *
+     * Only does one layout pass instead of four when using the four methods separately.
+     */
+    virtual void setPadding(float top, float right, float bottom, float left);
+
+    /**
+     * Sets the padding of the view, aka the internal space to give
+     * between this view boundaries and its children.
+     */
+    virtual void setPaddingTop(float top);
+
+    /**
+     * Sets the padding of the view, aka the internal space to give
+     * between this view boundaries and its children.
+     */
+    virtual void setPaddingRight(float right);
+
+    /**
+     * Sets the padding of the view, aka the internal space to give
+     * between this view boundaries and its children.
+     */
+    virtual void setPaddingBottom(float bottom);
+
+    /**
+     * Sets the padding of the view, aka the internal space to give
+     * between this view boundaries and its children.
+     */
+    virtual void setPaddingLeft(float left);
+
+    /**
+     * Sets the children alignment along the Box axis.
+     *
+     * Default is FLEX_START.
+     */
+    void setJustifyContent(JustifyContent justify);
+
+    /**
+     * Sets the children alignment along the Box cross axis.
+     *
+     * Default is AUTO.
+     */
+    void setAlignItems(AlignItems alignment);
+
+    /**
+     * Sets the direction of the box, aka place the views
+     * left to right or right to left (flips the children).
+     *
+     * Default is INHERIT.
+     */
+    void setDirection(Direction direction);
+
+    void setAxis(Axis axis);
+
+    std::vector<View*>& getChildren();
+
+    /**
+     * Returns the bounds used for culling children.
+     */
+    virtual void getCullingBounds(float* top, float* right, float* bottom, float* left);
+
+    /**
+     * Registers an XML attribute to be forwarded to the given view. Works regardless of the target attribute type.
+     * Useful to expose attributes of children views in the parent box without copy pasting them individually.
+     *
+     * The forwarded attribute value will override the value of the regular attribute if it already exists in the target view.
+     */
+    void forwardXMLAttribute(std::string attributeName, View* target);
+
+    /**
+     * Registers an XML attribute to be forwarded to the given view, while changing the target attribute name.
+     * Works regardless of the target attribute type.
+     * Useful to expose attributes of children views in the parent box without copy pasting them individually, but with a different name.
+     *
+     * The forwarded attribute value will override the value of the regular attribute if it already exists in the target view.
+     */
+    void forwardXMLAttribute(std::string attributeName, View* target, std::string targetAttributeName);
+
+    /**
+     * Fired when focus is gained on one of this view's children, or one of the children
+     * of the children...
+     *
+     * directChild is guaranteed to be one of your children. It may not be the view that has been
+     * focused.
+     *
+     * If focusedView == directChild, then the child of yours has been focused.
+     * Otherwise, focusedView is a child of directChild.
+     */
+    virtual void onChildFocusGained(View* directChild, View* focusedView);
+
+    /**
+     * Fired when focus is lost on one of this view's children. Works similarly to
+     * onChildFocusGained().
+     */
+    virtual void onChildFocusLost(View* directChild, View* focusedView);
+
+    View* getView(std::string id) override;
+
+  private:
+    Axis axis;
+
+    std::vector<View*> children;
+
+    size_t defaultFocusedIndex = 0;
+
+    std::unordered_map<std::string, std::pair<std::string, View*>> forwardedAttributes;
+
+  protected:
+    /**
+     * Inflates the Box with the given XML string.
+     *
+     * The root element MUST be a brls::Box, corresponding to the inflated Box itself. Its
+     * attributes will be applied to the Box.
+     *
+     * Each child node in the root brls::Box will be treated as a view and added
+     * as a child of the Box.
+     */
+    void inflateFromXMLString(std::string xml);
+
+    /**
+     * Inflates the Box with the given XML element.
+     *
+     * The root element MUST be a brls::Box, corresponding to the inflated Box itself. Its
+     * attributes will be applied to the Box.
+     *
+     * Each child node in the root brls::Box will be treated as a view and added
+     * as a child of the Box.
+     */
+    void inflateFromXMLElement(tinyxml2::XMLElement* element);
+
+    /**
+     * Inflates the Box with the given XML resource.
+     *
+     * The root element MUST be a brls::Box, corresponding to the inflated Box itself. Its
+     * attributes will be applied to the Box.
+     *
+     * Each child node in the root brls::Box will be treated as a view and added
+     * as a child of the Box.
+     */
+    void inflateFromXMLRes(std::string res);
+
+    /**
+     * Inflates the Box with the given XML file path.
+     *
+     * The root element MUST be a brls::Box, corresponding to the inflated Box itself. Its
+     * attributes will be applied to the Box.
+     *
+     * Each child node in the root brls::Box will be treated as a view and added
+     * as a child of the Box.
+     */
+    void inflateFromXMLFile(std::string path);
+
+    /**
+     * Handles a child XML element.
+     *
+     * By default, calls createFromXMLElement() and adds the result
+     * to the children of the Box.
+     */
+    void handleXMLElement(tinyxml2::XMLElement* element) override;
+};
+
+// An empty view that has auto x auto and grow=1.0 to push
+// all the next views in its box to the right (or to the bottom)
+class Padding : public View
+{
+  public:
+    Padding();
+
+    void draw(NVGcontext* vg, float x, float y, float width, float height, Style style, FrameContext* ctx) override;
+
+    static View* create();
+};
+
+} // namespace brls

Source/Benchmark-Toolbox/lib/borealis/library/include/borealis/core/event.hpp

@@ -0,0 +1,73 @@
+/*
+    Copyright 2020 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <functional>
+#include <list>
+
+namespace brls
+{
+
+// Simple observer pattern implementation
+//
+// Usage:
+// 1. typedef your event type
+// 2. create as many events as you want using that type
+// 3. call subscribe on the events with your observers
+// 4. call fire when you want to fire the events
+//    it wil return true if at least one subscriber exists
+//    for that event
+template <typename... Ts>
+class Event
+{
+  public:
+    typedef std::function<void(Ts...)> Callback;
+    typedef std::list<Callback> CallbacksList;
+    typedef typename CallbacksList::iterator Subscription;
+
+    Subscription subscribe(Callback cb);
+    void unsubscribe(Subscription subscription);
+    bool fire(Ts... args);
+
+  private:
+    CallbacksList callbacks;
+};
+
+template <typename... Ts>
+typename Event<Ts...>::Subscription Event<Ts...>::subscribe(Event<Ts...>::Callback cb)
+{
+    this->callbacks.push_back(cb);
+    return --this->callbacks.end();
+}
+
+template <typename... Ts>
+void Event<Ts...>::unsubscribe(Event<Ts...>::Subscription subscription)
+{
+    this->callbacks.erase(subscription);
+}
+
+template <typename... Ts>
+bool Event<Ts...>::fire(Ts... args)
+{
+    for (Callback cb : this->callbacks)
+        cb(args...);
+
+    return !this->callbacks.empty();
+}
+
+}; // namespace brls

Source/Benchmark-Toolbox/lib/borealis/library/include/borealis/core/font.hpp

@@ -0,0 +1,62 @@
+/*
+    Copyright 2021 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#include <string>
+#include <unordered_map>
+
+namespace brls
+{
+
+static constexpr const int FONT_INVALID = -1;
+
+static const std::string FONT_REGULAR        = "regular"; // regular Latin font
+static const std::string FONT_KOREAN_REGULAR = "korean"; // regular Korean font
+static const std::string FONT_MATERIAL_ICONS = "material"; // Material icons font
+static const std::string FONT_SWITCH_ICONS   = "switch"; // Switch icons font (see the HOS shared symbols font for an example)
+
+typedef std::unordered_map<std::string, int> FontStash;
+
+// Platform interface to load fonts from disk or other sources (system / shared font...)
+class FontLoader
+{
+  public:
+    virtual ~FontLoader() {}
+    /**
+     * Called once on init to load every font in the font stash.
+     *
+     * The implementation must use the Application::loadFont and
+     * Application::loadFontFromMemory methods to load as much as possible
+     * of the "built-in" fonts defined in the FONT_* constants above.
+     */
+    virtual void loadFonts() = 0;
+
+  protected:
+    /**
+     * Convenience method to load a font from a file path
+     * with some more logging.
+     */
+    bool loadFontFromFile(std::string fontName, std::string filePath);
+
+    /**
+     * Can be called internally to load the Material icons font from resources.
+     * Returns true if the operation succeeds.
+     */
+    bool loadMaterialFromResources();
+};
+
+} // namespace brls

Source/Benchmark-Toolbox/lib/borealis/library/include/borealis/core/frame_context.hpp

@@ -0,0 +1,38 @@
+/*
+    Copyright 2019 natinusala
+    Copyright 2019 psam
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#include <nanovg.h>
+
+#include <borealis/core/font.hpp>
+#include <borealis/core/style.hpp>
+#include <borealis/core/theme.hpp>
+
+namespace brls
+{
+
+class FrameContext
+{
+  public:
+    NVGcontext* vg       = nullptr;
+    float pixelRatio     = 0.0;
+    FontStash* fontStash = nullptr;
+    Theme theme          = nullptr;
+};
+
+} // namespace brls

Source/Benchmark-Toolbox/lib/borealis/library/include/borealis/core/i18n.hpp

@@ -0,0 +1,88 @@
+/*
+    Copyright 2020-2021 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#include <fmt/core.h>
+
+#include <borealis/core/logger.hpp>
+#include <string>
+
+namespace brls
+{
+
+const std::string LOCALE_JA      = "ja";
+const std::string LOCALE_EN_US   = "en-US";
+const std::string LOCALE_EN_GB   = "en-GB";
+const std::string LOCALE_FR      = "fr";
+const std::string LOCALE_FR_CA   = "fr-CA";
+const std::string LOCALE_DE      = "de";
+const std::string LOCALE_IT      = "it";
+const std::string LOCALE_ES      = "es";
+const std::string LOCALE_ZH_CN   = "zh-CN";
+const std::string LOCALE_ZH_HANS = "zh-Hans";
+const std::string LOCALE_ZH_HANT = "zh-Hant";
+const std::string LOCALE_ZH_TW   = "zh-TW";
+const std::string LOCALE_Ko      = "ko";
+const std::string LOCALE_NL      = "nl";
+const std::string LOCALE_PT      = "pt";
+const std::string LOCALE_PT_BR   = "pt-BR";
+const std::string LOCALE_RU      = "ru";
+const std::string LOCALE_ES_419  = "es-419";
+
+const std::string LOCALE_DEFAULT = LOCALE_EN_US;
+
+namespace internal
+{
+    std::string getRawStr(std::string stringName);
+} // namespace internal
+
+/**
+ * Returns the translation for the given string,
+ * after injecting format parameters (if any)
+ */
+template <typename... Args>
+std::string getStr(std::string stringName, Args&&... args)
+{
+    std::string rawStr = internal::getRawStr(stringName);
+
+    try
+    {
+        return fmt::format(rawStr, args...);
+    }
+    catch (const std::exception& e)
+    {
+        Logger::error("Invalid format \"{}\" from string \"{}\": {}", rawStr, stringName, e.what());
+        return stringName;
+    }
+}
+
+/**
+ * Loads all translations of the current system locale + default locale
+ * Must be called before trying to get a translation!
+ */
+void loadTranslations();
+
+inline namespace literals
+{
+    /**
+     * Returns the translation for the given string, without
+     * injecting any parameters
+     * Shortcut to brls::getStr(stringName)
+     */
+    std::string operator"" _i18n(const char* str, size_t len);
+} // namespace literals
+} // namespace brls

Source/Benchmark-Toolbox/lib/borealis/library/include/borealis/core/input.hpp

@@ -0,0 +1,88 @@
+/*
+    Copyright 2021 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+namespace brls
+{
+
+// Abstract buttons enum - names correspond to a generic Xbox controller
+// LT and RT should not be buttons but for the sake of simplicity we'll assume they are.
+// Similarly, DPAD (also called HAT) is assumed to be buttons here.
+enum ControllerButton
+{
+    BUTTON_LT = 0,
+    BUTTON_LB,
+
+    BUTTON_LSB,
+
+    BUTTON_UP,
+    BUTTON_RIGHT,
+    BUTTON_DOWN,
+    BUTTON_LEFT,
+
+    BUTTON_BACK,
+    BUTTON_GUIDE,
+    BUTTON_START,
+
+    BUTTON_RSB,
+
+    BUTTON_Y,
+    BUTTON_B,
+    BUTTON_A,
+    BUTTON_X,
+
+    BUTTON_RB,
+    BUTTON_RT,
+
+    _BUTTON_MAX,
+};
+
+// Abstract axis enum - names correspond to a generic Xbox controller
+enum ControllerAxis
+{
+    LEFT_X,
+    LEFT_Y,
+
+    // No Z axis, LT and RT are in the buttons enum for the sake of simplicity
+
+    RIGHT_X, // also called 5th axis
+    RIGHT_Y, // also called 4th axis
+
+    _AXES_MAX,
+};
+
+// Represents the state of the controller (a gamepad or a keyboard) in the current frame
+typedef struct ControllerState
+{
+    bool buttons[_BUTTON_MAX]; // true: pressed
+    float axes[_AXES_MAX]; // from 0.0f to 1.0f
+} ControllerState;
+
+// Interface responsible for reporting input state to the application - button presses,
+// axis position and touch screen state
+class InputManager
+{
+  public:
+    virtual ~InputManager() {}
+
+    /**
+     * Called once every frame to fill the given ControllerState struct with the controller state.
+     */
+    virtual void updateControllerState(ControllerState* state) = 0;
+};
+
+}; // namespace brls

Source/Benchmark-Toolbox/lib/borealis/library/include/borealis/core/logger.hpp

@@ -0,0 +1,91 @@
+/*
+    Copyright 2019 natinusala
+    Copyright 2019 p-sam
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#include <fmt/core.h>
+
+#include <string>
+
+namespace brls
+{
+
+enum class LogLevel
+{
+    ERROR = 0,
+    WARNING,
+    INFO,
+    DEBUG
+};
+
+class Logger
+{
+  public:
+    static void setLogLevel(LogLevel logLevel);
+
+    template <typename... Args>
+    inline static void log(LogLevel logLevel, std::string prefix, std::string color, std::string format, Args&&... args)
+    {
+        if (Logger::logLevel < logLevel)
+            return;
+
+        try
+        {
+            fmt::print("\033{}[{}]\033[0m ", color, prefix);
+            fmt::print(format, args...);
+            fmt::print("\n");
+        }
+        catch (const std::exception& e)
+        {
+            // will be printed after the first fmt::print (so after the log tag)
+            printf("! Invalid log format string: \"%s\": %s\n", format.c_str(), e.what());
+        }
+
+#ifdef __MINGW32__
+        fflush(0);
+#endif
+    }
+
+    template <typename... Args>
+    inline static void error(std::string format, Args&&... args)
+    {
+        Logger::log(LogLevel::ERROR, "ERROR", "[0;31m", format, args...);
+    }
+
+    template <typename... Args>
+    inline static void warning(std::string format, Args&&... args)
+    {
+        Logger::log(LogLevel::WARNING, "WARNING", "[0;33m", format, args...);
+    }
+
+    template <typename... Args>
+    inline static void info(std::string format, Args&&... args)
+    {
+        Logger::log(LogLevel::INFO, "INFO", "[0;34m", format, args...);
+    }
+
+    template <typename... Args>
+    inline static void debug(std::string format, Args&&... args)
+    {
+        Logger::log(LogLevel::DEBUG, "DEBUG", "[0;32m", format, args...);
+    }
+
+  private:
+    inline static LogLevel logLevel = LogLevel::INFO;
+};
+
+} // namespace brls

Source/Benchmark-Toolbox/lib/borealis/library/include/borealis/core/platform.hpp

@@ -0,0 +1,106 @@
+/*
+    Copyright 2021 natinusala
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#include <borealis/core/audio.hpp>
+#include <borealis/core/font.hpp>
+#include <borealis/core/input.hpp>
+#include <borealis/core/theme.hpp>
+#include <borealis/core/video.hpp>
+#include <string>
+
+namespace brls
+{
+
+// Interface to provide everything platform specific required to run borealis: graphics context, inputs, audio...
+// The best platform is automatically selected when the application starts, and cannot be changed by the user at the moment
+class Platform
+{
+  public:
+    virtual ~Platform() {};
+
+    /**
+     * Called on startup, right after instanciation, to create and open a window
+     * with the given title and size.
+     */
+    virtual void createWindow(std::string title, uint32_t width, uint32_t height) = 0;
+
+    /**
+     * Returns the human-readable name of the platform.
+     */
+    virtual std::string getName() = 0;
+
+    /**
+     * Called at every iteration of the main loop.
+     * Must return false if the app should continue running
+     * (for example, return false if the X button was pressed on the window).
+     */
+    virtual bool mainLoopIteration() = 0;
+
+    /**
+     * Can be called at anytime to get the current system theme variant.
+     *
+     * For now, the variant is assumed to stay the same during the whole time
+     * the app is running (no variant hot swap).
+     *
+     * As such, the result should be cached by the platform code.
+     */
+    virtual ThemeVariant getThemeVariant() = 0;
+
+    /**
+     * Can be called at anytime to get the current locale
+     *
+     * For now, the locale is assumed to stay the same during the whole time
+     * the app is running (no locale hot swap)
+     *
+     * As such, the result should be cached by the platform code.
+     * The method should return one of the locale constants
+     * defined in the i18n header file.
+     */
+    virtual std::string getLocale() = 0;
+
+    /**
+     * Returns the AudioPlayer for the platform.
+     * Cannot return nullptr.
+     */
+    virtual AudioPlayer* getAudioPlayer() = 0;
+
+    /**
+     * Returns the VideoContext for the platform.
+     * Cannot return nullptr.
+     */
+    virtual VideoContext* getVideoContext() = 0;
+
+    /**
+     * Returns the InputManager for the platform.
+     * Cannot return nullptr.
+     */
+    virtual InputManager* getInputManager() = 0;
+
+    /**
+     * Returns the FontLoader for the platform.
+     * Cannot return nullptr.
+     */
+    virtual FontLoader* getFontLoader() = 0;
+
+    /**
+     * Selects and returns the best platform.
+     */
+    static Platform* createPlatform();
+};
+
+} // namespace brls

Source/Benchmark-Toolbox/lib/borealis/library/include/borealis/core/style.hpp

@@ -0,0 +1,56 @@
+/*
+    Copyright 2019-2020 natinusala
+    Copyright 2019 WerWolv
+    Copyright 2019 p-sam
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#pragma once
+
+#include <initializer_list>
+#include <string>
+#include <unordered_map>
+
+namespace brls
+{
+
+class StyleValues
+{
+  public:
+    StyleValues(std::initializer_list<std::pair<std::string, float>> list);
+
+    void addMetric(std::string name, float value);
+    float getMetric(std::string name);
+
+  private:
+    std::unordered_map<std::string, float> values;
+};
+
+// Simple wrapper around StyleValues for the array operator
+class Style
+{
+  public:
+    Style(StyleValues* values);
+    float operator[](std::string name);
+
+    void addMetric(std::string name, float value);
+    float getMetric(std::string name);
+
+  private:
+    StyleValues* values;
+};
+
+Style getStyle();
+
+} // namespace brls