hocclk: add auto cpu ram oc

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

@@ -69,6 +69,10 @@ typedef enum {
 
     HocClkConfigValue_AulaDisplayColorPreset,
     HocClkConfigValue_MarikoMiddleFreqs,
+    
+    HocClkConfigValue_AutoRAMCPUOverclock,
+    HocClkConfigValue_AutoRamCpuCpuOCFreq,
+    HocClkConfigValue_AutoRamCpuRamOCThreshold,
 
     KipConfigValue_custRev,
     KipConfigValue_KipVersion,
@@ -274,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";
@@ -492,7 +504,12 @@ static inline uint64_t hocclkDefaultConfigValue(HocClkConfigValue val)
         case HocClkConfigValue_ThermalThrottle:
         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_CpuGovernorMinimumFreq:
@@ -532,6 +549,7 @@ static inline uint64_t hocclkValidConfigValue(HocClkConfigValue val, uint64_t in
         case HocClkConfigValue_LiveCpuUv:
         case HocClkConfigValue_GPUSchedulingMethod:
         case HocClkConfigValue_MarikoMiddleFreqs:
+        case HocClkConfigValue_AutoRAMCPUOverclock:
             return (input & 0x1) == input;
             
         case KipConfigValue_KipVersion:
@@ -647,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/config_info_strings.cpp

@@ -435,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 {
@@ -464,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

@@ -2037,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,
@@ -2049,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));
 

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

@@ -506,6 +506,25 @@ 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;
+                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()

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;
                     }