hocclk: translate user notifications to German

This reverts commit d6c2ddf2ea.

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

@@ -20,8 +20,8 @@
 
 #pragma once
 
-#define CUST_REV 2
-#define KIP_VERSION 220
+#define CUST_REV 3
+#define KIP_VERSION 231
 
 #include "oc_common.hpp"
 #include "pcv/pcv_common.hpp"
@@ -92,7 +92,7 @@ struct CustomizeTable {
     StepMode stepMode;
     u32 marikoEmcMaxClock;
     u32 marikoEmcVddqVolt;
-    u32 emcDvbShift;
+    s32 emcDvbShift;
     u32 marikoSocVmax;
     // advanced config
     u32 t1_tRCD;

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

@@ -153,7 +153,7 @@ namespace ams::ldr::hoc::pcv {
             { C.commonEmcMemVolt,                    912'500, 1350'000, false, panic::Emc }, // Official burst vmax for the RAMs is 1500mV
             { GET_MAX_OF_ARR(erista::maxEmcClocks), 1600'000, 2600'000, false, panic::Emc },
             { C.marikoEmcMaxClock,                  1600'000, 3500'000, false, panic::Emc },
-            { C.marikoEmcVddqVolt,                   250'000,  700'000, false, panic::Emc },
+            { C.marikoEmcVddqVolt,                   400'000,  750'000, false, panic::Emc },
             { C.marikoSocVmax,                          1000,     1200, false, panic::Emc },
             { eristaGpuDvfsMaxFreq,                  768'000, 1152'000, false, panic::Gpu },
             { marikoGpuDvfsMaxFreq,                  768'000, 1536'000, false, panic::Gpu },

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

@@ -38,14 +38,14 @@ namespace ams::ldr::hoc::pcv {
     };
     static_assert(sizeof(cvb_entry_t) == 0x38);
 
-    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;
+        u32 tune_high_min_millivolts;
+        u32 tune_high_margin_millivolts;
+        u64 dvco_calibration_max;
     };
 
     struct __attribute__((packed)) div_nmp {
@@ -115,6 +115,25 @@ namespace ams::ldr::hoc::pcv {
     };
     static_assert(sizeof(regulator) == 0x120);
 
+    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;

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

@@ -66,11 +66,12 @@ namespace ams::ldr::hoc::pcv::erista {
     }
 
     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());
+        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();
@@ -100,6 +101,7 @@ namespace ams::ldr::hoc::pcv::erista {
             default:
                 break;
         }
+
         R_SUCCEED();
     }
 
@@ -121,10 +123,10 @@ namespace ams::ldr::hoc::pcv::erista {
         }
 
         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,      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);
         }
 
@@ -165,8 +167,10 @@ namespace ams::ldr::hoc::pcv::erista {
         }
         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]);
+            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();
@@ -210,7 +214,9 @@ 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));
+
+        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);
 
@@ -239,7 +245,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);
@@ -280,7 +285,7 @@ namespace ams::ldr::hoc::pcv::erista {
 
         /* 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;
@@ -325,8 +330,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;
@@ -354,10 +359,10 @@ 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_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->emc_cfg_2          = 0x11083D;
+        table->min_volt           = std::clamp(900 + (C.emcDvbShift * 25), 900, 1050);
     }
 
     /* Probably more intuitive to point to 40800 rather than 1600000, but oh well. */

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

@@ -140,7 +140,7 @@ namespace ams::ldr::hoc::pcv::erista {
         MtcTableIndex index;
     };
 
-    constexpr MtcDramIndex mtcIndexTable[] = {
+    const inline MtcDramIndex mtcIndexTable[] = {
         { ICOSA_4GB_SAMSUNG_K4F6E304HB_MGCH,        T210SdevEmcDvfsTableS4gb01, },
         { ICOSA_4GB_MICRON_MT53B512M32D2NP_062_WTC, T210SdevEmcDvfsTableS4gb01, },
         { ICOSA_6GB_SAMSUNG_K4FHE3D4HM_MGCH,        T210SdevEmcDvfsTableS6gb01, },

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

@@ -94,23 +94,29 @@ namespace ams::ldr::hoc::pcv::mariko {
     }
 
     Result CpuVoltDVFS(u32 *ptr) {
-        if (MatchesPattern(ptr, cpuVoltagePatchOffsets, cpuVoltagePatchValues)) {
-            if (C.marikoCpuLowVmin) {
-                PATCH_OFFSET(ptr, C.marikoCpuLowVmin);
-            }
+        CvbMeta *cpuCvbMeta = reinterpret_cast<CvbMeta *>(reinterpret_cast<u8 *>(ptr) - offsetof(CvbMeta, vmin));
 
-            if (C.marikoCpuHighVmin) {
-                PATCH_OFFSET(ptr - 2, C.marikoCpuHighVmin);
-            }
+        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.marikoCpuMaxVolt) {
-                PATCH_OFFSET(ptr + 5, C.marikoCpuMaxVolt);
-            }
-
-            R_SUCCEED();
+        if (C.marikoCpuLowVmin) {
+            PATCH_OFFSET(&(cpuCvbMeta->vmin), C.marikoCpuLowVmin);
         }
 
-        R_THROW(ldr::ResultInvalidCpuMinVolt());
+        if (C.marikoCpuHighVmin) {
+            PATCH_OFFSET(&(cpuCvbMeta->highVmin), C.marikoCpuHighVmin);
+        }
+
+        if (C.marikoCpuMaxVolt) {
+            PATCH_OFFSET(&(cpuCvbMeta->vmax), C.marikoCpuMaxVolt);
+        }
+
+        R_SUCCEED();
     }
 
     Result CpuVoltThermals(u32 *ptr) {
@@ -134,80 +140,80 @@ namespace ams::ldr::hoc::pcv::mariko {
     }
 
     Result CpuVoltDfll(u32 *ptr) {
-        cvb_cpu_dfll_data *entry = reinterpret_cast<cvb_cpu_dfll_data *>(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->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_low),  0xffa0);
                 PATCH_OFFSET(&(entry->tune0_high), 0xffff);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21107ff);
-                PATCH_OFFSET(&(entry->tune1_high), 0);
+                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_low),  0x21107ff);
                 PATCH_OFFSET(&(entry->tune1_high), 0x27207ff);
                 break;
             case 3:
-                PATCH_OFFSET(&(entry->tune0_low), 0xffdf);
+                PATCH_OFFSET(&(entry->tune0_low),  0xffdf);
                 PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21107ff);
+                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_low),  0xffff);
                 PATCH_OFFSET(&(entry->tune0_high), 0xffdf);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21107ff);
+                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_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_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_low),  0x21607ff);
                 PATCH_OFFSET(&(entry->tune1_high), 0x27b07ff);
                 break;
             case 8:
-                PATCH_OFFSET(&(entry->tune0_low), 0xdfff);
+                PATCH_OFFSET(&(entry->tune0_low),  0xdfff);
                 PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21707ff);
+                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_low),  0xdfff);
                 PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21707ff);
+                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_low),  0xdfff);
                 PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21707ff);
+                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_low),  0xdfff);
                 PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21707ff);
+                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_low),  0xdfff);
                 PATCH_OFFSET(&(entry->tune0_high), 0xdfff);
-                PATCH_OFFSET(&(entry->tune1_low), 0x21707ff);
+                PATCH_OFFSET(&(entry->tune1_low),  0x21707ff);
                 PATCH_OFFSET(&(entry->tune1_high), 0x27f07ff);
                 break;
             default:
@@ -216,7 +222,7 @@ namespace ams::ldr::hoc::pcv::mariko {
 
         switch (C.marikoCpuUVHigh) {
             case 1:
-                PATCH_OFFSET(&(entry->tune1_high), 0);
+                PATCH_OFFSET(&(entry->tune1_high), 0x0);
                 PATCH_OFFSET(&(entry->tune0_high), 0xffff);
                 break;
             case 2:
@@ -301,7 +307,7 @@ namespace ams::ldr::hoc::pcv::mariko {
             asm_set_rd(asm_set_imm16(GpuAsmPattern[1], max_clock >> 16), rd)
         };
 
-        PATCH_OFFSET(ptr32, asm_patch[0]);
+        PATCH_OFFSET(ptr32,     asm_patch[0]);
         PATCH_OFFSET(ptr32 + 1, asm_patch[1]);
 
         R_SUCCEED();
@@ -366,7 +372,7 @@ namespace ams::ldr::hoc::pcv::mariko {
         }
 
         u32 trefbw = refresh_raw + 0x40;
-        trefbw = MIN(trefbw, static_cast<u32>(0x3FFF));
+        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);
 
@@ -796,9 +802,9 @@ namespace ams::ldr::hoc::pcv::mariko {
             R_SKIP();
         }
 
-        u32 max0    = 1050;
-        u32 max1    = 1025;
-        u32 max2    = 1000;
+        s32 max0    = 1050;
+        s32 max1    = 1025;
+        s32 max2    = 1000;
         s32 voltAdd = 25 * C.emcDvbShift;
 
         if (C.marikoSocVmax && C.marikoSocVmax > 1000) {
@@ -807,11 +813,17 @@ namespace ams::ldr::hoc::pcv::mariko {
             max2 = C.marikoSocVmax;
         }
 
-        auto DvbVolt = [&](u32 zero, u32 one, u32 two) {
-            return std::array<u32, 3>{
-                std::min(zero + voltAdd, max0),
-                std::min(one  + voltAdd, max1),
-                std::min(two  + voltAdd, max2)
+        constexpr s32 MinVolt = 637;
+
+        auto ClampVolt = [&](s32 value, s32 max) {
+            return std::clamp(value + voltAdd, MinVolt, max);
+        };
+
+        auto DvbVolt = [&](s32 zero, s32 one, s32 two) {
+            return std::array<s32, 3>{
+                ClampVolt(zero, max0),
+                ClampVolt(one, max1),
+                ClampVolt(two, max2)
             };
         };
 
@@ -819,32 +831,33 @@ namespace ams::ldr::hoc::pcv::mariko {
             static_cast<u32>((v)[0]), \
             static_cast<u32>((v)[1]), \
             static_cast<u32>((v)[2])
-        DvbEntry emcDvbTableNew[] = {
-            {     204000, {             637, 637, 637,  } },
-            {    1331200, {             650, 637, 637,  } },
-            {    1600000, {             675, 650, 637,  } },
-            {    1866000, { DVB(DvbVolt(700, 675, 650)) } },
-            {    2133000, { DVB(DvbVolt(725, 700, 675)) } },
-            {    2400000, { DVB(DvbVolt(750, 725, 700)) } },
-            {    2666000, { DVB(DvbVolt(775, 750, 725)) } },
-            {    2933000, { DVB(DvbVolt(800, 775, 750)) } },
-            {    3200000, { DVB(DvbVolt(800, 800, 775)) } },
-            { 0xFFFFFFFF, {                             } },
+        DvbEntry emcDvbOcTableBrackets[] = {
+            {     204000, {              637,  637,  637,  }, },
+            {    1331200, {              650,  637,  637,  }, },
+            {    1600000, {              675,  650,  637,  }, },
+            {    1866000, { DVB(DvbVolt( 700,  675,  650)) }, },
+            {    2133000, { DVB(DvbVolt( 725,  700,  675)) }, },
+            {    2400000, { DVB(DvbVolt( 750,  725,  700)) }, },
+            {    2666000, { DVB(DvbVolt( 850,  825,  800)) }, },
+            {    2933000, { DVB(DvbVolt( 950,  925,  900)) }, },
+            {    3200000, { DVB(DvbVolt(1050, 1025, 1000)) }, },
+            {        ~0u, {                                }, },
         };
         #undef DVB
+        DvbEntry emcDvbTableOc[newEmcList.size()];
 
-        u32 j = MtcTableCountDefault;
-        for (u32 i = MtcTableCountDefault; i < newEmcList.size(); ++i) {
-            if (newEmcList[i] >= emcDvbTableNew[j].freq && newEmcList[i] < emcDvbTableNew[j + 1].freq) {
-                emcDvbTableNew[j].freq = newEmcList[i];
-                ++j;
-            } else {
-                break;
+        u32 bracketIndex = 0;
+        for (u32 i = 0; i < newEmcList.size(); ++i) {
+            while (newEmcList[i] >= emcDvbOcTableBrackets[bracketIndex + 1].freq) {
+                ++bracketIndex;
             }
+
+            emcDvbTableOc[i].freq = newEmcList[i];
+            std::memcpy(emcDvbTableOc[i].volt, emcDvbOcTableBrackets[bracketIndex].volt, sizeof(emcDvbTableOc[i].volt));
         }
 
         std::memset(mem_dvb_table_head, 0, sizeof(EmcDvbTableDefault));
-        std::memcpy(mem_dvb_table_head, &emcDvbTableNew, sizeof(emcDvbTableNew));
+        std::memcpy(mem_dvb_table_head, &emcDvbTableOc, sizeof(emcDvbTableOc));
 
         /* 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

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

@@ -48,11 +48,11 @@ namespace ams::ldr::hoc::pcv::mariko {
         {                                               },
     };
 
-    constexpr u32 CpuClkOfficial  = 1963'500;
-    constexpr u32 CpuVoltOfficial = 1120;
-    constexpr u32 CpuVminOfficial = 620;
-
-    constexpr u32 CpuTune0Low = 0xFFCF;
+    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 };
@@ -230,7 +230,7 @@ namespace ams::ldr::hoc::pcv::mariko {
         MtcTableIndex index;
     };
 
-    constexpr MtcDramIndex mtcIndexTable[] = {
+    const inline MtcDramIndex mtcIndexTable[] = {
         { HOAG_4GB_HYNIX_H9HCNNNBKMMLXR_NEE,       T210b0SdevEmcDvfsTableH1y4gb01,  },
         { AULA_4GB_HYNIX_H9HCNNNBKMMLXR_NEE,       T210b0SdevEmcDvfsTableH1y4gb01,  },
         { IOWA_4GB_HYNIX_H9HCNNNBKMMLXR_NEE,       T210b0SdevEmcDvfsTableH1y4gb01,  },

Source/hoc-clk/overlay/Makefile

@@ -39,7 +39,7 @@ include ${TOPDIR}/lib/libultrahand/ultrahand.mk
 # version control constants
 #---------------------------------------------------------------------------------
 #TARGET_VERSION	:= $(shell git describe --dirty --always --tags)
-APP_VERSION		:= 2.2.0 # ensure to set KIP_VERSION and CUST_REV in sysmodule Makefile when updating this
+APP_VERSION		:= 2.3.1 # ensure to set KIP_VERSION and CUST_REV in sysmodule Makefile when updating this
 TARGET_VERSION := $(APP_VERSION)
 
 #---------------------------------------------------------------------------------

Source/hoc-clk/overlay/src/ui/gui/config_info_strings.cpp

@@ -0,0 +1,570 @@
+/*
+ *
+ * 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 "config_info_strings.h"
+
+std::vector<std::string> ConfigInfoStrings(HocClkConfigValue val, bool isMariko, bool isHoag)
+{
+    switch (val)
+    {
+        case HocClkConfigValue_PollingIntervalMs:
+            return {
+                "The interval (in miliseconds) where clocks are applied, tempratures and voltages are polled and logs are written (if enabled).",
+                "Higher values may cause more delay between changing a setting and it taking effect, and lower values may increase sysmodule memory usage",
+                "Default: 300ms"
+            };
+
+        case HocClkConfigValue_RamDisplayUnit:
+            return {
+                "The unit used when displaying RAM frequency values.",
+                "Options:",
+                "- MHz: Megahertz (e.g. 1600 MHz)",
+                "- MT/s: MegaTransfers per second (e.g. 3200 MT/s)",
+                "Default: MHz"
+            };
+
+        case HocClkConfigValue_RAMVoltDisplayMode:
+            return {
+                "The method used to display RAM voltage values.",
+                "Options:",
+                "- VDD2 - Display VDD2 voltage",
+                "- VDDQ - Display VDDQ voltage",
+                "Default: VDD2"
+            };
+
+        case HocClkConfigValue_EnableExperimentalSettings:
+            return {
+                "When enabled, shows settings that are still being tested and may be unstable or not work at all.",
+                "Use with caution and report any issues to the developers."
+            };
+
+        case HocClkConfigValue_MarikoMiddleFreqs:
+            return {
+                "Allows usage of frequencies stepped by 38.4MHz instead of 76.8MHz below 1228MHz GPU clock",
+                "Default: OFF"
+            };
+
+        case HocClkConfigValue_LiveCpuUv:
+            return {
+                "Allows changing CPU undervolt settings without a reboot",
+                "Default: OFF"
+            };
+
+        case HocClkConfigValue_GPUSchedulingMethod:
+            return {
+                "Method used for GPU scheduling override",
+                "Options:",
+                "- INI: override via system_settings.ini",
+                "- NV Service: override via nvservices sysmodule (experimental)",
+                "Default: INI"
+            };
+
+        case HocClkConfigValue_MemoryFrequencyMeasurementMode:
+            return {
+                "How the RAM real frequency is measured",
+                "Options:",
+                "- PLL: Measure from PLLMB and PLLM (more accurate)",
+                "- Actmon: Measure from Actmon (less accurate)",
+                "Default: PLL"
+            };
+
+        case HocClkConfigValue_BatteryChargeCurrent:
+            return {
+                "Overrides the charge current to the battery. Use with caution!",
+                isHoag ? "Default: 1664 mA" : "2048 mA"
+            };
+
+        case HocClkConfigValue_AulaDisplayColorPreset:
+            return {
+                "Current display color preset. Default is Basic",
+                "Options:",
+                "- Saturated: Based on Vivid but over-saturated.",
+                "- Washed: Washed out colors.",
+                "- Basic: Real natural profile.",
+                "- Natural: Not actually natural.. Extra saturation.",
+                "- Vivid: Saturated.",      
+                "Default: Do not override"  
+            };
+
+        case HocClkConfigValue_CpuGovernorMinimumFreq:
+            return {
+                "The minimum frequency that the CPU governor will allow.",
+                "Default: 612MHz"
+            };
+
+        case HocClkConfigValue_OverwriteRefreshRate:
+            return {
+                "Conrols the avaiability of display refresh rate features.",
+                "When enabled, allows changing the display refresh rate and using display refresh rate related features."
+            };
+
+        case HocClkConfigValue_MaxDisplayClockH:
+            return {
+                "The maximum display clock frequency in handheld mode (in Hz).",
+                "Warning: Changing this value may cause instability or display damage.",
+                "Default: 60 Hz"
+            };
+
+        case HocClkConfigValue_DisplayVoltage:
+            return {
+                "The voltage supplied to the display panel (in mV).",
+                "Warning: Changing this value may cause instability.",
+                "Default: 1200mV"
+            };
+
+        case HocClkConfigValue_UncappedClocks:
+            if(isMariko) {
+                return {
+                    "When enabled, disables clock cappings",
+                    "Warning: Enabling this may cause damage to your device without a proper undervolt. Use with caution!",
+                    "Clock cappings:",
+                    "- Handheld:",
+                    "  - GPU (HiOPT): 614 MHz",
+                    "  - GPU (HiOPT - 15mV): 691 MHz",
+                    "  - GPU (High UV): 768 MHz",
+                    "- USB Charger",
+                    "  - GPU (HiOPT): 844 MHz",
+                    "  - GPU (HiOPT - 15mV): 921 MHz",
+                    "  - GPU (High UV): 998 MHz",
+                    "- PD Charger / Docked:",
+                    "  - No capping applied",
+                    "Default: OFF"
+                };
+            } else {
+                return {
+                    "When enabled, disables clock cappings",
+                    "Warning: Enabling this may cause damage to your device without a proper undervolt. Use with caution!",
+                    "Clock cappings:",
+                    "- Handheld:",
+                    "  - GPU: 460 MHz",
+                    "  - CPU: 1581 MHz",
+                    "- USB Charger",
+                    "  - GPU: 768 MHz",
+                    "- PD Charger / Docked:",
+                    "  - No capping applied",
+                    "Default: OFF"
+                };
+            }
+
+        case HocClkConfigValue_ThermalThrottle:
+            return {
+                "If enabled, Resets to stock clocks after the threshold is applied",
+                "Default: ON",
+            };
+
+        case HocClkConfigValue_HandheldTDP:
+            return {
+                "If enabled, Resets to stock clocks when power consumption is above the threshold in handheld mode",
+                "Default: ON",
+            };
+
+        case HocClkConfigValue_HandheldTDPLimit:
+        case HocClkConfigValue_LiteTDPLimit:
+            return {
+                "The power consumption threshold (in mW) for resetting to stock clocks in handheld mode when Handheld TDP is enabled.",
+                isHoag ? "Default: 6400mW" : "Default: 9600mW"
+            };
+
+        case HocClkConfigValue_ThermalThrottleThreshold:
+            return {
+                "The temperature threshold (in °C) for resetting to stock clocks when Thermal Throttle is enabled.",
+                "Default: 70°C"
+            };
+
+        case KipConfigValue_emcDvbShift:
+            return {
+                "Each level adds/removes 25mV from the SOC Voltage table",
+                "Consoles are bracketed by SoC Speedo. The brackets are as follows:",
+                " - Speedo 1487-1598: Bracket 0",
+                " - Speedo 1598-1709: Bracket 1",
+                " - Speedo 1709-1820: Bracket 2",
+                "SOC Volt Table:",
+                " - 1331/1600MHz tables are not modified",
+                " - 1633-1866MHz:",
+                "   - Bracket 0: 700mV",
+                "   - Bracket 1: 675mV",
+                "   - Bracket 2: 650mV",
+                " - 1900-2133MHz:",
+                "   - Bracket 0: 725mV",
+                "   - Bracket 1: 700mV",
+                "   - Bracket 2: 675mV",
+                " - 2166-2400MHz:",
+                "   - Bracket 0: 750mV",
+                "   - Bracket 1: 725mV",
+                "   - Bracket 2: 700mV",
+                " - 2433-2666MHz:",
+                "   - Bracket 0: 850mV",
+                "   - Bracket 1: 825mV",
+                "   - Bracket 2: 800mV",
+                " - 2700-2933MHz:",
+                "   - Bracket 0: 950mV",
+                "   - Bracket 1: 925mV",
+                "   - Bracket 2: 900mV",
+                " - 2966-3200MHz:",
+                "   - Bracket 0: 1050mV",
+                "   - Bracket 1: 1025mV",
+                "   - Bracket 2: 1000mV",
+                "Default: 0"
+            };
+
+        case KipConfigValue_marikoSocVmax:
+            return {
+                "The maximum available SOC Voltage that the DVB-adjusted table can use",
+                "Default: Do not override"
+            };
+
+        case KipConfigValue_hpMode:
+            return {
+                "When enabled, disables RAM powerdown. Helps with latency significantly",
+                "Default: OFF"
+            };
+
+        case KipConfigValue_commonEmcMemVolt:
+            return {
+                "RAM VDD2 voltage",
+                "Increasing this WILL NOT increase your maximum frequency, but may help with timing reduction.",
+                "Undervolting RAM is pointless and may hurt performance and stability",
+                "Default: 1175 mV"
+            };
+
+        case KipConfigValue_marikoEmcVddqVolt:
+            return {
+                "RAM VDDQ voltage",
+                "Increasing this may help, but the default value is usually good enough.",
+                "Undervolting RAM is pointless and may hurt performance and stability",
+                "Default: 600 mV"
+            };
+
+        case KipConfigValue_stepMode:         
+            return {
+                "The step that RAM clocks take.",
+                "Options (with examples):",
+                " - 66MHz - 66 MHz step (ex. 1600, 1666, 1733, etc.)",
+                " - 100MHz - 100 MHz step (ex. 1600, 1700, 1800, etc.)",
+                " - 133MHz - 66 MHz step (ex. 1600, 1733, 1866, etc.)",
+                " - JEDEC:",
+                "   - 1600, 1866, 1996, 2133, 2400, 2666, 2933 and 3200 MHz are used",
+                "The RAM max clock will always be available regardless of the step mode, but the intermediate frequencies will be limited by the selected step mode.",
+                "This setting does not affect performance and the option you choose mostly is based on your personal taste",
+                "33 MHz step mode is not possible due to certian limitations of Horizon OS",
+                "Default: 66 MHz",
+            };
+
+        case KipConfigValue_marikoEmcMaxClock:
+            return {
+                "The maximum RAM frequency available.",
+                "Higher frequencies may cause instability, so increase this gradually and test for stability.",
+                "Default: 2133 MHz"
+            };
+
+        case KipConfigValue_eristaEmcMaxClock:
+        case KipConfigValue_eristaEmcMaxClock1:
+        case KipConfigValue_eristaEmcMaxClock2:
+            return {
+                "The RAM frequency used in the particular slot. Higher frequencies may cause instability, so increase this gradually and test for stability.",
+                "Default: Disabled (1600 MHz)"
+            };
+
+        case KipConfigValue_t1_tRCD:
+            return {
+                "RAS-to-CAS delay",
+                "Default: 0"
+            };
+
+        case KipConfigValue_t2_tRP:
+            return {
+                "Row precharge time",
+                "Default: 0"
+            };
+
+        case KipConfigValue_t3_tRAS:
+            return {
+                "Row active time",
+                "Default: 0"
+            };
+
+        case KipConfigValue_t4_tRRD:
+            return {
+                "Row refresh time",
+                "Default: 0"
+            };
+
+        case KipConfigValue_t5_tRFC:
+            return {
+                "Refresh Cycle Time",
+                "Default: 0"
+            };
+
+        case KipConfigValue_t6_tRTW:
+            return {
+                "Read To Write (High bracket)",
+                "Default: 0"
+            };
+
+        case KipConfigValue_t7_tWTR:
+            return {
+                "Write To Read (High bracket)",
+                "Default: 0"
+            };
+
+        case KipConfigValue_t8_tREFI:
+            return {
+                "Refresh command interval",
+                "Default: 0"
+            };
+
+        case KipConfigValue_timingEmcTbreak:
+            return {
+                "Frequency where t6 and t7 break between the low and high brackets",
+                "Example:",
+                "Tbreak is set to 1866 MHz, and t6Low is set to 4 and t6High is set to 2. At frequencies below 1866 MHz, t6 will be 4, and at frequencies above 1866 MHz, t6 will be 2.",
+                "Default: Disabled"
+            };
+
+        case KipConfigValue_low_t6_tRTW:
+            return {
+                "Read To Write (Low bracket)",
+                "Default: 0"
+            };
+
+        case KipConfigValue_low_t7_tWTR:
+            return {
+                "Write To Read (Low bracket)",
+                "Default: 0"
+            };
+        case KipConfigValue_t2_tRP_cap:
+            return {
+                "Cap for t2 when 1333WL is used.",
+                "The default value is sufficient for most RAMs but some may need a lower value",
+                "Default: 2"
+            };
+
+        case KipConfigValue_t6_tRTW_fine_tune:
+            return {
+                "Finetunes the raw calculation of t6",
+                "Default: 0"
+            };
+
+        case KipConfigValue_t7_tWTR_fine_tune:
+            return {
+                "Finetunes the raw calculation of t6",
+                "Default: 0"
+            };
+
+        case KipConfigValue_write_latency_1333:
+        case KipConfigValue_write_latency_1600:
+        case KipConfigValue_write_latency_1866:
+        case KipConfigValue_write_latency_2133:
+        case KipConfigValue_read_latency_1333:
+        case KipConfigValue_read_latency_1600:
+        case KipConfigValue_read_latency_1866:
+        case KipConfigValue_read_latency_2133:
+            return {
+                "Latency bracket settings",
+                "Example:",
+                "If 1333 is set to 2000 MHz, 1600 set to 2500 MHz, 1866 set to 2766 MHz and 2133 set to 2933 MHz:",
+                "Frequencies below 2000 MHz use 1333, 2033-2500 MHz use 1600, 2533-2766 MHz use 1866 and 2800-2933 MHz use 2133. ",
+                "Either of these can be ommited and it will work (say you set 1333 to -, then <2000 MHz will use 1600 latency)",
+                "If all of these parameters are ommited the latency will automatically be calculated as follows:",
+                "1633-1866 MHz - 1866 WRL",
+                "1900+ MHz - 2133 WRL",
+                "These properties apply for both write and read latencies, and you can mix-and-match the brackets if nessesary",
+                "Default: -"
+            };
+
+        case KipConfigValue_mem_burst_read_latency:
+            return {
+                "The read latency for the ram",
+                "Default: 1600 RL"
+            };
+
+        case KipConfigValue_mem_burst_write_latency:
+            return {
+                "The write latency for the ram",
+                "Default: 1600 WL"
+            };
+
+        case KipConfigValue_marikoCpuUVLow:
+            return {
+                "The CPU UV level used before tBreak",
+                "Default: 0"
+            };
+
+        case KipConfigValue_marikoCpuUVHigh:
+            return {
+                "The CPU UV level used after tBreak",
+                "Default: 0"
+            };
+
+        case KipConfigValue_tableConf:
+            return {
+                "The current UV table used. The tbreaks are as follows:",
+                "1581 MHz tBreak and 1683 MHz tBreak use their respective tBreaks",
+                "The other tables use 1581 MHz as tBreak",
+                "The \"Default\" table does not contain frequencies past 1963 MHz and may not undervolt correctly"
+            };
+
+        case KipConfigValue_marikoCpuLowVmin:
+            return {
+                "The CPU vmin used before tBreak",
+                "Default: 620 mV"
+            };
+
+        case KipConfigValue_marikoCpuHighVmin:
+            return {
+                "The CPU vmin used after tBreak",
+                "Default: 750 mV"
+            };
+
+
+        case KipConfigValue_marikoCpuMaxVolt:
+            return {
+                "The maximum voltage that the CPU can use",
+                "Change this setting with caution!",
+                "Default: 1120 mV"
+            };
+
+        case KipConfigValue_marikoCpuMaxClock:
+            return {
+                "The maximum available CPU clock",
+                "Default: 1963 MHz"
+            };
+
+        case KipConfigValue_marikoCpuBoostClock:
+            return {
+                "The clock used for the CPU in \"boost mode\"",
+                "Default: 1963 MHz"
+            };
+
+        case KipConfigValue_eristaCpuUV:
+            return {
+                "CPU undervolt level",
+                "Default: 0"
+            };
+
+        case KipConfigValue_eristaCpuUnlock:
+            return {
+                "Unlock unsafe CPU clocks",
+                "Default: OFF"
+            };
+
+        case KipConfigValue_eristaCpuVmin:
+            return {
+                "Minimum CPU voltage",
+                "Default: 825 mV"
+            };
+
+        case KipConfigValue_eristaCpuMaxVolt:
+            return {
+                "Maximum CPU voltage",
+                "Default: 1235 mV"
+            };
+
+        case HocClkConfigValue_EristaMaxCpuClock:
+            return {
+                "The maximum available CPU clock",
+                "Default: 1785 MHz"
+            };
+
+        case KipConfigValue_eristaCpuBoostClock:
+            return {
+                "The clock used for the CPU in \"boost mode\"",
+                "Default: 1785 MHz"
+            };
+
+        case HocClkConfigValue_OverwriteBoostMode:
+            return {
+                "If enabled, profiles can override the boost mode setting",
+                "Default: OFF"
+            };
+
+        case KipConfigValue_marikoGpuUV:
+            return {
+                "GPU undervolt level",
+                "Options:",
+                " - HiOPT: L4T Custom HiOPT table",
+                " - HiOPT - 15mV: L4T Custom HiOPT table with a 15mV offset",
+                " - High UV: The highest undervolt table, reccomended",
+                "Default: HiOPT"
+            };
+
+        case KipConfigValue_marikoGpuVmin:
+            return {
+                "Minimum GPU voltage",
+                "Note: DVFS may change this value when the RAM clock is changed if the DVFS mode is set to PCV Hijack",
+                "Default: 610 mV"
+            };
+
+        case KipConfigValue_marikoGpuVmax:
+            return {
+                "Maximum GPU voltage",
+                "Default: 800 mV"
+            };
+
+        case HocClkConfigValue_DVFSMode:
+            return {
+                "The mode used for GPU DVFS",
+                "Adjusts GPU vmin when RAM clock is changed due to a higher requirement",
+                "Options:",
+                "- Disabled: disabled...",
+                "- PCV Hijack: hijack PCV for override",
+                "Default: PCV Hijack"
+            };
+
+        case HocClkConfigValue_DVFSOffset:
+            return {
+                "The offset added/subtracted to the GPU vmin when the RAM clock is changed due to a higher requirement in PCV Hijack mode",
+                "Default: 0 mV (Disabled)"
+            };
+
+        case KipConfigValue_eristaGpuUV:
+            return {
+                "GPU undervolt level",
+                "Options:",
+                " - HiOPT: L4T Custom HiOPT table",
+                " - HiOPT - 15mV: L4T Custom HiOPT table with a 15mV offset",
+                " - High UV: The highest undervolt table, reccomended",
+                "Default: HiOPT"
+            };
+
+        case KipConfigValue_eristaGpuVmin:
+            return {
+                "Minimum GPU voltage",
+                "Default: 810 mV (812mV as erista is stepped my 6.5mV instead of 5mV)"
+            };
+
+        case KipConfigValue_commonGpuVoltOffset:
+            return {
+                "The offset added/subtracted to all AUTO GPU voltages",
+                "Default: 0 mV (Disabled)"
+            };
+
+        case HocClkConfigValue_GPUScheduling:
+            return {
+                "The scheduling method used for GPU clocks",
+                "Options:",
+                "- Do Not Override: Do not override existing scheduling mode",
+                "- Disabled: Disables GPU scheduling, 99.7% GPU max load",
+                "- Enabled: Enables GPU scheduling, 96.5% GPU max load",
+                "Default: Do not override"
+            };
+
+        default:
+            return {};
+    }
+}

Source/hoc-clk/overlay/src/ui/gui/config_info_strings.h

@@ -0,0 +1,23 @@
+/*
+ *
+ * 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 "misc_gui.h"
+#include <vector>
+#include <string>
+
+std::vector<std::string> ConfigInfoStrings(HocClkConfigValue val, bool isMariko, bool isHoag);

Source/hoc-clk/overlay/src/ui/gui/info_gui.cpp

@@ -0,0 +1,88 @@
+/*
+ *
+ * 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 "info_gui.h"
+#include "ult_ext.h"
+#include <sstream>
+
+InfoGui::InfoGui(std::string title, std::vector<std::string> strings)
+    : m_title(std::move(title)), m_strings(std::move(strings)) {}
+
+static constexpr s32  TEXT_SIZE  = 16;
+static constexpr s32  LINE_H     = 22;
+static constexpr s32  PARA_GAP   = 10;
+static constexpr s32  MARGIN_L   = 20;
+static constexpr s32  MARGIN_R   = 35;
+
+static std::vector<std::string> wrapText(const std::string& text, s32 maxWidth)
+{
+    constexpr float CHAR_W = 10.0f;
+
+    // Preserve leading whitespace as an indent prefix for wrapped continuation lines.
+    std::string indent;
+    for (char c : text) {
+        if (c == ' ') indent += ' ';
+        else break;
+    }
+
+    std::vector<std::string> lines;
+    std::istringstream ss(text);
+    std::string word, line = indent; // seed with indent so first word inherits it
+    bool first = true;
+    while (ss >> word) {
+        std::string candidate = (first && !indent.empty()) ? indent + word
+                              : line.empty()               ? word
+                                                           : line + " " + word;
+        first = false;
+        if (static_cast<s32>(candidate.size() * CHAR_W) <= maxWidth)
+            line = std::move(candidate);
+        else {
+            if (!line.empty() && line != indent) lines.push_back(line);
+            line = indent + word;
+        }
+    }
+    if (!line.empty() && line != indent) lines.push_back(line);
+    if (lines.empty()) lines.emplace_back("");
+    return lines;
+}
+
+void InfoGui::listUI()
+{
+    this->listElement->addItem(new tsl::elm::CategoryHeader(m_title));
+
+    const s32 maxWidth = tsl::cfg::FramebufferWidth - MARGIN_L - MARGIN_R;
+
+    for (const auto& para : m_strings) {
+        for (const auto& lineText : wrapText(para, maxWidth)) {
+            auto* d = new FocusableDrawer(
+                [lineText](tsl::gfx::Renderer* r, s32 x, s32 y, s32 w, s32 h) {
+                    r->drawString((lineText + "\n").c_str(), false,
+                                  x + MARGIN_L, y + LINE_H - 5,
+                                  TEXT_SIZE, tsl::style::color::ColorText);
+                });
+            d->setBoundaries(0, 0, tsl::cfg::FramebufferWidth, LINE_H);
+            this->listElement->addItem(d, LINE_H);
+        }
+
+        // paragraph gap
+        auto* gap = new tsl::elm::CustomDrawer(
+            [](tsl::gfx::Renderer*, s32, s32, s32, s32) {});
+        gap->setBoundaries(0, 0, tsl::cfg::FramebufferWidth, PARA_GAP);
+        this->listElement->addItem(gap, PARA_GAP);
+    }
+}

Source/hoc-clk/overlay/src/ui/gui/info_gui.h

@@ -1,5 +1,6 @@
 /*
- * Copyright (c) ppkantorski (bord2death)
+ *
+ * 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,
@@ -12,21 +13,21 @@
  *
  * 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 "base_menu_gui.h"
+#include <string>
+#include <vector>
 
-#include <switch.h>  // for Service, Result, hosversionBefore(), smGetService(), serviceClose(), etc.
-#include "rgltr.h"   // for RgltrSession, PowerDomainId, etc.
+class InfoGui : public BaseMenuGui
+{
+public:
+    InfoGui(std::string title, std::vector<std::string> strings);
+    ~InfoGui() = default;
+    void listUI() override;
 
-extern Service g_rgltrSrv;
-
-Result rgltrInitialize(void);
-void   rgltrExit(void);
-
-Result rgltrOpenSession(RgltrSession* session_out, PowerDomainId module_id);
-
-Result rgltrGetVoltage(RgltrSession* session, u32* out_volt);
-
-void   rgltrCloseSession(RgltrSession* session);
+private:
+    std::string m_title;
+    std::vector<std::string> m_strings;
+};

Source/hoc-clk/overlay/src/ui/gui/misc_gui.cpp

@@ -18,6 +18,7 @@
 
 #include "misc_gui.h"
 #include "fatal_gui.h"
+#include "config_info_strings.h"
 #include "../format.h"
 #include <cstdio>
 #include <cstring>
@@ -88,7 +89,24 @@ MiscGui::~MiscGui()
 
 void MiscGui::addConfigToggle(HocClkConfigValue configVal, const char* altName, bool kip) {
     const char* configName = altName ? altName : hocclkFormatConfigValue(configVal, true);
-    tsl::elm::ToggleListItem* toggle = new tsl::elm::ToggleListItem(configName, this->configList->values[configVal]);
+    auto infoStrings = ConfigInfoStrings(configVal, IsMariko(), IsHoag());
+
+    struct YAwareToggle : tsl::elm::ToggleListItem {
+        std::vector<std::string> m_info;
+        std::string m_title;
+        YAwareToggle(const char* text, bool state, std::string title, std::vector<std::string> info)
+            : tsl::elm::ToggleListItem(text, state), m_info(std::move(info)), m_title(std::move(title)) {}
+        bool onClick(u64 keys) override {
+            if (!m_info.empty() && (keys & HidNpadButton_Y) && !(keys & ~HidNpadButton_Y)) {
+                tsl::changeTo<InfoGui>(m_title, m_info);
+                return true;
+            }
+            return tsl::elm::ToggleListItem::onClick(keys);
+        }
+    };
+
+    auto* toggle = new YAwareToggle(configName, this->configList->values[configVal],
+                                    configName, std::move(infoStrings));
     if (!kip)
         toggle->setTextColor(tsl::Color(120, 235, 255, 255));
     toggle->setStateChangedListener([this, configVal, kip](bool state) {
@@ -106,9 +124,13 @@ void MiscGui::addConfigToggle(HocClkConfigValue configVal, const char* altName,
 }
 
 void MiscGui::addConfigTrackbar(HocClkConfigValue configVal, const char* altName, const ValueRange& range, bool kip) {
+    auto infoStrings = ConfigInfoStrings(configVal, IsMariko(), IsHoag());
     struct IndexedBar : tsl::elm::NamedStepTrackBar {
-        IndexedBar(const char* label, const ValueRange& r)
-            : tsl::elm::NamedStepTrackBar("", {""}, true, label) {
+        std::vector<std::string> m_info;
+        std::string m_title;
+        IndexedBar(const char* label, const ValueRange& r, std::string title, std::vector<std::string> info)
+            : tsl::elm::NamedStepTrackBar("", {""}, true, label),
+              m_info(std::move(info)), m_title(std::move(title)) {
             m_stepDescriptions.clear();
             u32 numSteps = (r.max - r.min) / r.step + 1;
             for (u32 i = 0; i < numSteps; i++) {
@@ -120,9 +142,17 @@ void MiscGui::addConfigTrackbar(HocClkConfigValue configVal, const char* altName
             m_numSteps = (u8)m_stepDescriptions.size();
             m_selection = m_stepDescriptions[0];
         }
+        bool handleInput(u64 keysDown, u64 keysHeld, const HidTouchState& touchPos,
+                         HidAnalogStickState leftJoyStick, HidAnalogStickState rightJoyStick) override {
+            if (!m_info.empty() && (keysDown & HidNpadButton_Y) && !(keysDown & ~HidNpadButton_Y)) {
+                tsl::changeTo<InfoGui>(m_title, m_info);
+                return true;
+            }
+            return tsl::elm::NamedStepTrackBar::handleInput(keysDown, keysHeld, touchPos, leftJoyStick, rightJoyStick);
+        }
     };
     const char* name = altName ? altName : hocclkFormatConfigValue(configVal, true);
-    auto* bar = new IndexedBar(name, range);
+    auto* bar = new IndexedBar(name, range, name, std::move(infoStrings));
     u32 cur = (u32)this->configList->values[configVal];
     u16 curStep = 0;
     if (cur >= range.min && cur <= range.max && range.step > 0 && (cur - range.min) % range.step == 0)
@@ -141,7 +171,25 @@ void MiscGui::addMappedConfigTrackbar(HocClkConfigValue configVal, const char* a
                                        std::vector<u32> vals,
                                        std::initializer_list<std::string> names, bool kip) {
     const char* name = altName ? altName : hocclkFormatConfigValue(configVal, true);
-    auto* bar = new tsl::elm::NamedStepTrackBar("", names, true, name);
+    auto infoStrings = ConfigInfoStrings(configVal, IsMariko(), IsHoag());
+
+    struct YAwareTrackBar : tsl::elm::NamedStepTrackBar {
+        std::vector<std::string> m_info;
+        std::string m_title;
+        YAwareTrackBar(const char* label, std::initializer_list<std::string> steps, std::string title, std::vector<std::string> info)
+            : tsl::elm::NamedStepTrackBar("", steps, true, label),
+              m_info(std::move(info)), m_title(std::move(title)) {}
+        bool handleInput(u64 keysDown, u64 keysHeld, const HidTouchState& touchPos,
+                         HidAnalogStickState leftJoyStick, HidAnalogStickState rightJoyStick) override {
+            if (!m_info.empty() && (keysDown & HidNpadButton_Y) && !(keysDown & ~HidNpadButton_Y)) {
+                tsl::changeTo<InfoGui>(m_title, m_info);
+                return true;
+            }
+            return tsl::elm::NamedStepTrackBar::handleInput(keysDown, keysHeld, touchPos, leftJoyStick, rightJoyStick);
+        }
+    };
+
+    auto* bar = new YAwareTrackBar(name, names, name, std::move(infoStrings));
     u32 cur = (u32)this->configList->values[configVal];
     u16 curIdx = 0;
     for (u16 i = 0; i < (u16)vals.size(); i++) {
@@ -170,6 +218,7 @@ void MiscGui::addConfigButton(HocClkConfigValue configVal,
     bool kip)
 {
     const char* configName = altName ? altName : hocclkFormatConfigValue(configVal, true);
+    auto infoStrings = ConfigInfoStrings(configVal, IsMariko(), IsHoag());
 
     tsl::elm::ListItem* listItem = new tsl::elm::ListItem(configName);
     if (!kip)
@@ -203,8 +252,14 @@ void MiscGui::addConfigButton(HocClkConfigValue configVal,
     ValueThresholds thresholdsCopy = (thresholds ? *thresholds : ValueThresholds{});
 
     listItem->setClickListener(
-        [this, configVal, range, categoryName, thresholdsCopy, labels, showDefaultValue, kip](u64 keys)
+        [this, configVal, range, categoryName, thresholdsCopy, labels, showDefaultValue, kip,
+         infoStrings = std::move(infoStrings), configName = std::string(configName)](u64 keys)
         {
+            if (!infoStrings.empty() && (keys & HidNpadButton_Y) && !(keys & ~HidNpadButton_Y)) {
+                tsl::changeTo<InfoGui>(configName, infoStrings);
+                return true;
+            }
+
             if ((keys & HidNpadButton_A) == 0)
                 return false;
 
@@ -287,6 +342,8 @@ void MiscGui::addConfigButtonS(HocClkConfigValue configVal,
     const char* subText,
     bool kip)
 {
+    const char* configName = altName ? altName : hocclkFormatConfigValue(configVal, true);
+    auto infoStrings = ConfigInfoStrings(configVal, IsMariko(), IsHoag());
     tsl::elm::ListItem* listItem = new tsl::elm::ListItem("");
     if (!kip)
         listItem->setTextColor(tsl::Color(120, 235, 255, 255));
@@ -321,8 +378,14 @@ void MiscGui::addConfigButtonS(HocClkConfigValue configVal,
     ValueThresholds thresholdsCopy = (thresholds ? *thresholds : ValueThresholds{});
 
     listItem->setClickListener(
-        [this, configVal, range, categoryName, thresholdsCopy, labels, showDefaultValue, kip](u64 keys)
+        [this, configVal, range, categoryName, thresholdsCopy, labels, showDefaultValue, kip,
+         infoStrings = std::move(infoStrings), configName = std::string(configName)](u64 keys)
         {
+            if (!infoStrings.empty() && (keys & HidNpadButton_Y) && !(keys & ~HidNpadButton_Y)) {
+                tsl::changeTo<InfoGui>(configName, infoStrings);
+                return true;
+            }
+
             if ((keys & HidNpadButton_A) == 0)
                 return false;
 
@@ -410,6 +473,7 @@ void MiscGui::addFreqButton(HocClkConfigValue configVal,
                             const std::map<uint32_t, std::string>& labels)
 {
     const char* configName = altName ? altName : hocclkFormatConfigValue(configVal, true);
+    auto infoStrings = ConfigInfoStrings(configVal, IsMariko(), IsHoag());
 
     tsl::elm::ListItem* listItem = new tsl::elm::ListItem(configName);
 
@@ -419,8 +483,14 @@ void MiscGui::addFreqButton(HocClkConfigValue configVal,
     listItem->setValue(valueText);
 
     listItem->setClickListener(
-        [this, configVal, module, labels](u64 keys)
+        [this, configVal, module, labels,
+         infoStrings = std::move(infoStrings), configName = std::string(configName)](u64 keys)
         {
+            if (!infoStrings.empty() && (keys & HidNpadButton_Y) && !(keys & ~HidNpadButton_Y)) {
+                tsl::changeTo<InfoGui>(configName, infoStrings);
+                return true;
+            }
+
             if ((keys & HidNpadButton_A) == 0)
                 return false;
 
@@ -483,8 +553,11 @@ void MiscGui::listUI()
     tsl::elm::CustomDrawer* rebootSetWarning = new tsl::elm::CustomDrawer([](tsl::gfx::Renderer *renderer, s32 x, s32 y, s32 w, s32 h) {
         renderer->drawString("\uE150 Settings marked in blue", false, x + 20, y + 30, 18, tsl::style::color::ColorText);
         renderer->drawString("don't require a reboot to apply!", false, x + 20, y + 50, 18, tsl::style::color::ColorText);
+        renderer->drawString("You can also press \ue0e3 to show", false, x + 20, y + 70, 18, tsl::style::color::ColorText);
+        renderer->drawString("information about each setting.", false, x + 20, y + 90, 18, tsl::style::color::ColorText);
+
     });
-    rebootSetWarning->setBoundaries(0, 0, tsl::cfg::FramebufferWidth, 70);
+    rebootSetWarning->setBoundaries(0, 0, tsl::cfg::FramebufferWidth, 110);
     this->listElement->addItem(rebootSetWarning);
 
     tsl::elm::ListItem* sysmoduleSettingsSubMenu = new tsl::elm::ListItem("General Settings");
@@ -933,7 +1006,10 @@ protected:
 
         this->listElement->addItem(new tsl::elm::CategoryHeader("RAM Settings"));
         
-        addConfigTrackbar(KipConfigValue_emcDvbShift,  "SoC DVB Shift",  ValueRange(0, 16, 1)); // yes, DVB 16 is nessesary
+        addMappedConfigTrackbar(KipConfigValue_emcDvbShift, "DVB Shift",
+            {0xFFFFFFFCu, 0xFFFFFFFDu, 0xFFFFFFFEu, 0xFFFFFFFFu, 0u, 1u, 2u, 3u, 4u, 5u, 6u, 7u, 8u},
+            {"-4", "-3", "-2", "-1", " 0", "1", "2", "3", "4", "5", "6", "7", "8"});
+
         if(IsMariko()) {
             u32 socSpeedo = this->context->speedos[HocClkSpeedo_SOC];
             std::string autoText = "1000 mV";
@@ -1347,7 +1423,12 @@ protected:
             tsl::elm::ListItem* item = new tsl::elm::ListItem(label);
             item->setValue(makeValueText(currentVal));
 
-            item->setClickListener([this, tierIdx, thisKey, keysArr](u64 keys) -> bool {
+            item->setClickListener([this, tierIdx, thisKey, keysArr, label](u64 keys) -> bool {
+                auto infoStrings = ConfigInfoStrings(thisKey, IsMariko(), IsHoag());
+                if (!infoStrings.empty() && (keys & HidNpadButton_Y) && !(keys & ~HidNpadButton_Y)) {
+                    tsl::changeTo<InfoGui>(std::string(label), infoStrings);
+                    return true;
+                }
                 if ((keys & HidNpadButton_A) == 0)
                     return false;
 

Source/hoc-clk/overlay/src/ui/gui/misc_gui.h

@@ -25,6 +25,7 @@
 #include <vector>
 #include "freq_choice_gui.h"
 #include "value_choice_gui.h"
+#include "info_gui.h"
 class MiscGui : public BaseMenuGui
 {
 public:
@@ -32,7 +33,7 @@ public:
     ~MiscGui();
     void listUI() override;
     void refresh() override;
-    
+
 protected:
     HocClkConfigValueList* configList;
     std::map<HocClkConfigValue, tsl::elm::ListItem*> configButtons;
@@ -43,7 +44,7 @@ protected:
     std::set<HocClkConfigValue> configButtonSKeys;
     std::map<HocClkConfigValue, std::string> configButtonSSubtext;
     std::set<HocClkConfigValue> emcClockConfigs;
-    
+
     void addConfigToggle(HocClkConfigValue configVal, const char* altName, bool kip = false);
     void addConfigTrackbar(HocClkConfigValue configVal, const char* altName, const ValueRange& range, bool kip = true);
     void addMappedConfigTrackbar(HocClkConfigValue configVal, const char* altName,
@@ -74,8 +75,8 @@ protected:
                             HocClkModule module,
                             const std::map<uint32_t, std::string>& labels = {});
     void updateConfigToggles();
-    
+
     tsl::elm::ToggleListItem* enabledToggle;
     u8 frameCounter = 60;
     bool shouldSaveKip = false;
-};
+};

Source/hoc-clk/overlay/src/ui/gui/ult_ext.h

@@ -95,6 +95,18 @@ public:
     }
 };
 
+class FocusableDrawer : public tsl::elm::CustomDrawer {
+public:
+    template<typename... Args>
+    FocusableDrawer(Args&&... args) : tsl::elm::CustomDrawer(std::forward<Args>(args)...) {
+        m_isItem = true;
+    }
+    Element* requestFocus(Element*, tsl::FocusDirection) override {
+        return this;
+    }
+    void drawHighlight(tsl::gfx::Renderer*) override {}
+};
+
 class HideableCustomDrawer : public tsl::elm::Element {
 private:
     bool visible;

Source/hoc-clk/sysmodule/Makefile

@@ -28,9 +28,9 @@ INCLUDES	:=	../common/include src/hos src/soc src/i2c src/util src/pwr src/ipc
 EXEFS_SRC	:=	exefs_src
 LIBNAMES	:=	minIni
 # major minor patch
-TARGET_VERSION	:= 2.2.0
-KIP_VERSION :=  220
-CUST_REV    :=  2
+TARGET_VERSION	:= 2.3.1
+KIP_VERSION :=  231
+CUST_REV    :=  3
 
 #---------------------------------------------------------------------------------
 # options for code generation

Source/hoc-clk/sysmodule/perms.json

@@ -3,7 +3,7 @@
 	"title_id": "0x00FF0000636C6BFF",
 	"title_id_range_min": "0x00FF0000636C6BFF",
 	"title_id_range_max": "0x00FF0000636C6BFF",
-	"main_thread_stack_size": "0x0000B000",
+	"main_thread_stack_size": "0x0000C000",
 	"main_thread_priority": 16,
 	"default_cpu_id": 3,
 	"process_category": 1,

Source/hoc-clk/sysmodule/src/board/board.cpp

@@ -37,7 +37,6 @@
 #include <registers.h>
 #include <battery.h>
 #include "../display/display_refresh_rate.hpp"
-#include <rgltr.h>
 #include <notification.h>
 
 #include "board.hpp"
@@ -135,9 +134,6 @@ namespace board {
         rc = tmp451Initialize();
         ASSERT_RESULT_OK(rc, "tmp451Initialize");
 
-        rc = rgltrInitialize();
-        ASSERT_RESULT_OK(rc, "rgltrInitialize");
-
         rc = pmdmntInitialize();
         ASSERT_RESULT_OK(rc, "pmdmntInitialize");
 
@@ -220,7 +216,6 @@ namespace board {
 
         pwmChannelSessionClose(&iCon);
         pwmExit();
-        rgltrExit();
         batteryInfoExit();
         pmdmntExit();
         nvExit();
@@ -245,7 +240,7 @@ namespace board {
         svcCallSecureMonitor(&args);
 
         if (args.X[1] == (MC_REGISTER_BASE + MC_EMEM_CFG_0)) { // if param 1 is identical read failed
-            notification::writeNotification("Horizon OC\nSecmon read failed!\n This may be a hardware issue!");
+            notification::writeNotification("Horizon OC\nSecmon-Lesen fehlgeschlagen!\nDies könnte ein Hardwareproblem sein!");
             return false;
         }
 

Source/hoc-clk/sysmodule/src/board/board_misc.cpp

@@ -27,7 +27,6 @@
 #include <switch.h>
 #include <pwm.h>
 #include <cmath>
-#include <rgltr.h>
 
 namespace board {
 

Source/hoc-clk/sysmodule/src/board/board_volt.cpp

@@ -22,13 +22,12 @@
 #include <memmem.h>
 #include <registers.h>
 #include <cstring>
-#include <rgltr.h>
 #include <battery.h>
 #include "board.hpp"
 #include "board_freq.hpp"
 #include "board_volt.hpp"
 #include "../file/file_utils.hpp"
-
+#include "../i2c/i2cDrv.h"
 namespace board {
 
     GpuVoltData voltData = {};
@@ -215,59 +214,39 @@ namespace board {
     } PowerDomainId;
     */
     u32 GetVoltage(HocClkVoltage voltage) {
-        RgltrSession session;
-        Result rc = 0;
         u32 out = 0;
         BatteryChargeInfo info;
 
         switch (voltage) {
             case HocClkVoltage_SOC:
-                rc = rgltrOpenSession(&session, PcvPowerDomainId_Max77620_Sd0);
-                ASSERT_RESULT_OK(rc, "rgltrOpenSession")
-                rgltrGetVoltage(&session, &out);
-                rgltrCloseSession(&session);
+                out = I2c_BuckConverter_GetUvOut(&I2c_SOC);
                 break;
             case HocClkVoltage_EMCVDD2:
-                rc = rgltrOpenSession(&session, PcvPowerDomainId_Max77620_Sd1);
-                ASSERT_RESULT_OK(rc, "rgltrOpenSession")
-                rgltrGetVoltage(&session, &out);
-                rgltrCloseSession(&session);
+                out = I2c_BuckConverter_GetUvOut(&I2c_VDD2);
                 break;
             case HocClkVoltage_CPU:
-                if (GetSocType() == HocClkSocType_Mariko) {
-                    rc = rgltrOpenSession(&session, PcvPowerDomainId_Max77621_Cpu);
+                if(GetSocType() == HocClkSocType_Mariko) {
+                    out = I2c_BuckConverter_GetUvOut(&I2c_Mariko_CPU);
                 } else {
-                    rc = rgltrOpenSession(&session, PcvPowerDomainId_Max77812_Cpu);
+                    out = I2c_BuckConverter_GetUvOut(&I2c_Erista_CPU);
                 }
-                ASSERT_RESULT_OK(rc, "rgltrOpenSession")
-                rgltrGetVoltage(&session, &out);
-                rgltrCloseSession(&session);
                 break;
             case HocClkVoltage_GPU:
-                if (GetSocType() == HocClkSocType_Mariko) {
-                    rc = rgltrOpenSession(&session, PcvPowerDomainId_Max77621_Gpu);
+                if(GetSocType() == HocClkSocType_Mariko) {
+                    out = I2c_BuckConverter_GetUvOut(&I2c_Mariko_GPU);
                 } else {
-                    rc = rgltrOpenSession(&session, PcvPowerDomainId_Max77812_Gpu);
-                }
-                ASSERT_RESULT_OK(rc, "rgltrOpenSession")
-                rgltrGetVoltage(&session, &out);
-                rgltrCloseSession(&session);
+                    out = I2c_BuckConverter_GetUvOut(&I2c_Erista_GPU);
+                }               
                 break;
             case HocClkVoltage_EMCVDDQ:
-                if (GetSocType() == HocClkSocType_Mariko) {
-                    rc = rgltrOpenSession(&session, PcvPowerDomainId_Max77812_Dram);
-                    ASSERT_RESULT_OK(rc, "rgltrOpenSession")
-                    rgltrGetVoltage(&session, &out);
-                    rgltrCloseSession(&session);
+                if(GetSocType() == HocClkSocType_Mariko) {
+                    out = I2c_BuckConverter_GetUvOut(&I2c_Mariko_DRAM_VDDQ);
                 } else {
-                    out = GetVoltage(HocClkVoltage_EMCVDD2); // VDD2 and VDDQ are always connected to the same rail on Erista
+                    out = I2c_BuckConverter_GetUvOut(&I2c_VDD2);
                 }
                 break;
             case HocClkVoltage_Display:
-                rc = rgltrOpenSession(&session, PcvPowerDomainId_Max77620_Ldo0);
-                ASSERT_RESULT_OK(rc, "rgltrOpenSession")
-                rgltrGetVoltage(&session, &out);
-                rgltrCloseSession(&session);
+                out = I2c_BuckConverter_GetUvOut(&I2c_Display);
                 break;
             case HocClkVoltage_Battery:
                 batteryInfoGetChargeInfo(&info);

Source/hoc-clk/sysmodule/src/file/kip.cpp

@@ -31,7 +31,7 @@ namespace kip {
         // if(board::GetSocType() == HocClkSocType_Mariko) {
         //     if(R_FAILED(I2c_BuckConverter_SetMvOut(&I2c_Mariko_DRAM_VDDQ, config::GetConfigValue(KipConfigValue_marikoEmcVddqVolt) / 1000))) {
         //         fileUtils::LogLine("[clock_manager] Failed set i2c vddq");
-        //         notification::writeNotification("Horizon OC\nFailed to write I2C\nwhile setting vddq");
+        //         notification::writeNotification("Horizon OC\nI2C-Schreiben fehlgeschlagen!\nbeim Setzen von vddq");
         //     }
         // }
         CustomizeTable table;
@@ -39,7 +39,7 @@ namespace kip {
         fp = fopen("sdmc:/atmosphere/kips/hoc.kip", "r");
 
         if (fp == NULL) {
-            notification::writeNotification("Horizon OC\nKip opening failed");
+            notification::writeNotification("Horizon OC\nKIP konnte nicht geöffnet werden!");
             kipAvailable = false;
             return;
         } else {
@@ -49,19 +49,19 @@ namespace kip {
 
         if (!cust_read_and_cache("sdmc:/atmosphere/kips/hoc.kip", &table)) {
             fileUtils::LogLine("[kip] Failed to read KIP file");
-            notification::writeNotification("Horizon OC\nKip read failed");
+            notification::writeNotification("Horizon OC\nKIP konnte nicht gelesen werden!");
             return;
         }
 
         u32 custRev    = cust_get_cust_rev(&table);
         u32 kipVersion = cust_get_kip_version(&table);
         if (custRev < CUST_REV || kipVersion < KIP_VERSION) {
-            notification::writeNotification("Horizon OC\nOutdated kip detected!\nPlease update Horizon OC");
+            notification::writeNotification("Horizon OC\nVeraltetes KIP erkannt!\nBitte Horizon OC aktualisieren");
             fileUtils::LogLine("Cust revision: %u", custRev);
             fileUtils::LogLine("Kip version: %u", kipVersion);
             return;
         } else if (custRev > CUST_REV || kipVersion > KIP_VERSION) {
-            notification::writeNotification("Horizon OC\nOutdated sysmodule detected!\nPlease update Horizon OC");
+            notification::writeNotification("Horizon OC\nVeraltetes Sysmodule erkannt!\nBitte Horizon OC aktualisieren");
             fileUtils::LogLine("Cust revision: %u", custRev);
             fileUtils::LogLine("Kip version: %u", kipVersion);
             return;
@@ -76,7 +76,7 @@ namespace kip {
         CUST_WRITE_FIELD_BATCH(&table, eristaEmcMaxClock2, config::GetConfigValue(KipConfigValue_eristaEmcMaxClock2));
         CUST_WRITE_FIELD_BATCH(&table, marikoEmcMaxClock, config::GetConfigValue(KipConfigValue_marikoEmcMaxClock));
         CUST_WRITE_FIELD_BATCH(&table, marikoEmcVddqVolt, config::GetConfigValue(KipConfigValue_marikoEmcVddqVolt));
-        CUST_WRITE_FIELD_BATCH(&table, emcDvbShift, config::GetConfigValue(KipConfigValue_emcDvbShift));
+        CUST_WRITE_FIELD_BATCH(&table, emcDvbShift, config::GetConfigValue(KipConfigValue_emcDvbShift) > 8 && config::GetConfigValue(KipConfigValue_emcDvbShift) <= 16 ? 8 : config::GetConfigValue(KipConfigValue_emcDvbShift)); // 2.2.0 -> 2.3.0 compat
         CUST_WRITE_FIELD_BATCH(&table, marikoSocVmax, config::GetConfigValue(KipConfigValue_marikoSocVmax));
 
         CUST_WRITE_FIELD_BATCH(&table, t1_tRCD, config::GetConfigValue(KipConfigValue_t1_tRCD));
@@ -145,7 +145,7 @@ namespace kip {
 
         if (!cust_write_table("sdmc:/atmosphere/kips/hoc.kip", &table)) {
             fileUtils::LogLine("[kip] Failed to write KIP file");
-            notification::writeNotification("Horizon OC\nKip write failed");
+            notification::writeNotification("Horizon OC\nKIP konnte nicht geschrieben werden!");
         }
 
         HocClkConfigValueList configValues;
@@ -160,7 +160,7 @@ namespace kip {
             }
         } else {
             fileUtils::LogLine("[kip] Warning: Failed to set config values from KIP");
-            notification::writeNotification("Horizon OC\nKip config set failed");
+            notification::writeNotification("Horizon OC\nKIP-Konfiguration konnte nicht gesetzt werden!");
         }
     }
 
@@ -172,7 +172,7 @@ namespace kip {
         fp = fopen("sdmc:/atmosphere/kips/hoc.kip", "r");
 
         if (fp == NULL) {
-            notification::writeNotification("Horizon OC\nKip opening failed");
+            notification::writeNotification("Horizon OC\nKIP konnte nicht geöffnet werden!");
             kipAvailable = false;
             return;
         } else {
@@ -186,23 +186,23 @@ namespace kip {
         CustomizeTable table;
         if (!cust_read_and_cache("sdmc:/atmosphere/kips/hoc.kip", &table)) {
             fileUtils::LogLine("[kip] Failed to read KIP file for GetKipData");
-            notification::writeNotification("Horizon OC\nKip read failed");
+            notification::writeNotification("Horizon OC\nKIP konnte nicht gelesen werden!");
             return;
         }
 
         // if(cust_get_cust_rev(&table) != CUST_REV) {
-        //     notification::writeNotification("Horizon OC\nKip version mismatch\nPlease reinstall Horizon OC");
+        //     notification::writeNotification("Horizon OC\nKIP-Versionskonflikt!\nBitte Horizon OC neu installieren");
         //     return;
         // }
 
         if ((u64)crc32::checksum_file("sdmc:/atmosphere/kips/hoc.kip") != config::GetConfigValue(KipCrc32) && !config::GetConfigValue(HocClkConfigValue_IsFirstLoad)) {
             SetKipData();
-            notification::writeNotification("Horizon OC\nKIP has been updated\nPlease reboot your console");
+            notification::writeNotification("Horizon OC\nKIP wurde aktualisiert\nBitte Konsole neu starten");
             return;
         }
         if (config::GetConfigValue(HocClkConfigValue_IsFirstLoad) == true) {
             configValues.values[HocClkConfigValue_IsFirstLoad] = (u64)false;
-            notification::writeNotification("Horizon OC has been installed");
+            notification::writeNotification("Horizon OC wurde installiert");
         }
 
         configValues.values[KipCrc32] = (u64)crc32::checksum_file("sdmc:/atmosphere/kips/hoc.kip"); // write checksum
@@ -212,12 +212,12 @@ namespace kip {
         u32 custRev    = cust_get_cust_rev(&table);
         u32 kipVersion = cust_get_kip_version(&table);
         if (custRev < CUST_REV || kipVersion < KIP_VERSION) {
-            notification::writeNotification("Horizon OC\nOutdated kip detected!\nPlease update Horizon OC");
+            notification::writeNotification("Horizon OC\nVeraltetes KIP erkannt!\nBitte Horizon OC aktualisieren");
             fileUtils::LogLine("Cust revision: %u", custRev);
             fileUtils::LogLine("Kip version: %u", kipVersion);
             return;
         } else if (custRev > CUST_REV || kipVersion > KIP_VERSION) {
-            notification::writeNotification("Horizon OC\nOutdated sysmodule detected!\nPlease update Horizon OC");
+            notification::writeNotification("Horizon OC\nVeraltetes Sysmodule erkannt!\nBitte Horizon OC aktualisieren");
             fileUtils::LogLine("Cust revision: %u", custRev);
             fileUtils::LogLine("Kip version: %u", kipVersion);
             return;
@@ -233,7 +233,7 @@ namespace kip {
         configValues.values[KipConfigValue_eristaEmcMaxClock2] = cust_get_erista_emc_max2(&table);
         configValues.values[KipConfigValue_marikoEmcMaxClock] = cust_get_mariko_emc_max(&table);
         configValues.values[KipConfigValue_marikoEmcVddqVolt] = cust_get_mariko_emc_vddq(&table);
-        configValues.values[KipConfigValue_emcDvbShift] = cust_get_emc_dvb_shift(&table);
+        configValues.values[KipConfigValue_emcDvbShift] = cust_get_emc_dvb_shift(&table) > 8 && cust_get_emc_dvb_shift(&table) <= 16 ? 8 : cust_get_emc_dvb_shift(&table); // 2.2.0 -> 2.3.0 compat
         configValues.values[KipConfigValue_marikoSocVmax] = cust_get_marikoSocVmax(&table);
 
         configValues.values[KipConfigValue_t1_tRCD] = cust_get_tRCD(&table);
@@ -306,11 +306,12 @@ namespace kip {
                 }
             } else {
                 fileUtils::LogLine("[kip] Warning: Failed to set config values from KIP");
-                notification::writeNotification("Horizon OC\nKip config set failed");
+                notification::writeNotification("Horizon OC\nKIP-Konfiguration konnte nicht gesetzt werden!");
             }
         } else {
             fileUtils::LogLine("[kip] Error: Config value list buffer size mismatch");
-            notification::writeNotification("Horizon OC\nConfig Buffer Mismatch");
+            notification::writeNotification("Horizon OC\nKonfigurationspuffer stimmt nicht überein");
         }
     }
-}
+}
+

Source/hoc-clk/sysmodule/src/hos/rgltr.h

@@ -1,38 +0,0 @@
-/*
- * Copyright (c) ppkantorski (bord2death)
- *
- * 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 <switch.h>
-#include "pcv_types.h"
-
-typedef struct {
-    Service s;
-} RgltrSession;
-
-Result rgltrInitialize(void);
-
-void rgltrExit(void);
-
-Service* rgltrGetServiceSession(void);
-
-Result rgltrOpenSession(RgltrSession* session_out, PowerDomainId module_id);
-void rgltrCloseSession(RgltrSession* session);
-Result rgltrGetVoltage(RgltrSession* session, u32 *out_volt);
-Result rgltrGetPowerModuleNumLimit(u32 *out);
-Result rgltrGetVoltageEnabled(RgltrSession* session, u32 *out);
-Result rgltrRequestVoltage(RgltrSession* session, u32 microvolt);
-Result rgltrCancelVoltageRequest(RgltrSession* session);

Source/hoc-clk/sysmodule/src/hos/rgltr_services.cpp

@@ -1,66 +0,0 @@
-/*
- * Copyright (c) ppkantorski (bord2death)
- *
- * 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 <switch.h>
-#include "rgltr.h"
-#include "rgltr_services.h"  // for extern Service g_rgltrSrv, etc.
-
-// Global service handle
-Service g_rgltrSrv;
-
-Result rgltrInitialize(void) {
-    if (hosversionBefore(8, 0, 0)) {
-        return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
-    }
-    return smGetService(&g_rgltrSrv, "rgltr");
-}
-
-void rgltrExit(void) {
-    serviceClose(&g_rgltrSrv);
-}
-
-Result rgltrOpenSession(RgltrSession* session_out, PowerDomainId module_id) {
-    const u32 in = (u32)module_id;
-    return serviceDispatchIn(
-        &g_rgltrSrv,
-        0,
-        in,
-        .out_num_objects = 1,
-        .out_objects     = &session_out->s
-    );
-}
-
-Result rgltrGetVoltage(RgltrSession* session, u32* out_volt) {
-    u32 temp = 0;
-    Result rc = serviceDispatchOut(&session->s, 4, temp);
-    if (R_SUCCEEDED(rc)) {
-        *out_volt = temp;
-    }
-    return rc;
-}
-
-Result rgltrRequestVoltage(RgltrSession* session, u32 microvolt) {
-    return serviceDispatchIn(&session->s, 5, microvolt);
-}
-
-Result rgltrCancelVoltageRequest(RgltrSession* session) {
-    return serviceDispatch(&session->s, 6);
-}
-
-void rgltrCloseSession(RgltrSession* session) {
-    serviceClose(&session->s);
-}

Source/hoc-clk/sysmodule/src/i2c/i2cDrv.cpp

@@ -103,6 +103,10 @@ u32 I2c_BuckConverter_MultiplierToMvOut(const I2c_BuckConverter_Domain* domain,
     return (domain->uv_min + domain->uv_step * multiplier) / 1000;
 }
 
+u32 I2c_BuckConverter_MultiplierToUvOut(const I2c_BuckConverter_Domain* domain, u8 multiplier) {
+    return domain->uv_min + domain->uv_step * multiplier;
+}
+
 u8 I2c_BuckConverter_MvOutToMultiplier(const I2c_BuckConverter_Domain* domain, u32 mvolt) {
     u32 uvolt = mvolt * 1000;
     if (uvolt < domain->uv_min)
@@ -129,6 +133,22 @@ u32 I2c_BuckConverter_GetMvOut(const I2c_BuckConverter_Domain* domain) {
     return I2c_BuckConverter_MultiplierToMvOut(domain, val & domain->volt_mask);
 }
 
+u32 I2c_BuckConverter_GetUvOut(const I2c_BuckConverter_Domain* domain) {
+    u8 val;
+    // Retry 5 times if received POR value
+    for (int i = 0; i < 5; i++) {
+        if (R_FAILED(I2cRead_OutU8(domain->device, domain->reg, &val)))
+            return 0u;
+
+        // Wait 1us
+        svcSleepThread(1E3);
+
+        if (!domain->por_val || val != domain->por_val)
+            break;
+    }
+    return I2c_BuckConverter_MultiplierToUvOut(domain, val & domain->volt_mask);
+}
+
 Result I2c_BuckConverter_SetMvOut(const I2c_BuckConverter_Domain* domain, u32 mvolt) {
     u8 val;
     Result res = I2cRead_OutU8(domain->device, domain->reg, &val);

Source/hoc-clk/sysmodule/src/i2c/i2cDrv.h

@@ -21,6 +21,7 @@ const u8 MAX17050_CURRENT_REG = 0x0A;
 
 // Buck Converter
 typedef enum I2c_BuckConverter_Reg {
+    I2c_Max77620_SD0VOLT_REG = 0x16,
     I2c_Max77620_SD1VOLT_REG = 0x17, // Used for Erista DDR VDDQ+VDD2 / Mariko VDD2
     I2c_Max77620_LDO0VOLT_REG = 0x23, // Used for Erista DDR VDDQ+VDD2 / Mariko VDD2
     I2c_Max77621_VOLT_REG    = 0x00,
@@ -39,16 +40,17 @@ typedef struct I2c_BuckConverter_Domain {
     u8 por_val;
 } I2c_BuckConverter_Domain;
 
+const I2c_BuckConverter_Domain I2c_SOC              = { I2cDevice_Max77620Pmic, I2c_Max77620_SD0VOLT_REG, 0x7F, 12500, 600000, 1400000, };
+const I2c_BuckConverter_Domain I2c_VDD2             = { I2cDevice_Max77620Pmic, I2c_Max77620_SD1VOLT_REG, 0x7F, 12500, 600000, 1350000, };
+const I2c_BuckConverter_Domain I2c_Display          = { I2cDevice_Max77620Pmic, I2c_Max77620_LDO0VOLT_REG, 0x3F,  25000, 800000,  1325000, };
 const I2c_BuckConverter_Domain I2c_Erista_CPU       = { I2cDevice_Max77621Cpu,  I2c_Max77621_VOLT_REG,    0x7F,  6250, 606250, 1400000, };
 const I2c_BuckConverter_Domain I2c_Erista_GPU       = { I2cDevice_Max77621Gpu,  I2c_Max77621_VOLT_REG,    0x7F,  6250, 606250, 1400000, };
-const I2c_BuckConverter_Domain I2c_Erista_DRAM      = { I2cDevice_Max77620Pmic, I2c_Max77620_SD1VOLT_REG, 0x3F, 12500, 600000, 1250000, };
-const I2c_BuckConverter_Domain I2c_Display          = { I2cDevice_Max77620Pmic, I2c_Max77620_LDO0VOLT_REG, 0x7F,  25000, 800000,  1325000, };
 const I2c_BuckConverter_Domain I2c_Mariko_CPU       = { I2cDevice_Max77812_2,   I2c_Max77812_CPUVOLT_REG, 0xFF,  5000, 250000, 1525000, 0x78 };
 const I2c_BuckConverter_Domain I2c_Mariko_GPU       = { I2cDevice_Max77812_2,   I2c_Max77812_GPUVOLT_REG, 0xFF,  5000, 250000, 1525000, 0x78 };
 const I2c_BuckConverter_Domain I2c_Mariko_DRAM_VDDQ = { I2cDevice_Max77812_2,   I2c_Max77812_MEMVOLT_REG, 0xFF,  5000, 250000,  700000, 0x78 };
-const I2c_BuckConverter_Domain I2c_Mariko_DRAM_VDD2 = { I2cDevice_Max77620Pmic, I2c_Max77620_SD1VOLT_REG, 0x7F, 12500, 600000, 1250000, };
 
 u32 I2c_BuckConverter_GetMvOut(const I2c_BuckConverter_Domain* domain);
+u32 I2c_BuckConverter_GetUvOut(const I2c_BuckConverter_Domain* domain);
 Result I2c_BuckConverter_SetMvOut(const I2c_BuckConverter_Domain* domain, u32 mvolt);
 
 // Bq24193 Battery management

Source/hoc-clk/sysmodule/src/main.cpp

@@ -38,7 +38,7 @@
 #include "ipc/ipc_service.hpp"
 #include "file/config.hpp"
 
-#define INNER_HEAP_SIZE 0x3A000
+#define INNER_HEAP_SIZE 0x40000
 
 extern "C"
 {

Source/hoc-clk/sysmodule/src/mgr/clock_manager.cpp

@@ -252,7 +252,6 @@ namespace clockManager {
             return;
         }
     }
-
     void HandleMiscFeatures()
     {
         // these dont need to run that often, so dont bother
@@ -381,7 +380,6 @@ namespace clockManager {
             board::SetHz(HocClkModule_CPU, board::GetHz(HocClkModule_CPU));
             prepareBoostExit = false;
         }
-
         bool returnRaw = false; // Return a value scaled to MHz instead of raw value
         for (unsigned int module = 0; module < HocClkModule_EnumMax; module++) {
             u32 oldHz = board::GetHz((HocClkModule)module); // Get Old hz (used primarily for DVFS Logic)
@@ -715,8 +713,9 @@ namespace clockManager {
 
         HandleSafetyFeatures();
         HandleMiscFeatures();
-
-        if (RefreshContext() || config::Refresh()) {
+        
+        // GPU clock should always be the same unless PCV has overwriten our change, so reset it
+        if (RefreshContext() || config::Refresh() || board::GetRealHz(HocClkModule_GPU) != gContext.freqs[HocClkModule_GPU]) {
             SetClocks(isBoost);
         }
     }

Source/scripts/convert_dvb.cpp

@@ -0,0 +1,98 @@
+#include <cstdio>
+#include <cstdint>
+#include <iterator>
+
+typedef uint32_t u32;
+typedef int32_t s32;
+
+struct DvbEntry {
+    u32 freq;
+    u32 volts[3];
+};
+
+DvbEntry oldDvbTable[] = {
+    {  204000, { 637, 637, 637, }, },
+    { 1331200, { 650, 637, 637, }, },
+    { 1600000, { 675, 650, 637, }, },
+    { 1866000, { 700, 675, 650, }, },
+    { 2133000, { 725, 700, 675, }, },
+    { 2400000, { 750, 725, 700, }, },
+    { 2666000, { 775, 750, 725, }, },
+    { 2933000, { 800, 775, 750, }, },
+    { 3200000, { 800, 800, 775, }, },
+    {     ~0u, {                }, },
+};
+
+DvbEntry newDvbTable[] = {
+    {  204000, {  637,  637,  637, }, },
+    { 1331200, {  650,  637,  637, }, },
+    { 1600000, {  675,  650,  637, }, },
+    { 1866000, {  700,  675,  650, }, },
+    { 2133000, {  725,  700,  675, }, },
+    { 2400000, {  750,  725,  700, }, },
+    { 2666000, {  850,  825,  800, }, },
+    { 2933000, {  950,  925,  900, }, },
+    { 3200000, { 1050, 1025, 1000, }, },
+    {     ~0u, {                   }, },
+};
+
+constexpr u32 DvbTableSize = std::size(oldDvbTable);
+
+u32 PrintAndScan(const char *message) {
+    u32 scanV;
+    printf("%s: ", message);
+    scanf("%i", &scanV);
+    return scanV;
+}
+
+u32 GetProcessId(u32 speedo) {
+    if (speedo <= 1597) {
+        return 0;
+    }
+
+    if (speedo <= 1708) {
+        return 1;
+    }
+
+    /* >= 1709. */
+    return 2;
+}
+
+u32 GetVoltageAndIndex(u32 dvbShift, u32 emc, u32 processId, DvbEntry *dvbTable, u32 &index) {
+    for (u32 i = 0; i < DvbTableSize - 1; ++i) {
+        if (emc < dvbTable[i].freq || emc >= dvbTable[i + 1].freq) {
+            continue;
+        }
+
+        index = i;
+        return dvbTable[i].volts[processId] + (25 * dvbShift);
+    }
+
+    return 0;
+}
+
+s32 GetShift(u32 oldVoltage, u32 processId, DvbEntry *dvbTable, u32 index) {
+    return (static_cast<s32>(oldVoltage) - static_cast<s32>(dvbTable[index].volts[processId])) / 25;
+}
+
+int main() {
+    u32 oldDvb    = PrintAndScan("Enter old dvb shift");
+    u32 emcMaxMhz = PrintAndScan("Enter max ram freq (MHz)");
+    u32 speedo    = PrintAndScan("Enter soc speedo");
+
+    u32 emcMaxKhz = emcMaxMhz * 1000;
+    u32 processId = GetProcessId(speedo);
+
+    #define INVALID_TABLE_INDEX 32
+    u32 tableIndex = INVALID_TABLE_INDEX;
+    u32 oldVoltage = GetVoltageAndIndex(oldDvb, emcMaxKhz, processId, oldDvbTable, tableIndex);
+
+    if (oldVoltage == 0 || tableIndex == INVALID_TABLE_INDEX) {
+        printf("Invalid values!\n");
+        return -1;
+    }
+
+    s32 newShift = GetShift(oldVoltage, processId, newDvbTable, tableIndex);
+
+    printf("New dvb table shift: %d", newShift);
+}

Source/scripts/convert_dvb.py

@@ -0,0 +1,120 @@
+from dataclasses import dataclass
+from typing import List
+
+
+u32 = int
+s32 = int
+
+
+@dataclass
+class DvbEntry:
+    freq: u32
+    volts: List[u32]
+
+
+oldDvbTable = [
+    DvbEntry(204000,  [637, 637, 637]),
+    DvbEntry(1331200, [650, 637, 637]),
+    DvbEntry(1600000, [675, 650, 637]),
+    DvbEntry(1866000, [700, 675, 650]),
+    DvbEntry(2133000, [725, 700, 675]),
+    DvbEntry(2400000, [750, 725, 700]),
+    DvbEntry(2666000, [775, 750, 725]),
+    DvbEntry(2933000, [800, 775, 750]),
+    DvbEntry(3200000, [800, 800, 775]),
+    DvbEntry(0xFFFFFFFF,      []),
+]
+
+newDvbTable = [
+    DvbEntry(204000,  [637, 637, 637]),
+    DvbEntry(1331200, [650, 637, 637]),
+    DvbEntry(1600000, [675, 650, 637]),
+    DvbEntry(1866000, [700, 675, 650]),
+    DvbEntry(2133000, [725, 700, 675]),
+    DvbEntry(2400000, [750, 725, 700]),
+    DvbEntry(2666000, [850, 825, 800]),
+    DvbEntry(2933000, [950, 925, 900]),
+    DvbEntry(3200000, [1050, 1025, 1000]),
+    DvbEntry(0xFFFFFFFF,      []),
+]
+
+DVB_TABLE_SIZE = len(oldDvbTable)
+INVALID_TABLE_INDEX = 32
+
+
+def print_and_scan(message: str) -> u32:
+    return int(input(f"{message}: "))
+
+
+def get_process_id(speedo: u32) -> u32:
+    if speedo <= 1597:
+        return 0
+
+    if speedo <= 1708:
+        return 1
+
+    # >= 1709
+    return 2
+
+
+def get_voltage_and_index(
+    dvb_shift: u32,
+    emc: u32,
+    process_id: u32,
+    dvb_table: List[DvbEntry],
+):
+    for i in range(DVB_TABLE_SIZE - 1):
+        if emc < dvb_table[i].freq or emc >= dvb_table[i + 1].freq:
+            continue
+
+        voltage = dvb_table[i].volts[process_id] + (25 * dvb_shift)
+        return voltage, i
+
+    return 0, INVALID_TABLE_INDEX
+
+
+def get_shift(
+    old_voltage: u32,
+    process_id: u32,
+    dvb_table: List[DvbEntry],
+    index: u32,
+) -> s32:
+    return (
+        int(old_voltage)
+        - int(dvb_table[index].volts[process_id])
+    ) // 25
+
+
+def main():
+    old_dvb = print_and_scan("Enter old dvb shift")
+    emc_max_mhz = print_and_scan("Enter max ram freq (MHz)")
+    speedo = print_and_scan("Enter soc speedo")
+
+    emc_max_khz = emc_max_mhz * 1000
+    process_id = get_process_id(speedo)
+
+    table_index = INVALID_TABLE_INDEX
+
+    old_voltage, table_index = get_voltage_and_index(
+        old_dvb,
+        emc_max_khz,
+        process_id,
+        oldDvbTable,
+    )
+
+    if old_voltage == 0 or table_index == INVALID_TABLE_INDEX:
+        print("Invalid values!")
+        return -1
+
+    new_shift = get_shift(
+        old_voltage,
+        process_id,
+        newDvbTable,
+        table_index,
+    )
+
+    print(f"New dvb table shift: {new_shift}")
+
+
+if __name__ == "__main__":
+    main()

dist/README.md

@@ -1,214 +0,0 @@
-
-<div align="center">
-
-<img src="assets/logo.png" alt="logo" width="768"/>
-
----
-
-![License: GPL-2.0](https://img.shields.io/badge/GPL--2.0-red?style=for-the-badge)
-![Nintendo Switch](https://img.shields.io/badge/Nintendo_Switch-E60012?style=for-the-badge\&logo=nintendo-switch\&logoColor=white)
-[![Discord](https://img.shields.io/badge/Discord-5865F2?style=for-the-badge\&logo=discord\&logoColor=white)](https://dsc.gg/horizonoc)
-![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/Horizon-OC/Horizon-OC/total.svg?style=for-the-badge)
-
----
-
-</div>
-
-## ⚠️ Disclaimer
-
-> **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.
-
----
-
-## About
-
-**Horizon OC** is an open-source overclocking tool for Nintendo Switch consoles running **Atmosphere custom firmware**.
-It enables advanced CPU, GPU, and RAM tuning with user-friendly configuration tools.
-
----
-
-## Default clocks
-
-* **CPU:** Up to 1963MHz (Mariko) / 1785MHz (Erista)
-* **GPU:** Up to 1075MHz (Mariko) / 921MHz (Erista)
-* **RAM:** Up to 1866/2133MHz (Mariko) / 1600MHz (Erista)
-* Over/undervolting support
-* Built-in configurator
-* Compatible with most homebrew
-
-> It is recommended to read the [guide](https://rentry.co/howtoget60fps) before proceeding, as this can help you get a *significant* performance boost over the default settings, often times with less power draw and heat output
-
----
-
-## Installation
-
-1. Ensure you have the latest versions of
-
-   * [Atmosphere](https://github.com/Atmosphere-NX/Atmosphere)
-   * [Ultrahand Overlay](https://github.com/ppkantorski/Ultrahand-Overlay)
-2. Download and extract the **Horizon OC Package** to the root of your SD card.
-3. If using **Hekate**, edit `hekate_ipl.ini` to include:
-
-   ```
-   kip1=atmosphere/kips/hoc.kip
-   ```
-
-   *(No changes needed if using fusee.)*
-
----
-
-## Configuration
-
-1. Open the Horizon OC Overlay
-2. Open the settings menu
-3. Adjust your overclocking settings as desired. A helpful guide can be found [here.](https://rentry.co/mariko#oc-settings-for-horizon-oc)
-4. Click **Save KIP Settings** to apply your configuration.
-
----
-
-## Building from Source
-
-Refer to COMPILATION.md
-
----
-## Clock table
-
-### 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.
-* 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 (mhz)
-* 2703 → mariko absolute max, dangerous
-* 2601 → unsafe
-* 2499
-* 2397 → mariko safe max with UV (low speedo)
-* 2295
-* 2193
-* 2091
-* 1963 → mariko no UV max clock
-* 1887
-* 1785 → erista no UV max clock, boost mode
-* 1683
-* 1581
-* 1428
-* 1326
-* 1224 → sdev oc
-* 1122
-* 1020 → official docked & handheld
-* 918
-* 816
-* 714
-* 612 → sleep mode
-
-### GPU clocks (mhz)
-* 1536 → absolute max clock on mariko. very dangerous
-* 1459
-* 1382
-* 1305
-* 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
-* 691
-* 614
-* 537
-* 460 → max handheld
-* 384 → official handheld
-* 307 → official handheld
-* 230
-* 153
-* 76 → boost mode
-
-**Notes:**
-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, hoc-clk development, guides
-* **TDRR** - HOC Logo Design
-* **tetetete-ctrl** - Website design
-* **SciresM** - Atmosphere CFW
-* **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
-* **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
-* **Nvidia** - [Tegra X1 Technical Reference Manual](https://developer.nvidia.com/embedded/dlc/tegra-x1-technical-reference-manual), soctherm driver, L4T

dist/config/horizon-oc/lang/es.json

@@ -2,140 +2,140 @@
     "Information": "Información",
     "IDDQ:": "IDDQ:",
     "Module: ": "Módulo:",
-    "sys-dock status:": "Estado de sys-dock:",
+    "sys-dock status:": "estado del sys-dock:",
     "SaltyNX status:": "Estado de SaltyNX:",
-    "RR Display status:": "Estado de pantalla RR:",
-    "Wafer Position:": "Posición del wafer:",
+    "RR Display status:": "Estado de visualización RR:",
+    "Wafer Position:": "Posición de la oblea:",
     "Credits": "Créditos",
     "Developers": "Desarrolladores",
     "Contributors": "Colaboradores",
-    "Testers": "Testers",
-    "Special Thanks": "Agradecimientos especiales",
+    "Testers": "Probadores",
+    "Special Thanks": "agradecimiento especial",
     "Unknown": "Desconocido",
     "Installed": "Instalado",
     "Not Installed": "No instalado",
     "X: %u Y: %u": "X: %u Y: %u",
-    "THE BEER-WARE LICENSE": "LICENCIA BEER-WARE",
+    "THE BEER-WARE LICENSE": "LA LICENCIA DE CERVEZA",
     "Default": "Predeterminado",
-    "Do Not Override": "No sobrescribir",
-    "Disabled": "Desactivado",
-    "Enabled": "Activado",
+    "Do Not Override": "No anular",
+    "Disabled": "Discapacitado",
+    "Enabled": "Habilitado",
     " \\ue0e3 Reset": "\\ue0e3 Restablecer",
     "Display": "Pantalla",
-    "Application changed\\n\\n": "Aplicación cambiada\\n\\n",
-    "The running application changed\\n\\n": "La aplicación en ejecución ha cambiado\\n\\n",
-    "while editing was going on.": "mientras se estaba editando.",
-    "Board": "Placa",
+    "Application changed\\n\\n": "Aplicación modificada\\n\\n",
+    "The running application changed\\n\\n": "La aplicación en ejecución cambió\\n\\n",
+    "while editing was going on.": "mientras se realizaba la edición.",
+    "Board": "tablero",
     "%u.%u%u mV": "%u.%u%u mV",
-    "Could not connect to hoc-clk sysmodule.\\n\\n": "No se pudo conectar al sysmodule hoc-clk.\\n\\n",
-    "Please make sure everything is\\n\\n": "Asegúrate de que todo esté\\n\\n",
-    "correctly installed and enabled.": "correctamente instalado y activado.",
-    "Fatal error": "Error fatal",
-    "Temporary Overrides ": "Ajustes temporales",
-    "Sleep Mode": "Modo reposo",
-    "Stock": "Valores de fábrica",
-    "Dev OC": "OC de desarrollo",
-    "Boost Mode": "Modo boost",
+    "Could not connect to hoc-clk sysmodule.\\n\\n": "No se pudo conectar al módulo del sistema hoc-clk.\\n\\n",
+    "Please make sure everything is\\n\\n": "Por favor asegúrese de que todo esté\\n\\n",
+    "correctly installed and enabled.": "correctamente instalado y habilitado.",
+    "Fatal error": "error fatal",
+    "Temporary Overrides ": "Anulaciones temporales",
+    "Sleep Mode": "Modo de suspensión",
+    "Stock": "Valores",
+    "Dev OC": "Desarrollador OC",
+    "Boost Mode": "Modo de impulso",
     "Safe Max": "Máximo seguro",
-    "Unsafe Max": "Máximo no seguro",
+    "Unsafe Max": "Máximo inseguro",
     "Absolute Max": "Máximo absoluto",
-    "Handheld Safe Max": "Máximo seguro en portátil",
-    "Enable": "Activar",
+    "Handheld Safe Max": "Caja fuerte de mano máx.",
+    "Enable": "Habilitar",
     "Edit App Profile": "Editar perfil de aplicación",
     "Edit Global Profile": "Editar perfil global",
-    "Temporary Overrides": "Ajustes temporales",
+    "Temporary Overrides": "Anulaciones temporales",
     "Settings": "Configuración",
     "About": "Acerca de",
-    "Compiling with minimal features": "Compilado con funciones mínimas",
-    "General Settings": "Configuración general",
-    "Governor Settings": "Configuración del governor",
-    "Safety Settings": "Configuración de seguridad",
-    "Save KIP Settings": "Guardar configuración KIP",
+    "Compiling with minimal features": "Compilando con características mínimas",
+    "General Settings": "Configuraciones generales",
+    "Governor Settings": "Configuración del gobernador",
+    "Safety Settings": "Configuraciones de seguridad",
+    "Save KIP Settings": "Guardar configuración de KIP",
     "RAM Settings": "Configuración de RAM",
-    "CPU Settings": "Configuración de CPU",
+    "CPU Settings": "Configuración de la CPU",
     "GPU Settings": "Configuración de GPU",
     "Display Settings": "Configuración de pantalla",
     "Experimental": "Experimental",
-    "GPU Scheduling Override Method": "Método de sobrescritura del scheduling de GPU",
-    "can be dangerous and may cause": "puede ser peligroso y causar",
-    "damage to your battery or charger!": "daños a la batería o al cargador.",
-    "Charge Current Override": "Sobrescritura de corriente de carga",
+    "GPU Scheduling Override Method": "Método de anulación de programación de GPU",
+    "can be dangerous and may cause": "puede ser peligroso y puede causar",
+    "damage to your battery or charger!": "¡Daños a su batería o cargador!",
+    "Charge Current Override": "Anulación de corriente de carga",
     "RAM Voltage Display Mode": "Modo de visualización de voltaje de RAM",
     "Polling Interval": "Intervalo de sondeo",
-    "CPU Governor Minimum Frequency": "Frecuencia mínima del governor de CPU",
-    "refresh rates may cause stress": "las tasas de refresco pueden causar estrés",
-    "or damage to your display! ": "o dañar la pantalla.",
-    "Proceed at your own risk!": "¡Úsalo bajo tu propio riesgo!",
-    "Max Handheld Display": "Frecuencia máxima de pantalla en portátil",
-    "Display Clock": "Frecuencia de pantalla",
-    "Official Rating": "Valor oficial",
+    "CPU Governor Minimum Frequency": "Frecuencia mínima del gobernador de CPU",
+    "refresh rates may cause stress": "Las frecuencias de actualización pueden causar estrés.",
+    "or damage to your display! ": "o daños a su pantalla!",
+    "Proceed at your own risk!": "¡Continúe bajo su propio riesgo!",
+    "Max Handheld Display": "Pantalla portátil máxima",
+    "Display Clock": "Reloj de pantalla",
+    "Official Rating": "Calificación oficial",
     "TDP Threshold": "Umbral de TDP",
-    "Power": "Potencia",
-    "Thermal Throttle Limit": "Límite de thermal throttling",
-    "HP Mode": "Modo alto rendimiento",
+    "Power": "poder",
+    "Thermal Throttle Limit": "Límite del acelerador térmico",
+    "HP Mode": "Modo HP",
     "Default (Mariko)": "Predeterminado (Mariko)",
     "Default (Erista)": "Predeterminado (Erista)",
-    "Rating": "Valor",
-    "Safe Max (Mariko)": "Máximo seguro (Mariko)",
-    "Safe Max (Erista)": "Máximo seguro (Erista)",
-    "RAM VDD2 Voltage": "Voltaje VDD2 de RAM",
-    "Voltage": "Voltaje",
-    "RAM VDDQ Voltage": "Voltaje VDDQ de RAM",
-    "RAM Frequency Editor": "Editor de frecuencia de RAM",
-    "JEDEC.": "JEDEC",
-    "High speedo needed!": "¡Se necesita alto speedo!",
-    "3333MHz (Needs extreme Speedo/PLL)": "3333MHz (requiere Speedo/PLL extremo)",
-    "3366MHz (Needs extreme Speedo/PLL)": "3366MHz (requiere Speedo/PLL extremo)",
-    "3400MHz (Needs extreme Speedo/PLL)": "3400MHz (requiere Speedo/PLL extremo)",
-    "3433MHz (Needs ridiculous Speedo/PLL)": "3433MHz (requiere Speedo/PLL muy alto)",
-    "3466MHz (Needs ridiculous Speedo/PLL)": "3466MHz (requiere Speedo/PLL muy alto)",
-    "3500MHz (Needs ridiculous Speedo/PLL)": "3500MHz (requiere Speedo/PLL muy alto)",
-    "Ram Max Clock": "Frecuencia máxima de RAM",
-    "RAM Latency Editor": "Editor de latencias de RAM",
-    "RAM Timing Reductions": "Reducción de timings de RAM",
-    "Memory Timings": "Timings de memoria",
+    "Rating": "Calificación",
+    "Safe Max (Mariko)": "Max seguro (Mariko)",
+    "Safe Max (Erista)": "Safe Max (Erista)",
+    "RAM VDD2 Voltage": "Voltaje RAM VDD2",
+    "Voltage": "voltaje",
+    "RAM VDDQ Voltage": "Voltaje RAM VDDQ",
+    "RAM Frequency Editor": "Editor de frecuencia RAM",
+    "JEDEC.": "JEDEC.",
+    "High speedo needed!": "¡Se necesita alta velocidad!",
+    "3333MHz (Needs extreme Speedo/PLL)": "3333MHz (Necesita Speedo/PLL extremo)",
+    "3366MHz (Needs extreme Speedo/PLL)": "3366MHz (Necesita Speedo/PLL extremo)",
+    "3400MHz (Needs extreme Speedo/PLL)": "3400MHz (Necesita Speedo/PLL extremo)",
+    "3433MHz (Needs ridiculous Speedo/PLL)": "3433MHz (Necesita Speedo/PLL ridículo)",
+    "3466MHz (Needs ridiculous Speedo/PLL)": "3466MHz (Necesita Speedo/PLL ridículo)",
+    "3500MHz (Needs ridiculous Speedo/PLL)": "3500MHz (Necesita Speedo/PLL ridículo)",
+    "Ram Max Clock": "Ram Max Reloj",
+    "RAM Latency Editor": "Editor de latencia de RAM",
+    "RAM Timing Reductions": "Reducciones de tiempo de RAM",
+    "Memory Timings": "Tiempos de memoria",
     "Advanced": "Avanzado",
-    "t6 tRTW Fine Tune": "Ajuste fino t6 tRTW",
+    "t6 tRTW Fine Tune": "t6 tRTW Ajuste fino",
     "tRTW Fine Tune": "Ajuste fino tRTW",
-    "t7 tWTR Fine Tune": "Ajuste fino t7 tWTR",
-    "tWTR Fine Tune": "Ajuste fino tWTR",
-    "Memory Latencies": "Latencias de memoria",
-    "Read Latency": "Latencia de lectura",
+    "t7 tWTR Fine Tune": "t7 tWTR Ajuste fino",
+    "tWTR Fine Tune": "Ajuste fino de tWTR",
+    "Memory Latencies": "Latencias de la memoria",
+    "Read Latency": "Leer latencia",
     "Write Latency": "Latencia de escritura",
-    "CPU Boost Clock": "Frecuencia boost de CPU",
-    "CPU UV": "Undervolt de CPU",
+    "CPU Boost Clock": "Reloj de aumento de CPU",
+    "CPU UV": "procesador ultravioleta",
     "CPU Unlock": "Desbloqueo de CPU",
-    "CPU VMIN": "VMIN de CPU",
-    "CPU Max Voltage": "Voltaje máximo de CPU",
-    "CPU Max Clock": "Frecuencia máxima de CPU",
-    "Extreme UV Table": "Tabla de undervolt extrema",
-    "CPU UV Table": "Tabla de undervolt de CPU",
-    "CPU Low UV": "Undervolt bajo de CPU",
-    "CPU High UV": "Undervolt alto de CPU",
+    "CPU VMIN": "CPU VMIN",
+    "CPU Max Voltage": "Voltaje máximo de la CPU",
+    "CPU Max Clock": "Reloj máximo de CPU",
+    "Extreme UV Table": "Mesa UV extrema",
+    "CPU UV Table": "Tabla UV de CPU",
+    "CPU Low UV": "CPU baja radiación ultravioleta",
+    "CPU High UV": "CPU alta UV",
     "CPU Low VMIN": "VMIN bajo de CPU",
     "CPU High VMIN": "VMIN alto de CPU",
-    "No Undervolt": "Sin undervolt",
-    "SLT Table": "Tabla SLT",
+    "No Undervolt": "Sin subvoltaje",
+    "SLT Table": "Mesa TR",
     "HiOPT Table": "Tabla HiOPT",
-    "GPU Undervolt Table": "Tabla de undervolt de GPU",
+    "GPU Undervolt Table": "Tabla de subvoltaje de GPU",
     "GPU Minimum Voltage": "Voltaje mínimo de GPU",
-    "Calculate GPU Vmin": "Calcular Vmin de GPU",
-    "GPU VMIN": "VMIN de GPU",
+    "Calculate GPU Vmin": "Calcular GPU Vmin",
+    "GPU VMIN": "GPU VMIN",
     "GPU Maximum Voltage": "Voltaje máximo de GPU",
-    "GPU Voltage Offset": "Offset de voltaje de GPU",
-    "Do not override": "No sobrescribir",
-    "Enabled (Default)": "Activado (predeterminado)",
-    "96.6% limit": "Límite 96,6%",
-    "99.7% limit": "Límite 99,7%",
-    "GPU Scheduling Override": "Sobrescritura de scheduling de GPU",
-    "Official Service": "Servicio oficial",
-    "GPU DVFS Mode": "Modo DVFS de GPU",
-    "GPU DVFS Offset": "Offset DVFS de GPU",
+    "GPU Voltage Offset": "Compensación de voltaje de GPU",
+    "Do not override": "no anular",
+    "Enabled (Default)": "Habilitado (predeterminado)",
+    "96.6% limit": "límite del 96,6%",
+    "99.7% limit": "límite del 99,7%",
+    "GPU Scheduling Override": "Anulación de programación de GPU",
+    "Official Service": "Servicio Oficial",
+    "GPU DVFS Mode": "Modo GPU DVFS",
+    "GPU DVFS Offset": "Compensación DVFS de GPU",
     "GPU Voltage Table": "Tabla de voltaje de GPU",
     "GPU Custom Table (mV)": "Tabla personalizada de GPU (mV)",
-    "1075MHz without UV, 1152MHz on SLT": "1075MHz sin undervolt, 1152MHz en SLT",
-    "or 1228MHz on HiOPT can cause ": "o 1228MHz en HiOPT pueden causar ",
-    "permanent damage to your Switch!": "¡daño permanente a tu Switch!",
-    "921MHz without UV and 960MHz on": "921MHz sin undervolt y 960MHz en",
-    "SLT or HiOPT can cause ": "SLT o HiOPT pueden causar "
-}
+    "1075MHz without UV, 1152MHz on SLT": "1075MHz sin UV, 1152MHz en SLT",
+    "or 1228MHz on HiOPT can cause ": "o 1228MHz en HiOPT pueden causar",
+    "permanent damage to your Switch!": "¡Daño permanente a tu Switch!",
+    "921MHz without UV and 960MHz on": "921MHz sin UV y 960MHz encendido",
+    "SLT or HiOPT can cause ": "SLT o HiOPT pueden causar"
+}

dist/config/horizon-oc/lang/fr.json

@@ -1,11 +1,11 @@
 {
     "Information": "Informations",
-    "IDDQ:": "IDDQ :",
-    "Module: ": "Module :",
-    "sys-dock status:": "Statut de sys-dock :",
-    "SaltyNX status:": "Statut de SaltyNX :",
-    "RR Display status:": "Statut de l'affichage RR :",
-    "Wafer Position:": "Position du wafer :",
+    "IDDQ:": "IDDQ :",
+    "Module: ": "Module :",
+    "sys-dock status:": "état du dock système :",
+    "SaltyNX status:": "Statut SaltyNX :",
+    "RR Display status:": "Etat d'affichage RR :",
+    "Wafer Position:": "Position de la plaquette :",
     "Credits": "Crédits",
     "Developers": "Développeurs",
     "Contributors": "Contributeurs",
@@ -15,127 +15,127 @@
     "Installed": "Installé",
     "Not Installed": "Non installé",
     "X: %u Y: %u": "X : %u Y : %u",
-    "THE BEER-WARE LICENSE": "LA LICENCE BEER-WARE",
+    "THE BEER-WARE LICENSE": "LA LICENCE DE LA BIÈRE",
     "Default": "Par défaut",
     "Do Not Override": "Ne pas remplacer",
     "Disabled": "Désactivé",
     "Enabled": "Activé",
     " \\ue0e3 Reset": "\\ue0e3 Réinitialiser",
-    "Display": "Écran",
+    "Display": "Affichage",
     "Application changed\\n\\n": "Application modifiée\\n\\n",
     "The running application changed\\n\\n": "L'application en cours d'exécution a changé\\n\\n",
-    "while editing was going on.": "pendant la modification.",
-    "Board": "Carte",
+    "while editing was going on.": "pendant le montage.",
+    "Board": "Conseil",
     "%u.%u%u mV": "%u.%u%u mV",
-    "Could not connect to hoc-clk sysmodule.\\n\\n": "Impossible de se connecter au sysmodule hoc-clk.\\n\\n",
+    "Could not connect to hoc-clk sysmodule.\\n\\n": "Impossible de se connecter au module système hoc-clk.\\n\\n",
     "Please make sure everything is\\n\\n": "Veuillez vous assurer que tout est\\n\\n",
     "correctly installed and enabled.": "correctement installé et activé.",
     "Fatal error": "Erreur fatale",
-    "Temporary Overrides ": "Forçages temporaires ",
+    "Temporary Overrides ": "Remplacements temporaires",
     "Sleep Mode": "Mode veille",
-    "Stock": "D'origine",
-    "Dev OC": "OC Développeur",
+    "Stock": "Actions",
+    "Dev OC": "Développeur OC",
     "Boost Mode": "Mode Boost",
-    "Safe Max": "Max sûr",
-    "Unsafe Max": "Max non sûr",
+    "Safe Max": "Coffre-fort maximum",
+    "Unsafe Max": "Dangereux Max",
     "Absolute Max": "Max absolu",
-    "Handheld Safe Max": "Max sûr (mode portable)",
+    "Handheld Safe Max": "Coffre-fort portatif Max",
     "Enable": "Activer",
-    "Edit App Profile": "Modifier le profil de l'app",
+    "Edit App Profile": "Modifier le profil de l'application",
     "Edit Global Profile": "Modifier le profil global",
-    "Temporary Overrides": "Forçages temporaires",
+    "Temporary Overrides": "Remplacements temporaires",
     "Settings": "Paramètres",
     "About": "À propos",
-    "Compiling with minimal features": "Compilation avec fonctionnalités minimales",
+    "Compiling with minimal features": "Compilation avec des fonctionnalités minimales",
     "General Settings": "Paramètres généraux",
     "Governor Settings": "Paramètres du gouverneur",
     "Safety Settings": "Paramètres de sécurité",
     "Save KIP Settings": "Enregistrer les paramètres KIP",
-    "RAM Settings": "Paramètres RAM",
-    "CPU Settings": "Paramètres CPU",
-    "GPU Settings": "Paramètres GPU",
+    "RAM Settings": "Paramètres de la RAM",
+    "CPU Settings": "Paramètres du processeur",
+    "GPU Settings": "Paramètres du processeur graphique",
     "Display Settings": "Paramètres d'affichage",
     "Experimental": "Expérimental",
-    "GPU Scheduling Override Method": "Méthode de Forçage de l'ordonnancement GPU",
-    "can be dangerous and may cause": "peut être dangereux et causer des",
-    "damage to your battery or charger!": "dommages à votre batterie ou chargeur !",
-    "Charge Current Override": "Forçage du courant de charge",
-    "RAM Voltage Display Mode": "Mode d'affichage de la tension RAM",
+    "GPU Scheduling Override Method": "Méthode de remplacement de la planification GPU",
+    "can be dangerous and may cause": "peut être dangereux et provoquer",
+    "damage to your battery or charger!": "dommages à votre batterie ou à votre chargeur !",
+    "Charge Current Override": "Remplacement du courant de charge",
+    "RAM Voltage Display Mode": "Mode d'affichage de la tension de la RAM",
     "Polling Interval": "Intervalle d'interrogation",
-    "CPU Governor Minimum Frequency": "Fréquence minimale du gouverneur CPU",
-    "refresh rates may cause stress": "les taux de rafraîchissement peuvent stresser",
-    "or damage to your display! ": "ou endommager votre écran !",
-    "Proceed at your own risk!": "À utiliser à vos propres risques !",
-    "Max Handheld Display": "Affichage portable max",
-    "Display Clock": "Fréquence d'affichage",
+    "CPU Governor Minimum Frequency": "Fréquence minimale du gouverneur du processeur",
+    "refresh rates may cause stress": "les taux de rafraîchissement peuvent causer du stress",
+    "or damage to your display! ": "ou endommager votre écran !",
+    "Proceed at your own risk!": "Procédez à vos propres risques !",
+    "Max Handheld Display": "Affichage portable maximum",
+    "Display Clock": "Affichage de l'horloge",
     "Official Rating": "Classement officiel",
     "TDP Threshold": "Seuil TDP",
-    "Power": "Alimentation",
-    "Thermal Throttle Limit": "Limite d'étranglement thermique",
+    "Power": "Puissance",
+    "Thermal Throttle Limit": "Limite d'accélérateur thermique",
     "HP Mode": "Mode HP",
     "Default (Mariko)": "Par défaut (Mariko)",
     "Default (Erista)": "Par défaut (Erista)",
-    "Rating": "Évaluation",
-    "Safe Max (Mariko)": "Max sûr (Mariko)",
-    "Safe Max (Erista)": "Max sûr (Erista)",
-    "RAM VDD2 Voltage": "Tension RAM VDD2",
+    "Rating": "Note",
+    "Safe Max (Mariko)": "Coffre-fort Max (Mariko)",
+    "Safe Max (Erista)": "Coffre-fort Max (Erista)",
+    "RAM VDD2 Voltage": "Tension de la RAM VDD2",
     "Voltage": "Tension",
-    "RAM VDDQ Voltage": "Tension RAM VDDQ",
+    "RAM VDDQ Voltage": "Tension VDDQ de la RAM",
     "RAM Frequency Editor": "Éditeur de fréquence RAM",
     "JEDEC.": "JEDEC.",
-    "High speedo needed!": "Speedo élevé requis !",
-    "3333MHz (Needs extreme Speedo/PLL)": "3333 MHz (nécessite Speedo/PLL extrême)",
-    "3366MHz (Needs extreme Speedo/PLL)": "3366 MHz (nécessite Speedo/PLL extrême)",
-    "3400MHz (Needs extreme Speedo/PLL)": "3400 MHz (nécessite Speedo/PLL extrême)",
-    "3433MHz (Needs ridiculous Speedo/PLL)": "3433 MHz (nécessite Speedo/PLL ridicule)",
-    "3466MHz (Needs ridiculous Speedo/PLL)": "3466 MHz (nécessite Speedo/PLL ridicule)",
-    "3500MHz (Needs ridiculous Speedo/PLL)": "3500 MHz (nécessite Speedo/PLL ridicule)",
-    "Ram Max Clock": "Fréquence RAM max",
+    "High speedo needed!": "Besoin d'un speedo haut !",
+    "3333MHz (Needs extreme Speedo/PLL)": "3333 MHz (nécessite un Speedo/PLL extrême)",
+    "3366MHz (Needs extreme Speedo/PLL)": "3366 MHz (nécessite un Speedo/PLL extrême)",
+    "3400MHz (Needs extreme Speedo/PLL)": "3400 MHz (nécessite un Speedo/PLL extrême)",
+    "3433MHz (Needs ridiculous Speedo/PLL)": "3433 MHz (nécessite un Speedo/PLL ridicule)",
+    "3466MHz (Needs ridiculous Speedo/PLL)": "3466 MHz (nécessite un Speedo/PLL ridicule)",
+    "3500MHz (Needs ridiculous Speedo/PLL)": "3500 MHz (nécessite un Speedo/PLL ridicule)",
+    "Ram Max Clock": "Ram Max Horloge",
     "RAM Latency Editor": "Éditeur de latence RAM",
-    "RAM Timing Reductions": "Réductions des timings RAM",
-    "Memory Timings": "Timings mémoire",
+    "RAM Timing Reductions": "Réductions de synchronisation de la RAM",
+    "Memory Timings": "Horaires de mémoire",
     "Advanced": "Avancé",
-    "t6 tRTW Fine Tune": "Ajustement précis t6 tRTW",
-    "tRTW Fine Tune": "Ajustement précis tRTW",
-    "t7 tWTR Fine Tune": "Ajustement précis t7 tWTR",
-    "tWTR Fine Tune": "Ajustement précis tWTR",
-    "Memory Latencies": "Latences mémoire",
+    "t6 tRTW Fine Tune": "t6 tRTW réglage fin",
+    "tRTW Fine Tune": "tRTW Réglage fin",
+    "t7 tWTR Fine Tune": "t7 tWTR réglage fin",
+    "tWTR Fine Tune": "Réglage fin du tWTR",
+    "Memory Latencies": "Latences de mémoire",
     "Read Latency": "Latence de lecture",
     "Write Latency": "Latence d'écriture",
-    "CPU Boost Clock": "Fréquence Boost CPU",
-    "CPU UV": "UV CPU",
-    "CPU Unlock": "Déverrouillage CPU",
+    "CPU Boost Clock": "Horloge d'augmentation du processeur",
+    "CPU UV": "UV du processeur",
+    "CPU Unlock": "Déverrouillage du processeur",
     "CPU VMIN": "CPU VMIN",
-    "CPU Max Voltage": "Tension CPU max",
-    "CPU Max Clock": "Fréquence CPU max",
-    "Extreme UV Table": "Table d'UV extrême",
-    "CPU UV Table": "Table d'UV CPU",
-    "CPU Low UV": "UV CPU faible",
-    "CPU High UV": "UV CPU élevé",
-    "CPU Low VMIN": "VMIN CPU faible",
-    "CPU High VMIN": "VMIN CPU élevé",
-    "No Undervolt": "Aucun Undervolt",
-    "SLT Table": "Table SLT",
-    "HiOPT Table": "Table HiOPT",
-    "GPU Undervolt Table": "Table d'undervolt GPU",
-    "GPU Minimum Voltage": "Tension GPU minimale",
-    "Calculate GPU Vmin": "Calculer Vmin GPU",
+    "CPU Max Voltage": "Tension maximale du processeur",
+    "CPU Max Clock": "Horloge maximale du processeur",
+    "Extreme UV Table": "Table UV Extrême",
+    "CPU UV Table": "Tableau UV du processeur",
+    "CPU Low UV": "CPU faible UV",
+    "CPU High UV": "CPU UV élevé",
+    "CPU Low VMIN": "CPU faible VMIN",
+    "CPU High VMIN": "Processeur VMIN élevé",
+    "No Undervolt": "Pas de sous-tension",
+    "SLT Table": "Tableau SLT",
+    "HiOPT Table": "Tableau HiOPT",
+    "GPU Undervolt Table": "Tableau de sous-tension GPU",
+    "GPU Minimum Voltage": "Tension minimale du GPU",
+    "Calculate GPU Vmin": "Calculer la Vmin du GPU",
     "GPU VMIN": "GPU VMIN",
-    "GPU Maximum Voltage": "Tension GPU maximale",
-    "GPU Voltage Offset": "Offset de tension GPU",
-    "Do not override": "Ne pas remplacer",
+    "GPU Maximum Voltage": "Tension maximale du GPU",
+    "GPU Voltage Offset": "Décalage de tension du GPU",
+    "Do not override": "Ne remplacez pas",
     "Enabled (Default)": "Activé (par défaut)",
-    "96.6% limit": "Limite de 96,6 %",
-    "99.7% limit": "Limite de 99,7 %",
-    "GPU Scheduling Override": "Forçage de l'ordonnancement GPU",
+    "96.6% limit": "Limite de 96,6 %",
+    "99.7% limit": "Limite de 99,7 %",
+    "GPU Scheduling Override": "Remplacement de la planification GPU",
     "Official Service": "Service officiel",
     "GPU DVFS Mode": "Mode GPU DVFS",
-    "GPU DVFS Offset": "Offset GPU DVFS",
-    "GPU Voltage Table": "Table de tension GPU",
-    "GPU Custom Table (mV)": "Table de GPU personnalisée (mV)",
+    "GPU DVFS Offset": "Décalage GPU DVFS",
+    "GPU Voltage Table": "Tableau de tension du GPU",
+    "GPU Custom Table (mV)": "Tableau personnalisé GPU (mV)",
     "1075MHz without UV, 1152MHz on SLT": "1075 MHz sans UV, 1152 MHz sur SLT",
-    "or 1228MHz on HiOPT can cause ": "ou 1228 MHz sur HiOPT peut causer des",
-    "permanent damage to your Switch!": "dommages permanents à votre Switch !",
-    "921MHz without UV and 960MHz on": "921 MHz sans UV et 960 MHz sur",
-    "SLT or HiOPT can cause ": "SLT ou HiOPT peuvent causer des"
+    "or 1228MHz on HiOPT can cause ": "ou 1228 MHz sur HiOPT peut provoquer",
+    "permanent damage to your Switch!": "dommages permanents à votre Switch !",
+    "921MHz without UV and 960MHz on": "921 MHz sans UV et 960 MHz activé",
+    "SLT or HiOPT can cause ": "SLT ou HiOPT peuvent provoquer"
 }

dist/config/horizon-oc/lang/it.json

@@ -2,140 +2,140 @@
     "Information": "Informazioni",
     "IDDQ:": "IDDQ:",
     "Module: ": "Modulo:",
-    "sys-dock status:": "stato di sys-dock",
+    "sys-dock status:": "stato del dock di sistema:",
     "SaltyNX status:": "Stato di SaltyNX:",
-    "RR Display status:": "Stato del RR:",
-    "Wafer Position:": "Posizione nel Wafer:",
+    "RR Display status:": "Stato di visualizzazione RR:",
+    "Wafer Position:": "Posizione del wafer:",
     "Credits": "Crediti",
     "Developers": "Sviluppatori",
     "Contributors": "Collaboratori",
     "Testers": "Tester",
-    "Special Thanks": "Un Ringraziamento Speciale",
+    "Special Thanks": "Un ringraziamento speciale",
     "Unknown": "Sconosciuto",
     "Installed": "Installato",
     "Not Installed": "Non installato",
     "X: %u Y: %u": "X: %u Y: %u",
-    "THE BEER-WARE LICENSE": "THE BEER-WARE LICENSE",
+    "THE BEER-WARE LICENSE": "LA LICENZA PER GLI ARTICOLI DI BIRRA",
     "Default": "Predefinito",
-    "Do Not Override": "Non Sovrascrivere",
+    "Do Not Override": "Non sovrascrivere",
     "Disabled": "Disabilitato",
     "Enabled": "Abilitato",
     " \\ue0e3 Reset": "\\ue0e3 Ripristina",
-    "Display": "Schermo",
+    "Display": "Visualizzazione",
     "Application changed\\n\\n": "Applicazione modificata\\n\\n",
     "The running application changed\\n\\n": "L'applicazione in esecuzione è cambiata\\n\\n",
     "while editing was going on.": "mentre era in corso la modifica.",
-    "Board": "Scheda",
+    "Board": "Consiglio",
     "%u.%u%u mV": "%u.%u%u mV",
-    "Could not connect to hoc-clk sysmodule.\\n\\n": "Impossibile connettersi al sysmodule hoc-clk.\\n\\n",
+    "Could not connect to hoc-clk sysmodule.\\n\\n": "Impossibile connettersi al modulo di sistema hoc-clk.\\n\\n",
     "Please make sure everything is\\n\\n": "Assicurati che tutto sia\\n\\n",
     "correctly installed and enabled.": "correttamente installato e abilitato.",
     "Fatal error": "Errore fatale",
-    "Temporary Overrides ": "Sostituzioni Temporanee",
-    "Sleep Mode": "Modalità di Sospensione",
-    "Stock": "Originale",
-    "Dev OC": "OC dev",
-    "Boost Mode": "Modalità Boost",
-    "Safe Max": "Massimo Sicuro",
-    "Unsafe Max": "Massimo Non Sicuro",
-    "Absolute Max": "Massimo Assoluto",
-    "Handheld Safe Max": "Massimo Sicuro Modalità Portatile",
+    "Temporary Overrides ": "Sostituzioni temporanee",
+    "Sleep Mode": "Modalità di sospensione",
+    "Stock": "Magazzino",
+    "Dev OC": "OC di sviluppo",
+    "Boost Mode": "Modalità potenziamento",
+    "Safe Max": "Sicuro massimo",
+    "Unsafe Max": "Non sicuro Max",
+    "Absolute Max": "Massimo assoluto",
+    "Handheld Safe Max": "Cassaforte portatile max",
     "Enable": "Abilita",
-    "Edit App Profile": "Modifica Profilo Dell'App",
-    "Edit Global Profile": "Modifica Profilo Globale",
-    "Temporary Overrides": "Sostituzioni Temporanee",
+    "Edit App Profile": "Modifica profilo dell'app",
+    "Edit Global Profile": "Modifica profilo globale",
+    "Temporary Overrides": "Sostituzioni temporanee",
     "Settings": "Impostazioni",
-    "About": "A Riguardo Di",
+    "About": "Circa",
     "Compiling with minimal features": "Compilazione con funzionalità minime",
-    "General Settings": "Impostazioni Generali",
-    "Governor Settings": "Impostazioni Del Governor",
-    "Safety Settings": "Impostazioni Di Sicurezza",
-    "Save KIP Settings": "Salva le impostazioni del KIP",
+    "General Settings": "Impostazioni generali",
+    "Governor Settings": "Impostazioni del governatore",
+    "Safety Settings": "Impostazioni di sicurezza",
+    "Save KIP Settings": "Salva le impostazioni KIP",
     "RAM Settings": "Impostazioni della RAM",
     "CPU Settings": "Impostazioni della CPU",
     "GPU Settings": "Impostazioni della GPU",
-    "Display Settings": "Impostazioni dello Schermo",
+    "Display Settings": "Impostazioni di visualizzazione",
     "Experimental": "Sperimentale",
-    "GPU Scheduling Override Method": "Metodo di override dello scheduling GPU",
+    "GPU Scheduling Override Method": "Metodo di override della pianificazione GPU",
     "can be dangerous and may cause": "può essere pericoloso e può causare",
     "damage to your battery or charger!": "danni alla batteria o al caricabatterie!",
-    "Charge Current Override": "Override della Corrente di Carica",
-    "RAM Voltage Display Mode": "Modalità di Visualizzazione della Tensione RAM",
+    "Charge Current Override": "Override della corrente di carica",
+    "RAM Voltage Display Mode": "Modalità di visualizzazione della tensione RAM",
     "Polling Interval": "Intervallo di polling",
-    "CPU Governor Minimum Frequency": "Frequenza minima del Governor della CPU",
+    "CPU Governor Minimum Frequency": "Frequenza minima del governatore della CPU",
     "refresh rates may cause stress": "le frequenze di aggiornamento possono causare stress",
     "or damage to your display! ": "o danni al display!",
     "Proceed at your own risk!": "Procedi a tuo rischio e pericolo!",
-    "Max Handheld Display": "Display Massimo in Modalità Portatile",
-    "Display Clock": "Frequenza del Display",
-    "Official Rating": "Rating Ufficiale",
+    "Max Handheld Display": "Display portatile massimo",
+    "Display Clock": "Visualizza orologio",
+    "Official Rating": "Valutazione ufficiale",
     "TDP Threshold": "Soglia TDP",
     "Power": "Potenza",
-    "Thermal Throttle Limit": "Limite Termico",
+    "Thermal Throttle Limit": "Limite della valvola termica",
     "HP Mode": "Modalità HP",
     "Default (Mariko)": "Predefinito (Mariko)",
     "Default (Erista)": "Predefinito (Erista)",
     "Rating": "Valutazione",
-    "Safe Max (Mariko)": "Massimo Sicuro (Mariko)",
-    "Safe Max (Erista)": "Massimo Sicuro (Erista)",
+    "Safe Max (Mariko)": "Safe Max (Mariko)",
+    "Safe Max (Erista)": "Safe Max (Erista)",
     "RAM VDD2 Voltage": "Tensione RAM VDD2",
     "Voltage": "Voltaggio",
     "RAM VDDQ Voltage": "Voltaggio VDDQ della RAM",
     "RAM Frequency Editor": "Editor della frequenza RAM",
     "JEDEC.": "JEDEC.",
-    "High speedo needed!": "Alto Valore Speedo Necessario!",
-    "3333MHz (Needs extreme Speedo/PLL)": "3333 MHz (richiede Speedo/PLL altissimo)",
-    "3366MHz (Needs extreme Speedo/PLL)": "3366 MHz (richiede Speedo/PLL altissimo)",
-    "3400MHz (Needs extreme Speedo/PLL)": "3400 MHz (richiede Speedo/PLL altissimo)",
-    "3433MHz (Needs ridiculous Speedo/PLL)": "3433 MHz (richiede Speedo/PLL estremo)",
-    "3466MHz (Needs ridiculous Speedo/PLL)": "3466 MHz (richiede Speedo/PLL estremo)",
-    "3500MHz (Needs ridiculous Speedo/PLL)": "3500 MHz (richiede Speedo/PLL estremo)",
-    "Ram Max Clock": "Frequenza Massima Ram",
-    "RAM Latency Editor": "Editor della Latenza RAM",
-    "RAM Timing Reductions": "Riduzioni dei Timing della RAM",
-    "Memory Timings": "Timing di Memoria",
+    "High speedo needed!": "È necessaria l'alta velocità!",
+    "3333MHz (Needs extreme Speedo/PLL)": "3333 MHz (richiede Speedo/PLL estremo)",
+    "3366MHz (Needs extreme Speedo/PLL)": "3366 MHz (richiede Speedo/PLL estremo)",
+    "3400MHz (Needs extreme Speedo/PLL)": "3400 MHz (richiede Speedo/PLL estremo)",
+    "3433MHz (Needs ridiculous Speedo/PLL)": "3433 MHz (è necessario un ridicolo Speedo/PLL)",
+    "3466MHz (Needs ridiculous Speedo/PLL)": "3466 MHz (è necessario un ridicolo Speedo/PLL)",
+    "3500MHz (Needs ridiculous Speedo/PLL)": "3500 MHz (è necessario un ridicolo Speedo/PLL)",
+    "Ram Max Clock": "Orologio Ram Max",
+    "RAM Latency Editor": "Editor della latenza RAM",
+    "RAM Timing Reductions": "Riduzioni della temporizzazione della RAM",
+    "Memory Timings": "Tempi di memoria",
     "Advanced": "Avanzato",
-    "t6 tRTW Fine Tune": "Regolazione Fine t6 tRTW",
-    "tRTW Fine Tune": "Regolazione Fine tRTW",
-    "t7 tWTR Fine Tune": "Regolazione Fine t7 tWTR",
-    "tWTR Fine Tune": "Regolazione Fine tWTR",
-    "Memory Latencies": "Latenza della Memoria",
-    "Read Latency": "Latenza di Lettura",
-    "Write Latency": "Latenza di Scrittura",
-    "CPU Boost Clock": "Frequenza CPU in Boost",
-    "CPU UV": "Undervolt CPU",
+    "t6 tRTW Fine Tune": "t6 tRTW Sintonia fine",
+    "tRTW Fine Tune": "tRTW Sintonia fine",
+    "t7 tWTR Fine Tune": "t7 tWTR Sintonia fine",
+    "tWTR Fine Tune": "tWTR Sintonia fine",
+    "Memory Latencies": "Latenza della memoria",
+    "Read Latency": "Leggi latenza",
+    "Write Latency": "Scrivi latenza",
+    "CPU Boost Clock": "Orologio di potenziamento della CPU",
+    "CPU UV": "UV della CPU",
     "CPU Unlock": "Sblocco della CPU",
-    "CPU VMIN": "CPU VMIN",
+    "CPU VMIN": "CPUVMIN",
     "CPU Max Voltage": "Voltaggio massimo della CPU",
-    "CPU Max Clock": "Frequenza massima della CPU",
-    "Extreme UV Table": "Tabella UV estremo",
+    "CPU Max Clock": "Orologio massimo della CPU",
+    "Extreme UV Table": "Tavolo UV estremo",
     "CPU UV Table": "Tabella UV della CPU",
-    "CPU Low UV": "CPU UV Bassa Frequenza",
-    "CPU High UV": "CPU UV Alta Frequenza",
-    "CPU Low VMIN": "CPU VMIN Bassa Frequenza",
-    "CPU High VMIN": "CPU VMIN Alta Frequenza",
-    "No Undervolt": "Nessun Undervolt",
+    "CPU Low UV": "CPU con raggi UV bassi",
+    "CPU High UV": "UV elevato della CPU",
+    "CPU Low VMIN": "VMIN CPU basso",
+    "CPU High VMIN": "CPU alta VMIN",
+    "No Undervolt": "Nessuna sottotensione",
     "SLT Table": "Tabella SLT",
     "HiOPT Table": "Tabella HiOPT",
-    "GPU Undervolt Table": "Tabella di Undervolt GPU",
-    "GPU Minimum Voltage": "Voltaggio Minimo della GPU",
+    "GPU Undervolt Table": "Tabella di sottotensione GPU",
+    "GPU Minimum Voltage": "Voltaggio minimo della GPU",
     "Calculate GPU Vmin": "Calcola GPU Vmin",
-    "GPU VMIN": "GPU VMIN",
+    "GPU VMIN": "GPUVMIN",
     "GPU Maximum Voltage": "Voltaggio massimo della GPU",
-    "GPU Voltage Offset": "Offset di Voltaggio della GPU",
+    "GPU Voltage Offset": "Offset di tensione della GPU",
     "Do not override": "Non sovrascrivere",
     "Enabled (Default)": "Abilitato (impostazione predefinita)",
     "96.6% limit": "Limite del 96,6%.",
     "99.7% limit": "Limite del 99,7%.",
-    "GPU Scheduling Override": "Override dello Scheduling GPU",
+    "GPU Scheduling Override": "Override della pianificazione GPU",
     "Official Service": "Servizio ufficiale",
     "GPU DVFS Mode": "Modalità DVFS GPU",
     "GPU DVFS Offset": "Offset DVFS della GPU",
-    "GPU Voltage Table": "Tabella delle Tensioni della GPU",
-    "GPU Custom Table (mV)": "Tabella GPU Personalizzata (mV)",
+    "GPU Voltage Table": "Tabella delle tensioni della GPU",
+    "GPU Custom Table (mV)": "Tabella personalizzata GPU (mV)",
     "1075MHz without UV, 1152MHz on SLT": "1075 MHz senza UV, 1152 MHz su SLT",
     "or 1228MHz on HiOPT can cause ": "o 1228 MHz su HiOPT possono causare",
-    "permanent damage to your Switch!": "danni permanenti alla tua Switch!",
-    "921MHz without UV and 960MHz on": "921 MHz senza UV e 960 MHz su",
+    "permanent damage to your Switch!": "danni permanenti al tuo Switch!",
+    "921MHz without UV and 960MHz on": "921 MHz senza UV e 960 MHz attivi",
     "SLT or HiOPT can cause ": "SLT o HiOPT possono causare"
 }

dist/config/horizon-oc/lang/ru.json

@@ -1,179 +1,141 @@
 {
     "Information": "Информация",
-    "IDDQ:": "IDDQ:",
-    "Module: ": "Module:",
-    "sys-dock status:": "Статус sys-dock:",
+    "IDDQ:": "ИДДК:",
+    "Module: ": "Модуль:",
+    "sys-dock status:": "Статус системной док-станции:",
     "SaltyNX status:": "Статус SaltyNX:",
-    "RR Display status:": "Статус RR Display:",
-    "Wafer Position:": "Wafer Position:",
-    "Credits": "Благодарности",
+    "RR Display status:": "Статус отображения RR:",
+    "Wafer Position:": "Позиция вафли:",
+    "Credits": "Кредиты",
     "Developers": "Разработчики",
-    "Contributors": "Внесли вклад",
+    "Contributors": "Авторы",
     "Testers": "Тестеры",
     "Special Thanks": "Особая благодарность",
     "Unknown": "Неизвестно",
     "Installed": "Установлено",
     "Not Installed": "Не установлено",
     "X: %u Y: %u": "X: %u Y: %u",
-    "THE BEER-WARE LICENSE": "BEER-WARE LICENSE",
+    "THE BEER-WARE LICENSE": "ЛИЦЕНЗИЯ НА ПРОДАЖУ ПИВА",
     "Default": "По умолчанию",
-    "Do Not Override": "Не менять",
+    "Do Not Override": "Не переопределять",
     "Disabled": "Отключено",
     "Enabled": "Включено",
-    "Auto": "Авто",
     " \\ue0e3 Reset": "\\ue0e3 Сброс",
     "Display": "Дисплей",
     "Application changed\\n\\n": "Приложение изменено\\n\\n",
     "The running application changed\\n\\n": "Запущенное приложение изменилось\\n\\n",
     "while editing was going on.": "пока шло редактирование.",
-    "Board": "Board",
+    "Board": "Совет",
     "%u.%u%u mV": "%u.%u%u мВ",
-    "Could not connect to hoc-clk sysmodule.\\n\\n": "Не удалось подключиться к сис-модулю hoc-clk.\\n\\n",
-    "Please make sure everything is\\n\\n": "Пожалуйста, убедитесь, что все\\n\\n",
-    "correctly installed and enabled.": "правильно установлено и включено.",
-    "Fatal error": "Фатальная ошибка",
-    "Temporary Overrides ": "Временный профиль",
+    "Could not connect to hoc-clk sysmodule.\\n\\n": "Не удалось подключиться к системному модулю hoc-clk.\\n\\n",
+    "Please make sure everything is\\n\\n": "Пожалуйста, убедитесь, что все в порядке\\n\\n",
+    "correctly installed and enabled.": "правильно установлен и включен.",
+    "Fatal error": "Неустранимая ошибка",
+    "Temporary Overrides ": "Временные переопределения",
     "Sleep Mode": "Спящий режим",
-    "Stock": "Стандарт",
-    "Dev OC": "Разгон dev-кита",
-    "Boost Mode": "Режим буста",
-    "Safe Max": "Безопасный макс.",
-    "Unsafe Max": "Опасный макс.",
-    "Absolute Max": "Абсолютный макс.",
-    "Handheld Safe Max": "Портативный безопасный макс.",
-    "Enable": "Включено",
-    "Edit App Profile": "Профиль приложения",
-    "Edit Global Profile": "Глобальный профиль",
-    "Temporary Overrides": "Временный профиль",
+    "Stock": "Акции",
+    "Dev OC": "Разработчик OC",
+    "Boost Mode": "Режим повышения",
+    "Safe Max": "Сейф Макс",
+    "Unsafe Max": "Небезопасный Макс",
+    "Absolute Max": "Абсолютный Макс",
+    "Handheld Safe Max": "Ручной сейф Макс",
+    "Enable": "Включить",
+    "Edit App Profile": "Редактировать профиль приложения",
+    "Edit Global Profile": "Редактировать глобальный профиль",
+    "Temporary Overrides": "Временные переопределения",
     "Settings": "Настройки",
-    "About": "Сведения",
-    "Compiling with minimal features": "Собрано с урезанием функций",
-    "\uE150 Settings marked in blue": "Настройки помеченные синим",
-    "don't require a reboot to apply!": "Синие настройки применяются сразу!",
-    "General Settings": "Основные настройки",
-    "Governor Settings": "Настройки говернора",
+    "About": "О",
+    "Compiling with minimal features": "Компиляция с минимальными возможностями",
+    "General Settings": "Общие настройки",
+    "Governor Settings": "Настройки губернатора",
     "Safety Settings": "Настройки безопасности",
-    "Save KIP Settings": "Сохранить настройки KIP",
-    "RAM Settings": "Настройки RAM",
-    "CPU Settings": "Настройки CPU",
-    "GPU Settings": "Настройки GPU",
+    "Save KIP Settings": "Сохранить настройки КИП",
+    "RAM Settings": "Настройки ОЗУ",
+    "CPU Settings": "Настройки процессора",
+    "GPU Settings": "Настройки графического процессора",
     "Display Settings": "Настройки дисплея",
     "Experimental": "Экспериментальный",
-    "Enable Experimental Settings": "Экспериментальные настройки",
-    "\uE150 Experimental Settings are incomplete ": "Экспериментальные настройки не закончены",
-    "and may not work correctly or at all!": "Экспериментальные настройки не",
-    "Here be dragons!": "закончены и могут не работать!",
-    "Experimental Settings": "Экспериментальные",
-    "Live CPU Undervolt": "Мгновенный андервольт CPU",
-    "GPU Scheduling Override Method": "Метод перезаписи планировщика GPU",
-    "Memory Frequency Measurement Mode": "Режим измерения частоты RAM",
-    "\uE150 Overriding the charge current": "Перезапись зарядного тока может",
-    "can be dangerous and may cause": "Перезапись зарядного тока может",
-    "damage to your battery or charger!": "повреждить аккумулятор или зарядку!",
-    "Charge Current Override": "Перезапись зарядного тока",
-    "RAM Voltage Display Mode": "Показ вольтажа RAM",
-    "RAM Display Unit": "Показ единицы измерения RAM",
+    "GPU Scheduling Override Method": "Метод переопределения планирования графического процессора",
+    "can be dangerous and may cause": "может быть опасным и может вызвать",
+    "damage to your battery or charger!": "повреждение аккумулятора или зарядного устройства!",
+    "Charge Current Override": "Блокировка зарядного тока",
+    "RAM Voltage Display Mode": "Режим отображения напряжения ОЗУ",
     "Polling Interval": "Интервал опроса",
-    "CPU Governor Minimum Frequency": "Минимальная частота говернора CPU",
-    "\uE150 Usage of unsafe display": "\uE150 Использование не безопасной",
-    "refresh rates may cause stress": "Не безопасная частота",
-    "or damage to your display! ": "может повредить ваш экран",
+    "CPU Governor Minimum Frequency": "Минимальная частота регулятора ЦП",
+    "refresh rates may cause stress": "частота обновления может вызвать стресс",
+    "or damage to your display! ": "или повреждение дисплея!",
     "Proceed at your own risk!": "Действуйте на свой страх и риск!",
-    "Max Handheld Display Hz": "Макс. в портативе",
-    "Display Clock": "Частота экрана",
+    "Max Handheld Display": "Макс. портативный дисплей",
+    "Display Clock": "Дисплей Часы",
     "Official Rating": "Официальный рейтинг",
     "TDP Threshold": "Порог TDP",
     "Power": "Мощность",
-    "Thermal Throttle Limit": "Предел троттлинга",
+    "Thermal Throttle Limit": "Температурный предел дроссельной заслонки",
     "HP Mode": "Режим HP",
-    "Default (Mariko)": "По умолчанию (M)",
-    "Default (Erista)": "По умолчанию (E)",
+    "Default (Mariko)": "По умолчанию (Марико)",
+    "Default (Erista)": "По умолчанию (Эриста)",
     "Rating": "Рейтинг",
-    "Safe Max (Mariko)": "Сейф Макс (M)",
-    "Safe Max (Erista)": "Сейф Макс (E)",
-    "RAM VDD2 Voltage": "Вольтаж VDD2",
-    "Voltage": "Вольтаж",
-    "RAM VDDQ Voltage": "Вольтаж VDDQ",
-    "Step Mode": "Частотный шаг",
-    "RAM Frequency Editor": "Редактор частоты",
-    "JEDEC.": "JEDEC.",
-    "High speedo needed!": "Для высоких speedo",
-    "3333MHz (Needs extreme Speedo/PLL)": "3333 MHz (нужны невероятные speedo/PLL)",
-    "3366MHz (Needs extreme Speedo/PLL)": "3366 MHz (нужны невероятные speedo/PLL)",
-    "3400MHz (Needs extreme Speedo/PLL)": "3400 MHz (нужны невероятные speedo/PLL)",
-    "3433MHz (Needs ridiculous Speedo/PLL)": "3433 MHz (нужны безумные speedo/PLL)",
-    "3466MHz (Needs ridiculous Speedo/PLL)": "3466 MHz (нужны безумные speedo/PLL)",
-    "3500MHz (Needs ridiculous Speedo/PLL)": "3500 MHz (нужны безумные speedo/PLL)",
-    "Ram Max Clock": "Макс. частота",
-    "RAM Latency Editor": "Редактор задержек",
-    "1333 Latency Max": "1333 задержка",
-    "1600 Latency Max": "1600 задержка",
-    "1866 Latency Max": "1866 задержка",
-    "2133 Latency Max": "2133 задержка",
-    "RAM Timing Reductions": "Настройка таймингов",
-    "Memory Timings": "Тайминги RAM",
-    "RAM-Timing tBreak": "Разбитие таблицы таймингов",
-    "Memory": "RAM",
-    "mem": "RAM",
-    "MEM": "RAM",
-    "Profile": "Профиль",
-    "Governor": "Говернор",
-    "Advanced": "Расширенные",
-    "Docked": "В доке",
-    "Handheld": "Портатив",
-    "Charging": "На зарядке",
-    "USB Charger": "USB Зарядка",
-    "PD Charger": "PD Зарядка", 
-    "Handheld TDP": "TPD в портативе",
-    "Thermal Throttle": "Троттлинг",
-    "Uncapped Clocks": "Максимальные частоты",
-    "SoC DVB Shift": "SoC DVB сдвиг",
-    "SoC Max Volt": "Макс. вольт SoC",
-    "Overwrite Boost Mode": "Перезапись буста",
-    "Display Refresh Rate Changing": "Изменение частоты экрана",
-    "Low t6 tRTW": "Нижний t6 tRTW",
-    "Low t7 tWTR": "Нижний t7 tWTR",
-    "1333WL t2 RP Cap": "Предел 1333WL t2 RP",
-    "t6 tRTW Fine Tune": " Точная настройка t6 tRTW",
-    "tRTW Fine Tune": " Точная настройка tRTW",
-    "t7 tWTR Fine Tune": " Точная настройка t7 tWTR",
-    "tWTR Fine Tune": " Точная настройка tWTR",
+    "Safe Max (Mariko)": "Сейф Макс (Марико)",
+    "Safe Max (Erista)": "Сейф Макс (Эриста)",
+    "RAM VDD2 Voltage": "Напряжение ОЗУ VDD2",
+    "Voltage": "Напряжение",
+    "RAM VDDQ Voltage": "Напряжение ОЗУ VDDQ",
+    "RAM Frequency Editor": "Редактор частоты оперативной памяти",
+    "JEDEC.": "ДЖЕДЕК.",
+    "High speedo needed!": "Нужен высокий спидометр!",
+    "3333MHz (Needs extreme Speedo/PLL)": "3333 МГц (требуется экстремальный спидометр/PLL)",
+    "3366MHz (Needs extreme Speedo/PLL)": "3366 МГц (требуется экстремальный спидометр/PLL)",
+    "3400MHz (Needs extreme Speedo/PLL)": "3400 МГц (требуется экстремальный спидометр/PLL)",
+    "3433MHz (Needs ridiculous Speedo/PLL)": "3433 МГц (нужен нелепый спидометр/PLL)",
+    "3466MHz (Needs ridiculous Speedo/PLL)": "3466 МГц (нужен нелепый спидометр/PLL)",
+    "3500MHz (Needs ridiculous Speedo/PLL)": "3500 МГц (нужен нелепый спидометр/PLL)",
+    "Ram Max Clock": "Рам Макс Часы",
+    "RAM Latency Editor": "Редактор задержки оперативной памяти",
+    "RAM Timing Reductions": "Сокращение таймингов ОЗУ",
+    "Memory Timings": "Тайминги памяти",
+    "Advanced": "Расширенный",
+    "t6 tRTW Fine Tune": "t6 tRTW Точная настройка",
+    "tRTW Fine Tune": "tRTW Точная настройка",
+    "t7 tWTR Fine Tune": "t7 tWTR Тонкая настройка",
+    "tWTR Fine Tune": "tWTR Тонкая настройка",
     "Memory Latencies": "Задержки памяти",
     "Read Latency": "Задержка чтения",
     "Write Latency": "Задержка записи",
-    "CPU Boost Clock": "Частота буста",
-    "CPU UV": "Андервольт CPU",
-    "CPU Unlock": "Разблокировка CPU",
-    "CPU VMIN": "Мин. вольтаж",
-    "CPU Max Voltage": "Макс. вольтаж",
-    "CPU Max Clock": "Макс. частота",
-    "Extreme UV Table": "Экстримальная",
-    "CPU UV Table": "Таблица андервольта",
-    "CPU Low UV": "Андервольт нижних частот",
-    "CPU High UV": "Андервольт верхних частот",
-    "CPU Low VMIN": "Мин. вольт. нижних частот",
-    "CPU High VMIN": "Мин. вольт. верхних частот",
-    "No Undervolt": "Без андервольта",
-    "SLT Table": "Таблица SLT",
+    "CPU Boost Clock": "Тактовая частота процессора",
+    "CPU UV": "УФ процессора",
+    "CPU Unlock": "Разблокировка процессора",
+    "CPU VMIN": "ЦП VMIN",
+    "CPU Max Voltage": "Максимальное напряжение процессора",
+    "CPU Max Clock": "Максимальная частота процессора",
+    "Extreme UV Table": "Стол для экстремального УФ-излучения",
+    "CPU UV Table": "UV-таблица процессора",
+    "CPU Low UV": "ЦП с низким УФ-излучением",
+    "CPU High UV": "Процессор с высоким УФ",
+    "CPU Low VMIN": "Низкий VMIN процессора",
+    "CPU High VMIN": "Высокий VMIN процессора",
+    "No Undervolt": "Нет Андервольта",
+    "SLT Table": "Таблица ТА",
     "HiOPT Table": "Таблица HiOPT",
-    "GPU Undervolt Table": "Таблица андервольта",
-    "GPU Minimum Voltage": "Мин. вольтаж",
-    "Calculate GPU Vmin": "Вычисление мин. вольтаж",
-    "GPU VMIN": "Мин. вольтаж",
-    "GPU Maximum Voltage": "Макс. вольтаж",
-    "GPU Voltage Offset": "Смещение вольтажа",
-    "Do not override": "Не менять",
-    "Enabled (Default)": "Включено (По умолчанию)",
-    "96.6% limit": "≤96,6%",
-    "99.7% limit": "≤99,7%",
-    "GPU Scheduling Override": "Перезапись планировщика",
+    "GPU Undervolt Table": "Таблица пониженного напряжения графического процессора",
+    "GPU Minimum Voltage": "Минимальное напряжение графического процессора",
+    "Calculate GPU Vmin": "Рассчитать Vmin графического процессора",
+    "GPU VMIN": "Вмин графического процессора",
+    "GPU Maximum Voltage": "Максимальное напряжение графического процессора",
+    "GPU Voltage Offset": "Смещение напряжения графического процессора",
+    "Do not override": "Не переопределять",
+    "Enabled (Default)": "Включено (по умолчанию)",
+    "96.6% limit": "Предел 96,6%",
+    "99.7% limit": "лимит 99,7%",
+    "GPU Scheduling Override": "Переопределение планирования графического процессора",
     "Official Service": "Официальная служба",
-    "GPU DVFS Mode": "Режим DVFS",
-    "GPU DVFS Offset": "Смещение DVFS",
-    "GPU Voltage Table": "Таблица вольтажей",
-    "GPU Custom Table (mV)": "Ручная таблица (мВ)",
-    "\uE150 Setting GPU Clocks past": "\uE150 Установка частот GPU выше",
-	"1228MHz without a proper undervolt": "Установка частот GPU выше 1228 МГц",
-    "can cause degradation or damage": "без хорошего андервольта может",
-    "to your console!": "повредить вашу консоль!"
+    "GPU DVFS Mode": "Режим графического процессора DVFS",
+    "GPU DVFS Offset": "Смещение DVFS графического процессора",
+    "GPU Voltage Table": "Таблица напряжений графического процессора",
+    "GPU Custom Table (mV)": "Пользовательская таблица графического процессора (мВ)",
+    "1075MHz without UV, 1152MHz on SLT": "1075 МГц без УФ, 1152 МГц на SLT",
+    "or 1228MHz on HiOPT can cause ": "или 1228 МГц на HiOPT может привести к",
+    "permanent damage to your Switch!": "необратимое повреждение вашего коммутатора!",
+    "921MHz without UV and 960MHz on": "921 МГц без УФ и 960 МГц с включенным",
+    "SLT or HiOPT can cause ": "SLT или HiOPT могут вызвать"
 }