hocclk: fix clock reset bug

hocclk: add auto cpu ram oc
hocclk: remove handheld TDP
2026-05-27 20:51:44 -04:00 · 2026-05-27 19:32:56 -04:00 · 2026-05-27 16:21:56 -04:00 · 2026-05-27 16:12:43 -04:00 · 2026-05-27 15:59:05 -04:00
15 changed files with 200 additions and 106 deletions
--- a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_mariko.cpp
+++ b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_mariko.cpp
@@ -839,32 +839,32 @@ 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)) }, },
-            {     ~0u, {                                }, },
+            { 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
        DvbEntry emcDvbTableOc[newEmcList.size()];
--- a/Source/hoc-clk/common/include/hocclk/config.h
+++ b/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;
--- a/Source/hoc-clk/overlay/src/ui/gui/base_gui.cpp
+++ b/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;
--- a/Source/hoc-clk/overlay/src/ui/gui/config_info_strings.cpp
+++ b/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",
--- a/Source/hoc-clk/overlay/src/ui/gui/misc_gui.cpp
+++ b/Source/hoc-clk/overlay/src/ui/gui/misc_gui.cpp
@@ -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,
@@ -2063,6 +2037,20 @@ protected:
                NamedValue("2601 MHz", 2601000),
                NamedValue("2703 MHz", 2703000),
            };
+            std::vector<NamedValue> ClkOptionsRamOc = {
+                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 +2063,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));

--- a/Source/hoc-clk/sysmodule/src/file/config.cpp
+++ b/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());
+    }
 }
--- a/Source/hoc-clk/sysmodule/src/file/config.hpp
+++ b/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];

 }
--- a/Source/hoc-clk/sysmodule/src/file/kip.cpp
+++ b/Source/hoc-clk/sysmodule/src/file/kip.cpp
@@ -311,11 +311,17 @@ 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;
+
+            // 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
    }
 }

--- a/Source/hoc-clk/sysmodule/src/mgr/clock_manager.cpp
+++ b/Source/hoc-clk/sysmodule/src/mgr/clock_manager.cpp
@@ -182,7 +182,7 @@ namespace clockManager {
        std::uint32_t *hz = &gFreqTable[module].list[0];
        gFreqTable[module].count = 0;

-        if (module == HocClkModule_GPU && board::GetSocType() == HocClkSocType_Mariko) {
+        if (module == HocClkModule_GPU && board::GetSocType() == HocClkSocType_Mariko && config::GetConfigValue(HocClkConfigValue_MarikoMiddleFreqs)) {
            constexpr u32 kStep = 38400000;
            constexpr u32 kPcvStep = 76800000;

@@ -205,8 +205,6 @@ namespace clockManager {

            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++;
@@ -295,20 +293,6 @@ namespace clockManager {

    bool HandleSafetyFeatures()
    {
-        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;
@@ -522,6 +506,27 @@ namespace clockManager {
                HandleFreqReset((HocClkModule)module, isBoost, didHijackPcv);
            }
        }
+
+        if (config::GetConfigValue(HocClkConfigValue_AutoRAMCPUOverclock) && !skipCpuDueToBoost && !governor::isCpuGovernorEnabled) {
+            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;
+                maxHz = GetMaxAllowedHz(HocClkModule_CPU, gContext.profile);
+                nearestHz = GetNearestHz(HocClkModule_CPU, cpuOverrideHz, maxHz);
+                fileUtils::LogLine(
+                    "[mgr] AutoRAMCPUOC CPU clock set : %u.%u MHz (ram = %u.%u MHz)",
+                    nearestHz / 1000000, nearestHz / 100000 - nearestHz / 1000000 * 10,
+                    ramHz / 1000000, ramHz / 100000 - ramHz / 1000000 * 10
+                );
+                board::SetHz(HocClkModule_CPU, nearestHz);
+                gContext.freqs[HocClkModule_CPU] = nearestHz;
+                if (HocClkModule_CPU < HocClkModuleStable_EnumMax)
+                    gContext.stable.freqs[HocClkModule_CPU] = nearestHz;
+            }
+        }
    }

    bool RefreshContext()
--- a/Source/hoc-clk/sysmodule/src/mgr/governor.cpp
+++ b/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;
                    }

--- a/dist/atmosphere/contents/00FF0000636C6BFF/exefs.nsp
+++ b/dist/atmosphere/contents/00FF0000636C6BFF/exefs.nsp
--- a/dist/atmosphere/kips/hoc.kip
+++ b/dist/atmosphere/kips/hoc.kip
--- a/dist/config/ultrahand/assets/notifications/hoc.rgba
+++ b/dist/config/ultrahand/assets/notifications/hoc.rgba
--- a/dist/switch/.overlays/Horizon-OC-Monitor.ovl
+++ b/dist/switch/.overlays/Horizon-OC-Monitor.ovl
--- a/dist/switch/.overlays/horizon-oc-overlay.ovl
+++ b/dist/switch/.overlays/horizon-oc-overlay.ovl
Author	SHA1	Message	Date
souldbminersmwc	3af3ad4a68	hocclk: fix clock reset bug	2026-05-27 20:51:44 -04:00
souldbminersmwc	d1308e0251	hocclk: add auto cpu ram oc	2026-05-27 19:32:56 -04:00
souldbminersmwc	e48cab36b7	hocclk: remove handheld TDP	2026-05-27 16:21:56 -04:00
souldbminersmwc	b2ba7354cd	Update base_gui.cpp	2026-05-27 16:12:43 -04:00
souldbminersmwc	4f0e890e01	hocclk: fix pcv patch 38.4mhz clock bug	2026-05-27 15:59:05 -04:00