hocclk: improve ui cohesiveness

Co-Authored-By: halop <4215938+halop@users.noreply.github.com

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

@@ -3,6 +3,8 @@
  *
  * Copyright (c) 2023 hanai3Bi
  *
+ * Copyright (c) B3711
+ *
  * Copyright (c) Souldbminer, Lightos_ and Horizon OC Contributors
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -591,7 +593,7 @@ namespace ams::ldr::hoc::pcv::erista {
         /* The correct instructions will always be x0 since the mtcTable pointer is returned. */
         u32 adrp = *(ptr + GoodAdrpOffset);
         R_UNLESS(AsmCompareAdrpNoImm(adrp, MtcAdrpAsm), ldr::ResultInvalidMtcTablePattern());
-        
+
 
         /* Check for the branch instruction above the cbz to ensure we are patching the right location*/
         u32 bl = *(ptr + GoodBlOffset);

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

@@ -3,6 +3,8 @@
  *
  * Copyright (c) 2023 hanai3Bi
  *
+ * Copyright (c) B3711
+ *
  * Copyright (c) Souldbminer and Horizon OC Contributors
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -50,11 +52,10 @@ namespace ams::ldr::hoc::pcv::mariko {
             R_THROW(ldr::ResultInvalidGpuDvfs());
         }
 
-
-        if(C.marikoGpuBootVolt) {
-            PATCH_OFFSET(ptr - 3,  C.marikoGpuBootVolt);
+        if (C.marikoGpuBootVolt) {
+            PATCH_OFFSET(ptr - 3, C.marikoGpuBootVolt);
         }
-        
+
         if (C.marikoGpuVmin) {
             PATCH_OFFSET(ptr,      C.marikoGpuVmin);
             PATCH_OFFSET(ptr +  3, C.marikoGpuVmin);
@@ -839,31 +840,31 @@ namespace ams::ldr::hoc::pcv::mariko {
             { 1331200, {              650,  637,  637,  }, },
             { 1600000, {              675,  650,  637,  }, },
             { 1866000, { DVB(DvbVolt( 700,  675,  650)) }, },
+            { 2000000, { DVB(DvbVolt( 712,  687,  662)) }, },
             { 2133000, { DVB(DvbVolt( 725,  700,  675)) }, },
-            { 2246000, { DVB(DvbVolt( 750,  725,  700)) }, },
+            { 2200000, { DVB(DvbVolt( 737,  712,  687)) }, },
+            { 2266000, { DVB(DvbVolt( 750,  725,  700)) }, },
+            { 2333000, { DVB(DvbVolt( 762,  737,  712)) }, },
             { 2400000, { DVB(DvbVolt( 775,  750,  725)) }, },
+            { 2433000, { DVB(DvbVolt( 787,  762,  737)) }, },
             { 2466000, { DVB(DvbVolt( 800,  775,  750)) }, },
-            { 2533000, { DVB(DvbVolt( 810,  785,  760)) }, },
-            { 2566000, { DVB(DvbVolt( 820,  795,  770)) }, },
-            { 2600000, { DVB(DvbVolt( 830,  805,  780)) }, },
-            { 2633000, { DVB(DvbVolt( 840,  815,  790)) }, },
+            { 2533000, { DVB(DvbVolt( 812,  787,  762)) }, },
+            { 2566000, { DVB(DvbVolt( 825,  800,  775)) }, },
+            { 2600000, { DVB(DvbVolt( 837,  812,  787)) }, },
             { 2666000, { DVB(DvbVolt( 850,  825,  800)) }, },
-            { 2700000, { DVB(DvbVolt( 860,  835,  810)) }, },
-            { 2733000, { DVB(DvbVolt( 870,  845,  820)) }, },
-            { 2766000, { DVB(DvbVolt( 880,  855,  830)) }, },
-            { 2800000, { DVB(DvbVolt( 895,  865,  840)) }, },
-            { 2833000, { DVB(DvbVolt( 900,  875,  850)) }, },
-            { 2866000, { DVB(DvbVolt( 910,  885,  860)) }, },
-            { 2900000, { DVB(DvbVolt( 920,  895,  870)) }, },
-            { 2933000, { DVB(DvbVolt( 950,  905,  880)) }, },
-            { 2966000, { DVB(DvbVolt( 960,  915,  890)) }, },
-            { 3000000, { DVB(DvbVolt( 970,  925,  900)) }, },
-            { 3033000, { DVB(DvbVolt( 980,  940,  910)) }, },
-            { 3066000, { DVB(DvbVolt(1000,  955,  920)) }, },
-            { 3100000, { DVB(DvbVolt(1010,  990,  930)) }, },
-            { 3133000, { DVB(DvbVolt(1025, 1005,  940)) }, },
-            { 3166000, { DVB(DvbVolt(1035, 1015,  950)) }, },
-            { 3200000, { DVB(DvbVolt(1050, 1025,  960)) }, },
+            { 2700000, { DVB(DvbVolt( 875,  850,  825)) }, },
+            { 2733000, { DVB(DvbVolt( 887,  862,  837)) }, },
+            { 2766000, { DVB(DvbVolt( 912,  887,  862)) }, },
+            { 2800000, { DVB(DvbVolt( 925,  900,  875)) }, },
+            { 2833000, { DVB(DvbVolt( 937,  912,  887)) }, },
+            { 2900000, { DVB(DvbVolt( 950,  925,  900)) }, },
+            { 2933000, { DVB(DvbVolt( 962,  937,  912)) }, },
+            { 3000000, { DVB(DvbVolt( 975,  950,  925)) }, },
+            { 3033000, { DVB(DvbVolt( 987,  962,  937)) }, },
+            { 3100000, { DVB(DvbVolt(1000,  975,  950)) }, },
+            { 3133000, { DVB(DvbVolt(1025, 1000,  975)) }, },
+            { 3166000, { DVB(DvbVolt(1037, 1012,  987)) }, },
+            { 3200000, { DVB(DvbVolt(1050, 1025, 1000)) }, },
             {     ~0u, {                                }, },
         };
         #undef DVB

Source/hoc-clk/common/include/hocclk/config.h

@@ -46,11 +46,6 @@ typedef enum {
     HocClkConfigValue_ThermalThrottle,
     HocClkConfigValue_ThermalThrottleThreshold,
 
-    HocClkConfigValue_HandheldTDP,
-    HocClkConfigValue_HandheldTDPLimit,
-
-    HocClkConfigValue_LiteTDPLimit,
-
     HocClkConfigValue_BatteryChargeCurrent,
 
     HocClkConfigValue_OverwriteRefreshRate,
@@ -74,6 +69,10 @@ typedef enum {
 
     HocClkConfigValue_AulaDisplayColorPreset,
     HocClkConfigValue_MarikoMiddleFreqs,
+    
+    HocClkConfigValue_AutoRAMCPUOverclock,
+    HocClkConfigValue_AutoRamCpuCpuOCFreq,
+    HocClkConfigValue_AutoRamCpuRamOCThreshold,
 
     KipConfigValue_custRev,
     KipConfigValue_KipVersion,
@@ -235,15 +234,6 @@ static inline const char* hocclkFormatConfigValue(HocClkConfigValue val, bool pr
         case HocClkConfigValue_ThermalThrottleThreshold:
             return pretty ? "Thermal Throttle Threshold" : "thermal_throttle_threshold";
 
-        case HocClkConfigValue_HandheldTDP:
-            return pretty ? "Handheld TDP" : "handheld_tdp";
-
-        case HocClkConfigValue_HandheldTDPLimit:
-            return pretty ? "Handheld TDP Limit" : "tdp_limit";
-
-        case HocClkConfigValue_LiteTDPLimit:
-            return pretty ? "Handheld TDP Limit" : "tdp_limit_l";
-
         case HocClkConfigValue_BatteryChargeCurrent:
             return pretty ? "Battery Charge Current" : "bat_charge_current";
 
@@ -288,6 +278,14 @@ static inline const char* hocclkFormatConfigValue(HocClkConfigValue val, bool pr
             return pretty ? "Aula Display Color Preset" : "aula_color_preset";
         case HocClkConfigValue_MarikoMiddleFreqs:
             return pretty ? "Mariko Middle Clocks" : "mariko_middle_freqs";
+
+        case HocClkConfigValue_AutoRAMCPUOverclock:
+            return pretty ? "Auto High RAM CPU OC" : "auto_high_ram_cpu_oc";
+        case HocClkConfigValue_AutoRamCpuCpuOCFreq:
+            return pretty ? "Auto High RAM CPU OC Freq" : "auto_ram_cpu_cpu_oc_freq";
+        case HocClkConfigValue_AutoRamCpuRamOCThreshold:
+            return pretty ? "Auto High RAM CPU OC RAM Threshold" : "auto_ram_cpu_ram_oc_threshold";
+
         // KIP config values
         case KipConfigValue_custRev:
             return pretty ? "Custom Revision" : "kip_cust_rev";
@@ -504,16 +502,16 @@ static inline uint64_t hocclkDefaultConfigValue(HocClkConfigValue val)
             return 1963ULL;
 
         case HocClkConfigValue_ThermalThrottle:
-        case HocClkConfigValue_HandheldTDP:
         case HocClkConfigValue_IsFirstLoad:
         case HocClkConfigValue_DVFSMode:
+        case HocClkConfigValue_AutoRAMCPUOverclock:
             return 1ULL;
+        case HocClkConfigValue_AutoRamCpuCpuOCFreq:
+            return 1683000ULL;
+        case HocClkConfigValue_AutoRamCpuRamOCThreshold:
+            return 2133000ULL;
         case HocClkConfigValue_ThermalThrottleThreshold:
             return 70ULL;
-        case HocClkConfigValue_HandheldTDPLimit:
-            return 9600ULL; // 8600mW will trigger on erista stock, so raise it a bit
-        case HocClkConfigValue_LiteTDPLimit:
-            return 6400ULL; // 0.5C
         case HocClkConfigValue_CpuGovernorMinimumFreq:
             return 612000000ULL; // 612MHz
         case HocClkConfigValue_MaxDisplayClockH:
@@ -534,8 +532,6 @@ static inline uint64_t hocclkValidConfigValue(HocClkConfigValue val, uint64_t in
         case HocClkConfigValue_EristaMaxCpuClock:
         case HocClkConfigValue_MarikoMaxCpuClock:
         case HocClkConfigValue_ThermalThrottleThreshold:
-        case HocClkConfigValue_HandheldTDPLimit:
-        case HocClkConfigValue_LiteTDPLimit:
         case HocClkConfigValue_PollingIntervalMs:
         case HocClkConfigValue_MaxDisplayClockH:
             return input > 0;
@@ -547,13 +543,13 @@ static inline uint64_t hocclkValidConfigValue(HocClkConfigValue val, uint64_t in
         case HocClkConfigValue_UncappedClocks:
         case HocClkConfigValue_OverwriteBoostMode:
         case HocClkConfigValue_ThermalThrottle:
-        case HocClkConfigValue_HandheldTDP:
         case HocClkConfigValue_OverwriteRefreshRate:
         case HocClkConfigValue_IsFirstLoad:
         case HocClkConfigValue_EnableExperimentalSettings:
         case HocClkConfigValue_LiveCpuUv:
         case HocClkConfigValue_GPUSchedulingMethod:
         case HocClkConfigValue_MarikoMiddleFreqs:
+        case HocClkConfigValue_AutoRAMCPUOverclock:
             return (input & 0x1) == input;
             
         case KipConfigValue_KipVersion:
@@ -669,6 +665,8 @@ static inline uint64_t hocclkValidConfigValue(HocClkConfigValue val, uint64_t in
         case HocClkConfigValue_MemoryFrequencyMeasurementMode:
         case HocClkConfigValue_RamDisplayUnit:
         case HocClkConfigValue_AulaDisplayColorPreset:
+        case HocClkConfigValue_AutoRamCpuCpuOCFreq:
+        case HocClkConfigValue_AutoRamCpuRamOCThreshold:
             return true;
         case HocClkConfigValue_BatteryChargeCurrent:
             return ((input >= 1024) && (input <= 3072)) || !input;

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

@@ -304,7 +304,7 @@ public:
         static constexpr struct { const char* label; int shift; } kAll[] = {
             {"CPU", 0}, {"GPU", 8}, {"VRR", 16}
         };
-        int count = configList.values[HocClkConfigValue_OverwriteRefreshRate] || this->context->isUsingRetroSuper ? 3 : 2;
+        int count = configList.values[HocClkConfigValue_OverwriteRefreshRate] || this->context->isUsingRetroSuper || this->context->profile == HocClkProfile_Docked ? 3 : 2;
 
         for (int i = 0; i < count; i++) {
             u8 cur = (this->profileList->mhzMap[this->profile][HocClkModule_Governor] >> kAll[i].shift) & 0xFF;

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

@@ -149,13 +149,13 @@ void BaseGui::preDraw(tsl::gfx::Renderer* renderer) {
         false
     );
 
-    static const std::string versionStr = "Version " + getVersionString();
+    static const std::string versionStr = "Version " + getVersionString() + "  \"Gaea\"";
     static constexpr tsl::Color versionColor(9, 9, 9, 15);
     static constexpr s32 vx = LOGO_TEXT_X + 15;
     static constexpr s32 vy = TEXT_Y + 18;
     static constexpr s32 fs = 15;
     static constexpr s32 skew = 3;
-    static constexpr s32 passes = 10;
+    static constexpr s32 passes = 25;
     for (s32 i = 0; i < passes; i++) {
         s32 sliceY = (vy - fs) + i * fs / passes;
         s32 sliceH = fs / passes + 1;

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

@@ -57,11 +57,19 @@ BaseMenuGui::~BaseMenuGui() {
 // Fast preDraw - just renders pre-computed strings
 void BaseMenuGui::preDraw(tsl::gfx::Renderer* renderer) {
     BaseGui::preDraw(renderer);
-    if(!this->context) [[unlikely]] return;
+    if (!this->context) [[unlikely]] {
+        this->context = new HocClkContext;
+    }
+
+    Result rc = hocclkIpcGetCurrentContext(this->context);
+    if (R_FAILED(rc)) [[unlikely]] {
+        FatalGui::openWithResultCode("hocclkIpcGetCurrentContext", rc);
+        return;
+    }
 
     // All constants pre-calculated and cached
     const char* labels[] = {
-        "App ID", "Profile", "CPU", "GPU", "MEM", "SoC", "Board", "Skin", "Now", "Avg", "BAT", "PMIC", "Fan", IsAula() ? "OLED" : "LCD", "FPS", "RES"
+        "App ID", "Profile", "CPU", "GPU", "MEM", "SoC", "Board", "Skin", "Now", "Avg", "BAT", "PMIC", "Fan", IsAula() || this->context->isUsingRetroSuper ? "OLED" : "LCD", "FPS", "RES"
     };
 
     static constexpr u32 dataPositions[6] = {63-3+3, 200-1, 344-1-3, 200-1, 342-1, 321-1};

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

@@ -170,19 +170,6 @@ std::vector<std::string> ConfigInfoStrings(HocClkConfigValue val, bool isMariko,
                 "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.",
@@ -448,6 +435,23 @@ std::vector<std::string> ConfigInfoStrings(HocClkConfigValue val, bool isMariko,
                 "The clock used for the CPU in \"boost mode\"",
                 "Default: 1785 MHz"
             };
+        case HocClkConfigValue_AutoRAMCPUOverclock:
+            return {
+                "When enabled, automatically raises the CPU clock to the configured OC frequency when RAM clock meets or exceeds the threshold to meet the increased voltage requirement.",
+                "Default: ON"
+            };
+
+        case HocClkConfigValue_AutoRamCpuCpuOCFreq:
+            return {
+                "The CPU clock (in MHz) applied when Auto High RAM CPU OC is enabled and the RAM threshold is met.",
+                "Default: 1683 MHz"
+            };
+
+        case HocClkConfigValue_AutoRamCpuRamOCThreshold:
+            return {
+                "The RAM clock threshold (in MHz) at or above which the Auto High RAM CPU OC will activate.",
+                "Default: 2133MHz"
+            };
 
         case HocClkConfigValue_OverwriteBoostMode:
             return {
@@ -477,7 +481,7 @@ std::vector<std::string> ConfigInfoStrings(HocClkConfigValue val, bool isMariko,
                 "Maximum GPU voltage",
                 "Default: 800 mV"
             };
-
+        
         case HocClkConfigValue_DVFSMode:
             return {
                 "The mode used for GPU DVFS",

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

@@ -724,8 +724,8 @@ protected:
         ValueThresholds thresholdsDisabled(0, 0);
         if(IsMariko()) {
             addConfigToggle(HocClkConfigValue_MarikoMiddleFreqs, nullptr, true);
+            addConfigToggle(HocClkConfigValue_LiveCpuUv, nullptr);
         }
-        addConfigToggle(HocClkConfigValue_LiveCpuUv, nullptr);
         std::vector<NamedValue> gpuSchedMethodValues = {
             NamedValue("INI", GpuSchedulingOverrideMethod_Ini),
             NamedValue("NV Service", GpuSchedulingOverrideMethod_NvService),
@@ -955,34 +955,8 @@ protected:
         this->listElement->addItem(new CompactCategoryHeader("Safety Settings"));
         addConfigToggle(HocClkConfigValue_UncappedClocks, nullptr);
         addConfigToggle(HocClkConfigValue_ThermalThrottle, nullptr);
-        addConfigToggle(HocClkConfigValue_HandheldTDP, nullptr);
 
         #if IS_MINIMAL == 0
-            std::map<uint32_t, std::string> labels_pwr_l = {
-                {6400, "Official Rating"}
-            };
-
-            if(IsHoag()) {
-                ValueThresholds tdpThresholdsLite(6400, 7500);
-                addConfigButton(
-                    HocClkConfigValue_LiteTDPLimit,
-                    "TDP Threshold",
-                    ValueRange(4000, 8000, 100, "mW", 1),
-                    "Power",
-                    &tdpThresholdsLite,
-                    labels_pwr_l
-                );
-            } else {
-                ValueThresholds tdpThresholds(9600, 11000);
-                addConfigButton(
-                    HocClkConfigValue_HandheldTDPLimit,
-                    "TDP Threshold",
-                    ValueRange(8000, 12000, 100, "mW", 1),
-                    "Power",
-                    &tdpThresholds
-                );
-            }
-
             ValueThresholds throttleThresholds(70, 80);
             addConfigButton(
                 HocClkConfigValue_ThermalThrottleThreshold,
@@ -1771,16 +1745,16 @@ protected:
                     const tsl::Color cMerge = tsl::Color(5, 15,  4, 15);
                     const tsl::Color cAxis  = tsl::Color(5,  5,  5, 15);
 
-                    const s32 gx    = x + 52;
-                    const s32 gw    = w - 64;
+                    const s32 gx    = x + (mariko ? 52 : 47);
+                    const s32 gw    = w - (mariko ? 64 : 59);
                     const s32 gy    = y + 14;
                     const s32 gh    = 54;
                     const s32 th    = gh / 3;
                     const s32 axisY = gy + gh;
 
                     auto tierY = [&](int i) -> s32 { return gy + gh - i * th; };
-                    // Fixed ruler: 1600 MHz (left) → 3300 MHz (right)
-                    constexpr uint32_t kRMin = 1600000u, kRMax = 3300000u;
+                    const uint32_t kRMin = 1600000u;
+                    const uint32_t kRMax = mariko ? 3300000u : 2400000u;
                     auto freqX = [&](uint32_t kHz) -> s32 {
                         if (kHz <= kRMin) return gx;
                         if (kHz >= kRMax) return gx + gw;
@@ -1882,36 +1856,47 @@ protected:
                         {7,5,7,5,7}, // 8
                         {7,5,7,1,7}, // 9
                     };
-                    const s32 pix     = 2;
-                    const s32 charH   = 3 * pix;
-                    const s32 charW   = 5 * pix;
                     const s32 charGap = 1;
 
-                    auto drawSidewaysMHz = [&](uint32_t mhz, s32 cx, s32 startY, const tsl::Color& c) {
+                    auto drawSidewaysMHz = [&](uint32_t mhz, s32 cx, s32 startY, const tsl::Color& c, s32 pixSize) {
                         char buf[8];
                         snprintf(buf, sizeof(buf), "%u", mhz);
-                        s32 originX = cx - charW / 2;
+                        s32 cW = 5 * pixSize;
+                        s32 cH = 3 * pixSize;
+                        s32 originX = cx - cW / 2;
                         for (int ci = 0; buf[ci]; ci++) {
                             int d = buf[ci] - '0';
                             if (d < 0 || d > 9) continue;
-                            s32 cy = startY + ci * (charH + charGap);
+                            s32 cy = startY + ci * (cH + charGap);
                             for (int r = 0; r < 5; r++) {
                                 for (int col = 0; col < 3; col++) {
                                     if (!((kDigBmp[d][r] >> (2 - col)) & 1)) continue;
-                                    renderer->drawRect(originX + (4-r)*pix, cy + col*pix, pix, pix, c);
+                                    renderer->drawRect(originX + (4-r)*pixSize, cy + col*pixSize, pixSize, pixSize, c);
                                 }
                             }
                         }
                     };
 
-                    static const uint32_t kRulerMHz[] = {
-                        1600, 1733, 1866, 2000, 2133, 2266,
-                        2400, 2533, 2666, 2800, 2933, 3066, 3200, 3300,
-                    };
-                    for (uint32_t mhz : kRulerMHz) {
-                        s32 fx = freqX(mhz * 1000u);
-                        renderer->drawRect(fx, axisY, 1, 4, cAxis);
-                        drawSidewaysMHz(mhz, fx, axisY + 6, cAxis);
+                    if (mariko) {
+                        static const uint32_t kRulerMHz[] = {
+                            1600, 1733, 1866, 2000, 2133, 2266,
+                            2400, 2533, 2666, 2800, 2933, 3066, 3200, 3300,
+                        };
+                        for (uint32_t mhz : kRulerMHz) {
+                            s32 fx = freqX(mhz * 1000u);
+                            renderer->drawRect(fx, axisY, 1, 4, cAxis);
+                            drawSidewaysMHz(mhz, fx, axisY + 6, cAxis, 2);
+                        }
+                    } else {
+                        static const uint32_t kEristaRulerMHz[] = {
+                            1600, 1666, 1733, 1800, 1866, 1933,
+                            2000, 2066, 2133, 2200, 2266, 2333, 2400,
+                        };
+                        for (uint32_t mhz : kEristaRulerMHz) {
+                            s32 fx = freqX(mhz * 1000u);
+                            renderer->drawRect(fx, axisY, 1, 4, cAxis);
+                            drawSidewaysMHz(mhz, fx, axisY + 6, cAxis, 2);
+                        }
                     }
 
                     // Breakpoint dots
@@ -2063,6 +2048,24 @@ protected:
                 NamedValue("2601 MHz", 2601000),
                 NamedValue("2703 MHz", 2703000),
             };
+            std::vector<NamedValue> ClkOptionsRamOc = {
+                NamedValue("1122 MHz", 1122000),
+                NamedValue("1224 MHz", 1224000),
+                NamedValue("1326 MHz", 1326000),
+                NamedValue("1428 MHz", 1428000),
+                NamedValue("1581 MHz", 1581000),
+                NamedValue("1683 MHz", 1683000),
+                NamedValue("1785 MHz", 1785000),
+                NamedValue("1887 MHz", 1887000),
+                NamedValue("1963 MHz", 1963500),
+                NamedValue("2091 MHz", 2091000),
+                NamedValue("2193 MHz", 2193000),
+                NamedValue("2295 MHz", 2295000),
+                NamedValue("2397 MHz", 2397000),
+                NamedValue("2499 MHz", 2499000),
+                NamedValue("2601 MHz", 2601000),
+                NamedValue("2703 MHz", 2703000),
+            };
 
             addConfigButton(
                 KipConfigValue_marikoCpuBoostClock,
@@ -2075,6 +2078,85 @@ protected:
                 false,
                 true
             );
+
+            std::vector<NamedValue> emcMaxClock = {
+                NamedValue("1600 MHz", 1600000),
+                NamedValue("1633 MHz", 1633000),
+                NamedValue("1666 MHz", 1666000),
+                NamedValue("1700 MHz", 1700000),
+                NamedValue("1733 MHz", 1733000),
+                NamedValue("1766 MHz", 1766000),
+                NamedValue("1800 MHz", 1800000),
+                NamedValue("1833 MHz", 1833000),
+                NamedValue("1866 MHz", 1866000, "JEDEC."),
+                NamedValue("1900 MHz", 1900000),
+                NamedValue("1933 MHz", 1933000),
+                NamedValue("1966 MHz", 1966000),
+                NamedValue("1996 MHz", 1996800, "JEDEC."),
+                NamedValue("2000 MHz", 2000000),
+                NamedValue("2033 MHz", 2033000),
+                NamedValue("2066 MHz", 2066000),
+                NamedValue("2100 MHz", 2100000),
+                NamedValue("2133 MHz", 2133000, "JEDEC."),
+                NamedValue("2166 MHz", 2166000),
+                NamedValue("2200 MHz", 2200000),
+                NamedValue("2233 MHz", 2233000),
+                NamedValue("2266 MHz", 2266000),
+                NamedValue("2300 MHz", 2300000),
+                NamedValue("2333 MHz", 2333000),
+                NamedValue("2366 MHz", 2366000),
+                NamedValue("2400 MHz", 2400000, "JEDEC."),
+                NamedValue("2433 MHz", 2433000),
+                NamedValue("2466 MHz", 2466000),
+                NamedValue("2500 MHz", 2500000),
+                NamedValue("2533 MHz", 2533000),
+                NamedValue("2566 MHz", 2566000),
+                NamedValue("2600 MHz", 2600000),
+                NamedValue("2633 MHz", 2633000),
+                NamedValue("2666 MHz", 2666000, "JEDEC."),
+                NamedValue("2700 MHz", 2700000),
+                NamedValue("2733 MHz", 2733000),
+                NamedValue("2766 MHz", 2766000),
+                NamedValue("2800 MHz", 2800000),
+                NamedValue("2833 MHz", 2833000),
+                NamedValue("2866 MHz", 2866000),
+                NamedValue("2900 MHz", 2900000),
+                NamedValue("2933 MHz", 2933000, "JEDEC."),
+                NamedValue("2966 MHz", 2966000),
+                NamedValue("3000 MHz", 3000000),
+                NamedValue("3033 MHz", 3033000),
+                NamedValue("3066 MHz", 3066000),
+                NamedValue("3100 MHz", 3100000),
+                NamedValue("3133 MHz", 3133000),
+                NamedValue("3166 MHz", 3166000),
+                NamedValue("3200 MHz", 3200000, "JEDEC."),
+                NamedValue("3233 MHz", 3233000, "High speedo needed!"),
+                NamedValue("3266 MHz", 3266000, "High speedo needed!"),
+                NamedValue("3300 MHz", 3300000, "High speedo needed!"),
+            };
+            addConfigToggle(HocClkConfigValue_AutoRAMCPUOverclock, "Auto CPU RAM OC");
+            addConfigButton(
+                HocClkConfigValue_AutoRamCpuCpuOCFreq,
+                "Auto CPU RAM OC CPU clock",
+                ValueRange(0, 0, 1, "", 1),
+                "CPU Clock",
+                &thresholdsDisabled,
+                {},
+                ClkOptionsRamOc,
+                false,
+                false
+            );
+            addConfigButton(
+                HocClkConfigValue_AutoRamCpuRamOCThreshold,
+                "Auto CPU RAM OC Threshold",
+                ValueRange(0, 0, 1, "", 1),
+                "RAM Clock",
+                &thresholdsDisabled,
+                {},
+                emcMaxClock,
+                false,
+                false
+            );
         } else {
             addConfigTrackbar(KipConfigValue_eristaCpuUV, "CPU UV", ValueRange(0, 5, 1));
 
@@ -2083,7 +2165,7 @@ protected:
             addConfigButton(
                 KipConfigValue_eristaCpuVmin,
                 "CPU VMIN",
-                ValueRange(700, 900, 25, "mV", 1),
+                ValueRange(750, 900, 25, "mV", 1),
                 "CPU VMIN",
                 &thresholdsDisabled,
                 {},
@@ -2147,7 +2229,7 @@ protected:
             );
         }
         addConfigToggle(HocClkConfigValue_OverwriteBoostMode, nullptr);
-
+        addConfigToggle(HocClkConfigValue_LiveCpuUv, nullptr);
     }
 };
 

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

@@ -43,8 +43,12 @@
 #include "../soc/gm20b.hpp"
 #include "../file/config.hpp"
 namespace board {
-    #define MIDDLE_FREQ_TABLE_START_POINT 1228800000
     static u32 currentInjectedHz = 0;
+    static u32 gMarikoGm20bCutoff = 1228800000;
+
+    void SetMarikoGm20bCutoff(u32 hz) {
+        gMarikoGm20bCutoff = hz;
+    }
     PcvModule GetPcvModule(HocClkModule hocclkModule) {
         switch (hocclkModule) {
             case HocClkModule_CPU:
@@ -97,7 +101,7 @@ namespace board {
             return;
         }
 
-        bool useGm20b = (module == HocClkModule_GPU) && (GetSocType() == HocClkSocType_Mariko) && (hz % 38400000 == 0) && (hz % 76800000 != 0) && hz < MIDDLE_FREQ_TABLE_START_POINT;
+        bool useGm20b = (module == HocClkModule_GPU) && (GetSocType() == HocClkSocType_Mariko) && (hz % 38400000 == 0) && (hz % 76800000 != 0) && hz < gMarikoGm20bCutoff;
 
         u32 pcvHz = useGm20b ? ((hz + 76800000 - 1) / 76800000) * 76800000 : hz;
 

Source/hoc-clk/sysmodule/src/board/board_freq.hpp

@@ -39,6 +39,7 @@
 namespace board {
 
     void SetHz(HocClkModule module, u32 hz);
+    void SetMarikoGm20bCutoff(u32 hz);
 
     u32 GetHz(HocClkModule module);
     u32 GetRealHz(HocClkModule module);

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

@@ -50,8 +50,17 @@ namespace board {
             u32 tune1_high;
         };
 
-        EristaCpuUvEntry eristaCpuUvTable[6] = {
-            {0xFFEAD0FF, 0x0},
+        EristaCpuUvEntry eristaCpuUvTableLowBracket[6] = { // <2118 CPU speedo
+            {0xFFEAD0FF, 0x25501d0},
+            {0xffff, 0x27007ff},
+            {0xefff, 0x27407ff},
+            {0xdfff, 0x27807ff},
+            {0xdfdf, 0x27a07ff},
+            {0xcfdf, 0x37007ff},
+        };
+
+        EristaCpuUvEntry eristaCpuUvTableHighBracket[6] = {
+            {0xFFEAD0FF, 0x20091d9},
             {0xffff, 0x27007ff},
             {0xefff, 0x27407ff},
             {0xdfff, 0x27807ff},
@@ -97,10 +106,6 @@ namespace board {
         if (GetSocType() == HocClkSocType_Erista) {
             cachedTune.tune0Low = *reinterpret_cast<u32 *>(cldvfs + CL_DVFS_TUNE0_0);
             cachedTune.tune1Low = *reinterpret_cast<u32 *>(cldvfs + CL_DVFS_TUNE1_0);
-        } else {
-            SetHz(HocClkModule_CPU, 1785000000);
-            cachedTune.tune0High = *reinterpret_cast<u32 *>(cldvfs + CL_DVFS_TUNE0_0);
-            ResetToStockCpu();
         }
     }
 
@@ -108,6 +113,7 @@ namespace board {
     void SetDfllTunings(u32 levelLow, u32 levelHigh, u32 tbreakPoint) {
         u32* tune0_ptr = reinterpret_cast<u32 *>(cldvfs + CL_DVFS_TUNE0_0);
         u32* tune1_ptr = reinterpret_cast<u32 *>(cldvfs + CL_DVFS_TUNE1_0);
+        
         if (GetSocType() == HocClkSocType_Mariko) {
             if (GetHz(HocClkModule_CPU) < tbreakPoint && (levelLow || levelHigh)) {
                 if (levelLow) {
@@ -136,16 +142,8 @@ namespace board {
                 return;
             }
         } else {
-            // if (GetHz(HocClkModule_CPU) < tbreakPoint || (!levelLow)) { // account for tbreak
-            //     *tune0_ptr = cachedTune.tune0Low; // I think each erista has a different tune0/tune1?
-            //     *tune1_ptr = cachedTune.tune1Low;
-            //     return;
-            // } else {
-            //     if (levelLow) {
-                     *tune0_ptr = eristaCpuUvTable[levelLow].tune0;
-                     *tune1_ptr = eristaCpuUvTable[levelLow].tune1;
-            //     } else {
-            // }
+            *tune0_ptr = fuseData.cpuSpeedo > 2118 ? eristaCpuUvTableHighBracket[levelLow].tune0 : eristaCpuUvTableLowBracket[levelLow].tune0;
+            *tune1_ptr = fuseData.cpuSpeedo > 2118 ? eristaCpuUvTableHighBracket[levelLow].tune1 : eristaCpuUvTableLowBracket[levelLow].tune1;
         }
     }
 

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

@@ -480,4 +480,8 @@ namespace config {
         return true;
     }
 
+    void DeleteKey(const char* section, const char* key) {
+        std::scoped_lock lock{gConfigMutex};
+        ini_puts(section, key, NULL, gPath.c_str());
+    }
 }

Source/hoc-clk/sysmodule/src/file/config.hpp

@@ -55,7 +55,8 @@ namespace config {
     bool SetConfigValues(HocClkConfigValueList* configValues, bool immediate);
     bool ResetConfigValue(HocClkConfigValue kval);
     bool SetConfigValue(HocClkConfigValue kval, std::uint64_t value, bool immediate = true);
-
+    void DeleteKey(const char* section, const char* key);
+    
     extern uint64_t configValues[HocClkConfigValue_EnumMax];
 
 }

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

@@ -311,11 +311,22 @@ namespace kip {
         config::GetConfigValues(&configValues);
         u32 previousVersion = configValues.values[KipConfigValue_KipVersion];
         if(previousVersion < 240 && version >= 240) {
-            // <2.4.0 -> 2.4.0 migration: add marikoGpuBootVolt with default value of 800mV
+            // <2.4.0 -> 2.4.0 migration
+
+            // add marikoGpuBootVolt with default value of 800mV
             configValues.values[KipConfigValue_marikoGpuBootVolt] = 800;
+
+            // Raise min cpu vmin
+            if(configValues.values[KipConfigValue_eristaCpuVmin] < 750) {
+                configValues.values[KipConfigValue_eristaCpuVmin] = 750;
+            }
+
+            // delete handheld TDP config entries
+            config::DeleteKey(CONFIG_VAL_SECTION, "handheld_tdp");
+            config::DeleteKey(CONFIG_VAL_SECTION, "tdp_limit");
+            config::DeleteKey(CONFIG_VAL_SECTION, "tdp_limit_l");
         }
         config::SetConfigValues(&configValues, true);
-        // This function cannot do anything at the moment. The capabilities will be expanded in the next release
     }
 }
 

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

@@ -182,31 +182,30 @@ namespace clockManager {
         std::uint32_t *hz = &gFreqTable[module].list[0];
         gFreqTable[module].count = 0;
 
-        if (module == HocClkModule_GPU && board::GetSocType() == HocClkSocType_Mariko) {
-            constexpr u32 kStep = 38400000;
+        if (module == HocClkModule_GPU && board::GetSocType() == HocClkSocType_Mariko
+                && config::GetConfigValue(HocClkConfigValue_MarikoMiddleFreqs)) {
+            constexpr u32 kStep    = 38400000;
             constexpr u32 kPcvStep = 76800000;
-
-            u32 kMax = 0;
+            u32 kMax = ~0;
             for (u32 i = 0; i < count; i++) {
                 for (u32 j = 0; j < count; j++) {
-                    if (freqs[j] == freqs[i] + kStep) {
-                        kMax = freqs[j];
+                    if (freqs[j] + kStep == freqs[i]) {
+                        if (freqs[j] < kMax) kMax = freqs[j];
                         break;
                     }
                 }
             }
-            
-            if (kMax == 0) {
+            if (kMax == ~0u) {
+                kMax = 0;
                 for (u32 i = 0; i < count; i++) {
-                    if (freqs[i] > kMax)
-                        kMax = freqs[i];
+                    if (freqs[i] > kMax) kMax = freqs[i];
                 }
             }
 
+            board::SetMarikoGm20bCutoff(kMax);
+
             for (u32 f = kPcvStep; f <= kMax && gFreqTable[module].count < HOCCLK_FREQ_LIST_MAX; f += kStep) {
                 if (f % kPcvStep != 0) {
-                    if (!config::GetConfigValue(HocClkConfigValue_MarikoMiddleFreqs)) 
-                        continue;
                     *hz = f;
                     gFreqTable[module].count++;
                     hz++;
@@ -232,6 +231,8 @@ namespace clockManager {
             return;
         }
 
+        board::SetMarikoGm20bCutoff(0);
+
         for (std::uint32_t i = 0; i < count; i++) {
             if (!IsAssignableHz(module, freqs[i])) {
                 continue;
@@ -293,26 +294,29 @@ namespace clockManager {
         fileUtils::LogLine("[mgr] count = %u", gFreqTable[module].count);
     }
 
-    bool HandleSafetyFeatures()
+    bool HandleSafetyFeatures(bool isBoost)
     {
-        if (config::GetConfigValue(HocClkConfigValue_HandheldTDP) && (gContext.profile != HocClkProfile_Docked)) {
-            if (board::GetConsoleType() == HocClkConsoleType_Hoag) {
-                if (board::GetPowerMw(HocClkPowerSensor_Avg) < -(int)config::GetConfigValue(HocClkConfigValue_LiteTDPLimit)) {
-                    ResetToStockClocks();
-                    return true;
-                }
-            } else {
-                if (board::GetPowerMw(HocClkPowerSensor_Avg) < -(int)config::GetConfigValue(HocClkConfigValue_HandheldTDPLimit)) {
-                    ResetToStockClocks();
-                    return true;
-                }
-            }
-        }
-
         if (((tmp451TempSoc() / 1000) > (int)config::GetConfigValue(HocClkConfigValue_ThermalThrottleThreshold)) && config::GetConfigValue(HocClkConfigValue_ThermalThrottle)) {
             ResetToStockClocks();
             return true;
         }
+
+        if (config::GetConfigValue(HocClkConfigValue_AutoRAMCPUOverclock) && !isBoost && !governor::isCpuGovernorEnabled && (board::GetSocType() == HocClkSocType_Mariko)) {
+            u32 ramHz = gContext.freqs[HocClkModule_MEM];
+            u32 threshold = (u32)config::GetConfigValue(HocClkConfigValue_AutoRamCpuRamOCThreshold) * 1000;
+            if (ramHz >= threshold) {
+                u32 cpuOverrideHz = (u32)config::GetConfigValue(HocClkConfigValue_AutoRamCpuCpuOCFreq) * 1000;
+                if (cpuOverrideHz <= gContext.freqs[HocClkModule_CPU])
+                    return false;
+                u32 maxHz = GetMaxAllowedHz(HocClkModule_CPU, gContext.profile);
+                u32 nearestHz = GetNearestHz(HocClkModule_CPU, cpuOverrideHz, maxHz);
+                board::SetHz(HocClkModule_CPU, nearestHz);
+                gContext.freqs[HocClkModule_CPU] = nearestHz;
+                if (HocClkModule_CPU < HocClkModuleStable_EnumMax)
+                    gContext.stable.freqs[HocClkModule_CPU] = nearestHz;
+                return true;
+            }
+        }
         return false;
     }
     void HandleMiscFeatures()
@@ -766,7 +770,7 @@ namespace clockManager {
 
         bool isBoost = apmExtIsBoostMode(mode);
 
-        bool shouldSkipClockSet = HandleSafetyFeatures();
+        bool shouldSkipClockSet = HandleSafetyFeatures(isBoost);
         HandleMiscFeatures();
         
         // GPU clock should always be the same unless PCV has overwriten our change, so reset it

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

@@ -162,6 +162,15 @@ namespace governor {
 
                     if (++cpuTick > 50) {
                         minHz = config::GetConfigValue(HocClkConfigValue_CpuGovernorMinimumFreq);
+                        if (config::GetConfigValue(HocClkConfigValue_AutoRAMCPUOverclock)) {
+                            u32 ramHz = clockManager::gContext.freqs[HocClkModule_MEM];
+                            u32 threshold = (u32)config::GetConfigValue(HocClkConfigValue_AutoRamCpuRamOCThreshold) * 1000;
+                            if (ramHz >= threshold) {
+                                u32 overrideHz = (u32)config::GetConfigValue(HocClkConfigValue_AutoRamCpuCpuOCFreq) * 1000;
+                                if (overrideHz > minHz)
+                                    minHz = overrideHz;
+                            }
+                        }
                         cpuTick = 0;
                     }