hocclk: major code refactor

move everything into its own directory, clean codebase up a lot

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

@@ -0,0 +1,695 @@
+/*
+ * 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/>.
+ *
+ */
+
+/* --------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <p-sam@d3vs.net>, <natinusala@gmail.com>, <m4x@m4xw.net>
+ * wrote this file. As long as you retain this notice you can do whatever you
+ * want with this stuff. If you meet any of us some day, and you think this
+ * stuff is worth it, you can buy us a beer in return.  - The sys-clk authors
+ * --------------------------------------------------------------------------
+ */
+
+#include "clock_manager.hpp"
+#include <cstring>
+#include "../file/file_utils.hpp"
+#include "../board/board.hpp"
+#include "../hos/process_management.hpp"
+#include "../file/errors.hpp"
+#include "../ipc/ipc_service.hpp"
+#include "../file/kip.hpp"
+#include <i2c.h>
+#include "../i2c/i2cDrv.h"
+#include "../display/display_refresh_rate.hpp"
+#include <cstdio>
+#include <crc32.h>
+#include "../file/config.hpp"
+#include "../hos/integrations.hpp"
+#include "../util/lockable_mutex.h"
+#include "../file/kip.hpp"
+#include "governor.hpp"
+#include "../display/aula.hpp"
+
+#define HOSPPC_HAS_BOOST (hosversionAtLeast(7,0,0))
+
+namespace clockManager {
+
+
+    bool gRunning = false;
+    LockableMutex gContextMutex;
+    HocClkContext gContext = {};
+    FreqTable gFreqTable[HocClkModule_EnumMax];
+    std::uint64_t gLastTempLogNs = 0;
+    std::uint64_t gLastFreqLogNs = 0;
+    std::uint64_t gLastPowerLogNs = 0;
+    std::uint64_t gLastCsvWriteNs = 0;
+
+    bool IsAssignableHz(HocClkModule module, std::uint32_t hz)
+    {
+        switch (module) {
+        case HocClkModule_CPU:
+            return hz >= 500000000;
+        case HocClkModule_MEM:
+            return hz >= 665600000;
+        default:
+            return true;
+        }
+    }
+
+    std::uint32_t GetMaxAllowedHz(HocClkModule module, HocClkProfile profile)
+    {
+        if (config::GetConfigValue(HocClkConfigValue_UncappedClocks)) {
+            return ~0; // Integer limit, uncapped clocks ON
+        } else {
+            if (module == HocClkModule_GPU) {
+                if (profile < HocClkProfile_HandheldCharging) {
+                    switch (board::GetSocType()) {
+                    case HocClkSocType_Erista:
+                        return 460800000;
+                    case HocClkSocType_Mariko:
+                        switch (config::GetConfigValue(KipConfigValue_marikoGpuUV)) {
+                        case 0:
+                            return 614400000;
+                        case 1:
+                            return 691200000;
+                        case 2:
+                            return 768000000;
+                        default:
+                            return 614400000;
+                        }
+                    default:
+                        return 460800000;
+                    }
+                } else if (profile <= HocClkProfile_HandheldChargingUSB) {
+                    switch (board::GetSocType()) {
+                    case HocClkSocType_Erista:
+                        return 768000000;
+                    case HocClkSocType_Mariko:
+                        switch (config::GetConfigValue(KipConfigValue_marikoGpuUV)) {
+                        case 0:
+                            return 844800000;
+                        case 1:
+                            return 921600000;
+                        case 2:
+                            return 998400000;
+                        default:
+                            return 844800000;
+                        }
+                    default:
+                        return 768000000;
+                    }
+                }
+            } else if (module == HocClkModule_CPU) {
+                if (profile < HocClkProfile_HandheldCharging && board::GetSocType() == HocClkSocType_Erista) {
+                    return 1581000000;
+                } else {
+                    return ~0;
+                }
+            }
+        }
+        return 0;
+    }
+
+    std::uint32_t GetNearestHz(HocClkModule module, std::uint32_t inHz, std::uint32_t maxHz)
+    {
+        std::uint32_t *freqs = &gFreqTable[module].list[0];
+        size_t count = gFreqTable[module].count - 1;
+
+        size_t i = 0;
+        while (i < count) {
+            if (maxHz > 0 && freqs[i] >= maxHz) {
+                break;
+            }
+            if (inHz <= ((std::uint64_t)freqs[i] + freqs[i + 1]) / 2) {
+                break;
+            }
+            i++;
+        }
+
+        return freqs[i];
+    }
+
+    void ResetToStockClocks()
+    {
+        board::ResetToStockCpu();
+        if (config::GetConfigValue(HocClkConfigValue_LiveCpuUv)) {
+            if (board::GetSocType() == HocClkSocType_Erista)
+                board::SetDfllTunings(config::GetConfigValue(KipConfigValue_eristaCpuUV), 0, 1581000000);
+            else
+                board::SetDfllTunings(config::GetConfigValue(KipConfigValue_marikoCpuUVLow), config::GetConfigValue(KipConfigValue_marikoCpuUVHigh), board::CalculateTbreak(config::GetConfigValue(KipConfigValue_tableConf)));
+        }
+
+        board::ResetToStockGpu();
+    }
+
+    bool ConfigIntervalTimeout(HocClkConfigValue intervalMsConfigValue, std::uint64_t ns, std::uint64_t *lastLogNs)
+    {
+        std::uint64_t logInterval = config::GetConfigValue(intervalMsConfigValue) * 1000000ULL;
+        bool shouldLog = logInterval && ((ns - *lastLogNs) > logInterval);
+
+        if (shouldLog) {
+            *lastLogNs = ns;
+        }
+
+        return shouldLog;
+    }
+
+    void RefreshFreqTableRow(HocClkModule module)
+    {
+        std::scoped_lock lock{gContextMutex};
+
+        std::uint32_t freqs[HOCCLK_FREQ_LIST_MAX];
+        std::uint32_t count;
+
+        fileUtils::LogLine("[mgr] %s freq list refresh", board::GetModuleName(module, true));
+        board::GetFreqList(module, &freqs[0], HOCCLK_FREQ_LIST_MAX, &count);
+
+        std::uint32_t *hz = &gFreqTable[module].list[0];
+        gFreqTable[module].count = 0;
+        for (std::uint32_t i = 0; i < count; i++) {
+            if (!IsAssignableHz(module, freqs[i])) {
+                continue;
+            }
+
+            *hz = freqs[i];
+            fileUtils::LogLine("[mgr] %02u - %u - %u.%u MHz", gFreqTable[module].count, *hz, *hz / 1000000, *hz / 100000 - *hz / 1000000 * 10);
+
+            gFreqTable[module].count++;
+            hz++;
+        }
+
+        fileUtils::LogLine("[mgr] count = %u", gFreqTable[module].count);
+    }
+
+    void 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;
+                }
+            } else {
+                if (board::GetPowerMw(HocClkPowerSensor_Avg) < -(int)config::GetConfigValue(HocClkConfigValue_HandheldTDPLimit)) {
+                    ResetToStockClocks();
+                    return;
+                }
+            }
+        }
+
+        if (((tmp451TempSoc() / 1000) > (int)config::GetConfigValue(HocClkConfigValue_ThermalThrottleThreshold)) && config::GetConfigValue(HocClkConfigValue_ThermalThrottle)) {
+            ResetToStockClocks();
+            return;
+        }
+    }
+
+    void HandleMiscFeatures()
+    {
+        // these dont need to run that often, so dont bother
+        static u32 tick = 0;
+        if(++tick > 10) {
+            tick = 0;
+
+            if (config::GetConfigValue(HocClkConfigValue_BatteryChargeCurrent)) {
+                I2c_Bq24193_SetFastChargeCurrentLimit(config::GetConfigValue(HocClkConfigValue_BatteryChargeCurrent));
+            }
+
+            I2c_BuckConverter_SetMvOut(&I2c_Display, config::GetConfigValue(HocClkConfigValue_DisplayVoltage));
+
+            if(board::GetConsoleType() == HocClkConsoleType_Aula)
+                AulaDisplay::SetDisplayColorMode((AulaColorMode)config::GetConfigValue(HocClkConfigValue_AulaDisplayColorPreset));
+        }
+    }
+
+    void ApplyGpuDvfs(u32 targetHz) {
+        s32 dvfsOffset = config::GetConfigValue(HocClkConfigValue_DVFSOffset);
+        dvfsOffset = std::max(dvfsOffset, -80);
+        u32 vmin = board::GetMinimumGpuVmin(targetHz / 1000000, board::GetGpuSpeedoBracket());
+
+        if (vmin) {
+            vmin += dvfsOffset;
+        }
+
+        /* Prevent console from combusting if for some reason bad shit happens :P */
+        vmin = std::min(vmin, 1000u);
+
+        /* Get nearest gpu clock; we need this in a second to update the voltage. */
+        u32 gpuHz = board::GetHz(HocClkModule_GPU);
+        u32 maxHz = GetMaxAllowedHz(HocClkModule_GPU, gContext.profile);
+        u32 nearestGpuHz = GetNearestHz(HocClkModule_GPU, gpuHz, maxHz);
+
+        /* Hijack gpu volt table. */
+        board::PcvHijackGpuVolts(vmin);
+
+        /* Update gpu frequency to actually use the voltage. */
+        if (targetHz) {
+            board::SetHz(HocClkModule_GPU, nearestGpuHz);
+        } else {
+            /* If the target frequency is zero, we reset the frequency to ensure it gets updated even without any frequency override. */
+            board::ResetToStockGpu();
+        }
+    }
+
+    void HandleCpuUv()
+    {
+        if (board::GetSocType() == HocClkSocType_Erista)
+            board::SetDfllTunings(config::GetConfigValue(KipConfigValue_eristaCpuUV), 0, 1581000000); // Erista tbreak is always 1581MHz
+        else
+            board::SetDfllTunings(config::GetConfigValue(KipConfigValue_marikoCpuUVLow), config::GetConfigValue(KipConfigValue_marikoCpuUVHigh), board::CalculateTbreak(config::GetConfigValue(KipConfigValue_tableConf)));
+    }
+
+    void DVFSReset()
+    {
+        if (board::GetSocType() == HocClkSocType_Mariko && config::GetConfigValue(HocClkConfigValue_DVFSMode) == DVFSMode_Hijack) {
+            board::PcvHijackGpuVolts(0); // Reset to vMin
+
+            u32 targetHz = gContext.overrideFreqs[HocClkModule_GPU];
+            if (!targetHz) {
+                targetHz = config::GetAutoClockHz(gContext.applicationId, HocClkModule_GPU, gContext.profile, false);
+                if (!targetHz) {
+                    targetHz = config::GetAutoClockHz(HOCCLK_GLOBAL_PROFILE_TID, HocClkModule_GPU, gContext.profile, false);
+                }
+            }
+            u32 maxHz = GetMaxAllowedHz(HocClkModule_GPU, gContext.profile);
+            u32 nearestHz = GetNearestHz(HocClkModule_GPU, targetHz, maxHz);
+
+            board::ResetToStockGpu();
+            if (targetHz)
+                board::SetHz(HocClkModule_GPU, nearestHz);
+        }
+    }
+
+    void HandleFreqReset(HocClkModule module, bool isBoost, bool didHijackPcv)
+    {
+        switch (module) {
+            case HocClkModule_CPU:
+                if (!(isBoost || (config::GetConfigValue(HocClkConfigValue_OverwriteBoostMode) && isBoost)))
+                    board::ResetToStockCpu();
+                if (config::GetConfigValue(HocClkConfigValue_LiveCpuUv)) {
+                    if (board::GetSocType() == HocClkSocType_Erista)
+                        board::SetDfllTunings(config::GetConfigValue(KipConfigValue_eristaCpuUV), 0, 1581000000);
+                    else
+                        board::SetDfllTunings(config::GetConfigValue(KipConfigValue_marikoCpuUVLow), config::GetConfigValue(KipConfigValue_marikoCpuUVHigh), board::CalculateTbreak(config::GetConfigValue(KipConfigValue_tableConf)));
+                }
+                break;
+            case HocClkModule_GPU:
+                board::ResetToStockGpu();
+                break;
+            case HocClkModule_MEM:
+                board::ResetToStockMem();
+                if(!didHijackPcv) {
+                    DVFSReset();
+                    didHijackPcv = true;
+                }
+                break;
+            case HocClkModule_Display:
+                if (config::GetConfigValue(HocClkConfigValue_OverwriteRefreshRate)) {
+                    board::ResetToStockDisplay();
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    void SetClocks(bool isBoost)
+    {
+        std::uint32_t targetHz = 0;
+        std::uint32_t maxHz = 0;
+        std::uint32_t nearestHz = 0;
+        static bool prepareBoostExit = false;
+
+        bool didHijackPcv = false;
+        bool skipCpuDueToBoost = isBoost && !config::GetConfigValue(HocClkConfigValue_OverwriteBoostMode);
+        if (skipCpuDueToBoost) {
+            board::SetHz(HocClkModule_CPU, board::GetHz(HocClkModule_CPU));
+            prepareBoostExit = true;
+            return; // Return if we aren't overwriting boost mode
+        }
+
+        if (prepareBoostExit) {
+            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)
+
+            if (module > HocClkModule_MEM)
+                returnRaw = true;
+            else
+                returnRaw = false;
+            targetHz = gContext.overrideFreqs[module];
+            if (!targetHz) {
+                targetHz = config::GetAutoClockHz(gContext.applicationId, (HocClkModule)module, gContext.profile, returnRaw);
+                if (!targetHz)
+                    targetHz = config::GetAutoClockHz(HOCCLK_GLOBAL_PROFILE_TID, (HocClkModule)module, gContext.profile, returnRaw);
+            }
+
+            if (module == HocClkModule_Governor) {
+                governor::HandleGovernor(targetHz);
+            }
+
+            bool noCPU = governor::isCpuGovernorEnabled;
+            bool noGPU = governor::isGpuGovernorEnabled;
+            bool noDisp = governor::isVRREnabled;
+            if (noDisp && module == HocClkModule_Display)
+                continue;
+
+            if (module == HocClkModule_Display && config::GetConfigValue(HocClkConfigValue_OverwriteRefreshRate) && !noDisp) {
+                if (targetHz) {
+                    board::SetHz(HocClkModule_Display, targetHz);
+                    gContext.freqs[HocClkModule_Display] = targetHz;
+                    gContext.realFreqs[HocClkModule_Display] = targetHz;
+
+                    gContext.stable.freqs[HocClkModule_Display] = targetHz;
+                    gContext.stable.realFreqs[HocClkModule_Display] = targetHz;
+                } else {
+                    HandleFreqReset(HocClkModule_Display, isBoost, didHijackPcv);
+                }
+            }
+
+            // The modules above MEM require special handling
+            if (module > HocClkModule_MEM) {
+                continue;
+            }
+
+            if ((skipCpuDueToBoost || noCPU) && module == HocClkModule_CPU)
+                continue;
+            if (noGPU && module == HocClkModule_GPU)
+                continue;
+
+            if (targetHz) {
+                maxHz = GetMaxAllowedHz((HocClkModule)module, gContext.profile);
+                nearestHz = GetNearestHz((HocClkModule)module, targetHz, maxHz);
+
+                if (nearestHz != gContext.freqs[module]) {
+                    fileUtils::LogLine(
+                        "[mgr] %s clock set : %u.%u MHz (target = %u.%u MHz)",
+                        board::GetModuleName((HocClkModule)module, true),
+                        nearestHz / 1000000, nearestHz / 100000 - nearestHz / 1000000 * 10,
+                        targetHz / 1000000, targetHz / 100000 - targetHz / 1000000 * 10
+                    );
+
+                    // The logic MUST be done in this order otherwise you WILL get crashes
+                    if (module == HocClkModule_MEM && board::GetSocType() == HocClkSocType_Mariko && targetHz > oldHz && config::GetConfigValue(HocClkConfigValue_DVFSMode) == DVFSMode_Hijack) {
+                        ApplyGpuDvfs(targetHz);
+                    }
+
+                    board::SetHz((HocClkModule)module, nearestHz);
+                    gContext.freqs[module] = nearestHz;
+
+                    if (module < HocClkModuleStable_EnumMax) {
+                        gContext.stable.freqs[module] = nearestHz;
+                    }
+
+                    if (module == HocClkModule_CPU && config::GetConfigValue(HocClkConfigValue_LiveCpuUv)) {
+                        HandleCpuUv();
+                    }
+
+                    if (module == HocClkModule_MEM && board::GetSocType() == HocClkSocType_Mariko && targetHz < oldHz && config::GetConfigValue(HocClkConfigValue_DVFSMode) == DVFSMode_Hijack) {
+                        ApplyGpuDvfs(targetHz);
+                    }
+
+                    if(module == HocClkModule_MEM && board::GetSocType() == HocClkSocType_Mariko && config::GetConfigValue(HocClkConfigValue_DVFSMode) == DVFSMode_Hijack)
+                        didHijackPcv = false;
+                }
+            } else {
+                HandleFreqReset((HocClkModule)module, isBoost, didHijackPcv);
+            }
+        }
+    }
+
+    bool RefreshContext()
+    {
+        bool hasChanged = false;
+
+        std::uint32_t mode = 0;
+        Result rc = apmExtGetCurrentPerformanceConfiguration(&mode);
+        ASSERT_RESULT_OK(rc, "apmExtGetCurrentPerformanceConfiguration");
+
+        std::uint64_t applicationId = processManagement::GetCurrentApplicationId();
+        if (applicationId != gContext.applicationId) {
+            fileUtils::LogLine("[mgr] TitleID change: %016lX", applicationId);
+            gContext.applicationId = applicationId;
+            hasChanged = true;
+        }
+
+        HocClkProfile profile = board::GetProfile();
+        if (profile != gContext.profile) {
+            fileUtils::LogLine("[mgr] Profile change: %s", board::GetProfileName(profile, true));
+            gContext.profile = profile;
+            hasChanged = true;
+        }
+
+        // restore clocks to stock values on app or profile change
+        if (hasChanged) {
+            board::ResetToStock();
+            if (board::GetSocType() == HocClkSocType_Mariko && config::GetConfigValue(HocClkConfigValue_DVFSMode) == DVFSMode_Hijack) {
+                board::PcvHijackGpuVolts(0);
+                board::ResetToStockGpu();
+            }
+            WaitForNextTick();
+        }
+
+        std::uint32_t hz = 0;
+        for (unsigned int module = 0; module < HocClkModule_EnumMax; module++) {
+            hz = board::GetHz((HocClkModule)module);
+            if (hz != 0 && hz != gContext.freqs[module]) {
+                fileUtils::LogLine("[mgr] %s clock change: %u.%u MHz", board::GetModuleName((HocClkModule)module, true), hz / 1000000, hz / 100000 - hz / 1000000 * 10);
+                gContext.freqs[module] = hz;
+
+                if (module < HocClkModuleStable_EnumMax) {
+                    gContext.stable.freqs[module] = hz;
+                }
+                hasChanged = true;
+            }
+
+            hz = config::GetOverrideHz((HocClkModule)module);
+            if (hz != gContext.overrideFreqs[module]) {
+                if (hz) {
+                    fileUtils::LogLine("[mgr] %s override change: %u.%u MHz", board::GetModuleName((HocClkModule)module, true), hz / 1000000, hz / 100000 - hz / 1000000 * 10);
+                }
+                gContext.overrideFreqs[module] = hz;
+
+                if (module < HocClkModuleStable_EnumMax) {
+                    gContext.stable.overrideFreqs[module] = hz;
+                }
+                hasChanged = true;
+            }
+        }
+
+        std::uint64_t ns = armTicksToNs(armGetSystemTick());
+
+        // temperatures do not and should not force a refresh, hasChanged untouched
+        std::uint32_t millis = 0;
+        bool shouldLogTemp = ConfigIntervalTimeout(HocClkConfigValue_TempLogIntervalMs, ns, &gLastTempLogNs);
+        for (unsigned int sensor = 0; sensor < HocClkThermalSensor_EnumMax; sensor++) {
+            millis = board::GetTemperatureMilli((HocClkThermalSensor)sensor);
+            if (shouldLogTemp) {
+                fileUtils::LogLine("[mgr] %s temp: %u.%u °C", board::GetThermalSensorName((HocClkThermalSensor)sensor, true), millis / 1000, (millis - millis / 1000 * 1000) / 100);
+            }
+            gContext.temps[sensor] = millis;
+
+            if (sensor < HocClkThermalSensorStable_EnumMax) {
+                gContext.stable.temps[sensor] = millis;
+            }
+        }
+
+        // power stats do not and should not force a refresh, hasChanged untouched
+        std::int32_t mw = 0;
+        bool shouldLogPower = ConfigIntervalTimeout(HocClkConfigValue_PowerLogIntervalMs, ns, &gLastPowerLogNs);
+        for (unsigned int sensor = 0; sensor < HocClkPowerSensor_EnumMax; sensor++) {
+            mw = board::GetPowerMw((HocClkPowerSensor)sensor);
+            if (shouldLogPower) {
+                fileUtils::LogLine("[mgr] Power %s: %d mW", board::GetPowerSensorName((HocClkPowerSensor)sensor, false), mw);
+            }
+            gContext.power[sensor] = mw;
+
+            if (sensor < HocClkPowerSensorStable_EnumMax) {
+                gContext.stable.power[sensor] = mw;
+            }
+        }
+
+        // real freqs do not and should not force a refresh, hasChanged untouched
+        std::uint32_t realHz = 0;
+        bool shouldLogFreq = ConfigIntervalTimeout(HocClkConfigValue_FreqLogIntervalMs, ns, &gLastFreqLogNs);
+        for (unsigned int module = 0; module < HocClkModule_EnumMax; module++) {
+            realHz = board::GetRealHz((HocClkModule)module);
+            if (shouldLogFreq) {
+                fileUtils::LogLine("[mgr] %s real freq: %u.%u MHz", board::GetModuleName((HocClkModule)module, true), realHz / 1000000, realHz / 100000 - realHz / 1000000 * 10);
+            }
+            gContext.realFreqs[module] = realHz;
+
+            if (module < HocClkModuleStable_EnumMax) {
+                gContext.stable.realFreqs[module] = realHz;
+            }
+        }
+
+        // ram load do not and should not force a refresh, hasChanged untouched
+        for (unsigned int loadSource = 0; loadSource < HocClkPartLoad_EnumMax; loadSource++) {
+            gContext.partLoad[loadSource] = board::GetPartLoad((HocClkPartLoad)loadSource);
+
+            if (loadSource < HocClkPartLoadStable_EnumMax) {
+                gContext.stable.partLoad[loadSource] = board::GetPartLoad((HocClkPartLoad)loadSource);
+            }
+        }
+
+        for (unsigned int voltageSource = 0; voltageSource < HocClkVoltage_EnumMax; voltageSource++) {
+            gContext.voltages[voltageSource] = board::GetVoltage((HocClkVoltage)voltageSource);
+
+            if (voltageSource < HocClkVoltageStable_EnumMax) {
+                gContext.stable.voltages[voltageSource] = board::GetVoltage((HocClkVoltage)voltageSource);
+            }
+        }
+
+        if (ConfigIntervalTimeout(HocClkConfigValue_CsvWriteIntervalMs, ns, &gLastCsvWriteNs)) {
+            fileUtils::WriteContextToCsv(&gContext);
+        }
+
+        // this->context->maxDisplayFreq = board::GetHighestDockedDisplayRate();
+        u32 targetHz = gContext.overrideFreqs[HocClkModule_Display];
+        if (!targetHz) {
+            targetHz = config::GetAutoClockHz(gContext.applicationId, HocClkModule_Display, gContext.profile, true);
+            if (!targetHz)
+                targetHz = config::GetAutoClockHz(HOCCLK_GLOBAL_PROFILE_TID, HocClkModule_Display, gContext.profile, true);
+        }
+
+        if (board::GetConsoleType() != HocClkConsoleType_Hoag)
+            board::SetDisplayRefreshDockedState(gContext.profile == HocClkProfile_Docked);
+
+        if (gContext.isSaltyNXInstalled)
+            gContext.fps = integrations::GetSaltyNXFPS();
+        else
+            gContext.fps = 254; // N/A
+
+        if (gContext.isSaltyNXInstalled)
+            gContext.resolutionHeight = integrations::GetSaltyNXResolutionHeight();
+        else
+            gContext.resolutionHeight = 0; // N/A
+
+        return hasChanged;
+    }
+
+    void Initialize()
+    {
+        gContext = {};
+        gContext.applicationId = 0;
+        gContext.profile = HocClkProfile_Handheld;
+        for (unsigned int module = 0; module < HocClkModule_EnumMax; module++) {
+            gContext.freqs[module] = 0;
+            gContext.realFreqs[module] = 0;
+            gContext.overrideFreqs[module] = 0;
+
+            if (module < HocClkModuleStable_EnumMax) {
+                gContext.stable.freqs[module] = 0;
+                gContext.stable.realFreqs[module] = 0;
+                gContext.stable.overrideFreqs[module] = 0;
+            }
+
+            RefreshFreqTableRow((HocClkModule)module);
+        }
+
+        gRunning = false;
+        gLastTempLogNs = 0;
+        gLastCsvWriteNs = 0;
+
+        kip::GetKipData();
+
+        board::FuseData *fuse = board::GetFuseData();
+
+        gContext.speedos[HocClkSpeedo_CPU] = fuse->cpuSpeedo;
+        gContext.speedos[HocClkSpeedo_GPU] = fuse->gpuSpeedo;
+        gContext.speedos[HocClkSpeedo_SOC] = fuse->socSpeedo;
+        gContext.iddq[HocClkSpeedo_CPU] = fuse->cpuIDDQ;
+        gContext.iddq[HocClkSpeedo_GPU] = fuse->gpuIDDQ;
+        gContext.iddq[HocClkSpeedo_SOC] = fuse->socIDDQ;
+        gContext.waferX = fuse->waferX;
+        gContext.waferY = fuse->waferY;
+
+        gContext.dramID = board::GetDramID();
+        gContext.isDram8GB = board::IsDram8GB();
+        gContext.consoleType = board::GetConsoleType();
+        
+        board::SetGpuSchedulingMode((GpuSchedulingMode)config::GetConfigValue(HocClkConfigValue_GPUScheduling), (GpuSchedulingOverrideMethod)config::GetConfigValue(HocClkConfigValue_GPUSchedulingMethod));
+        gContext.gpuSchedulingMode = (GpuSchedulingMode)config::GetConfigValue(HocClkConfigValue_GPUScheduling);
+
+        gContext.isSysDockInstalled = integrations::GetSysDockState();
+        gContext.isSaltyNXInstalled = integrations::GetSaltyNXState();
+        if (gContext.isSaltyNXInstalled) {
+            integrations::LoadSaltyNX();
+        }
+
+        gContext.isUsingRetroSuper = integrations::GetRETROSuperStatus();
+        governor::startThreads();
+    }
+
+    void Exit()
+    {
+        governor::exitThreads();
+    }
+
+    HocClkContext GetCurrentContext()
+    {
+        std::scoped_lock lock{gContextMutex};
+        return gContext;
+    }
+
+    void SetRunning(bool running)
+    {
+        gRunning = running;
+    }
+
+    bool Running()
+    {
+        return gRunning;
+    }
+
+    void GetFreqList(HocClkModule module, std::uint32_t *list, std::uint32_t maxCount, std::uint32_t *outCount)
+    {
+        ASSERT_ENUM_VALID(HocClkModule, module);
+
+        *outCount = std::min(maxCount, gFreqTable[module].count);
+        memcpy(list, &gFreqTable[module].list[0], *outCount * sizeof(gFreqTable[0].list[0]));
+    }
+
+    void Tick()
+    {
+        std::scoped_lock lock{gContextMutex};
+        std::uint32_t mode = 0;
+        Result rc = apmExtGetCurrentPerformanceConfiguration(&mode);
+        ASSERT_RESULT_OK(rc, "apmExtGetCurrentPerformanceConfiguration");
+
+        bool isBoost = apmExtIsBoostMode(mode);
+
+        HandleSafetyFeatures();
+        HandleMiscFeatures();
+
+        if (RefreshContext() || config::Refresh()) {
+            SetClocks(isBoost);
+        }
+    }
+
+    void WaitForNextTick()
+    {
+        if (board::GetHz(HocClkModule_MEM) > 665000000)
+            svcSleepThread(config::GetConfigValue(HocClkConfigValue_PollingIntervalMs) * 1000000ULL);
+        else
+            svcSleepThread(5000 * 1000000ULL); // 5 seconds in sleep mode
+    }
+} // namespace clockManager

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

@@ -0,0 +1,69 @@
+/*
+ * 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/>.
+ *
+ */
+
+/* --------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <p-sam@d3vs.net>, <natinusala@gmail.com>, <m4x@m4xw.net>
+ * wrote this file. As long as you retain this notice you can do whatever you
+ * want with this stuff. If you meet any of us some day, and you think this
+ * stuff is worth it, you can buy us a beer in return.  - The sys-clk authors
+ * --------------------------------------------------------------------------
+ */
+
+#pragma once
+
+#include <hocclk.h>
+#include <switch.h>
+#include "../util/lockable_mutex.h"
+
+namespace clockManager {
+
+    struct FreqTable {
+        std::uint32_t count;
+        std::uint32_t list[HOCCLK_FREQ_LIST_MAX];
+    };
+
+
+    extern bool hasChanged;
+
+    // instance variables
+    extern bool gRunning;
+    extern LockableMutex gContextMutex;
+    extern HocClkContext gContext;
+    extern FreqTable gFreqTable[HocClkModule_EnumMax];
+    extern std::uint64_t gLastTempLogNs;
+    extern std::uint64_t gLastFreqLogNs;
+    extern std::uint64_t gLastPowerLogNs;
+    extern std::uint64_t gLastCsvWriteNs;
+
+
+    void Initialize();
+    void Exit();
+
+    HocClkContext GetCurrentContext();
+
+    void SetRunning(bool running);
+    bool Running();
+
+    std::uint32_t GetMaxAllowedHz(HocClkModule module, HocClkProfile profile);
+    bool IsAssignableHz(HocClkModule module, std::uint32_t hz);
+
+    void GetFreqList(HocClkModule module, std::uint32_t* list, std::uint32_t maxCount, std::uint32_t* outCount);
+
+    void Tick();
+    void WaitForNextTick();
+}

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

@@ -0,0 +1,301 @@
+/*
+ * Copyright (c) Souldbminer and Horizon OC Contributors
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "governor.hpp"
+#include "../hos/process_management.hpp"
+#include <hocclk/clock_manager.h>
+namespace governor {
+
+    #define POLL_NS 5'000'000  // 5 ms  – governor poll rate
+    #define DOWN_HOLD_TICKS 10         // 50 ms – how long to in POLL_NS to hold while ramping down
+    #define STEP_UTIL 900        // multiplier for step calculations
+
+    bool isGpuGovernorEnabled = false;
+    bool isCpuGovernorEnabled = false;
+    bool lastGpuGovernorState = false;
+    bool lastCpuGovernorState = false;
+    bool lastVrrGovernorState = false;
+    bool hasChanged = true;
+    bool isCpuGovernorInBoostMode = false;
+    bool isVRREnabled = false;
+
+    Thread governorTHREAD;
+
+    void HandleGovernor(uint32_t targetHz) {
+        u32 tempTargetHz = clockManager::gContext.overrideFreqs[HocClkModule_Governor];
+        if (!tempTargetHz) {
+            tempTargetHz = config::GetAutoClockHz(clockManager::gContext.applicationId, HocClkModule_Governor, clockManager::gContext.profile, true);
+            if (!tempTargetHz)
+                tempTargetHz = config::GetAutoClockHz(HOCCLK_GLOBAL_PROFILE_TID, HocClkModule_Governor, clockManager::gContext.profile, true);
+        }
+
+        auto resolve = [](u8 app, u8 temp) -> u8 {
+            if (temp == ComponentGovernor_Disabled) return ComponentGovernor_Disabled;
+            if (temp != ComponentGovernor_DoNotOverride) return temp;
+            return app;
+        };
+
+        u8 effectiveCpu = resolve(GovernorStateCpu(targetHz), GovernorStateCpu(tempTargetHz));
+        u8 effectiveGpu = resolve(GovernorStateGpu(targetHz), GovernorStateGpu(tempTargetHz));
+        u8 effectiveVrr = resolve(GovernorStateVrr(targetHz), GovernorStateVrr(tempTargetHz));
+
+        bool newCpuGovernorState = (effectiveCpu == ComponentGovernor_Enabled);
+        bool newGpuGovernorState = (effectiveGpu == ComponentGovernor_Enabled);
+        bool newVrrGovernorState = (effectiveVrr == ComponentGovernor_Enabled);
+
+        isCpuGovernorEnabled = newCpuGovernorState;
+        isGpuGovernorEnabled = newGpuGovernorState;
+        isVRREnabled = newVrrGovernorState;
+
+        if (newCpuGovernorState == false && lastCpuGovernorState == true)
+            board::ResetToStockCpu();
+        if (newGpuGovernorState == false && lastGpuGovernorState == true)
+            board::ResetToStockGpu();
+        if (newVrrGovernorState == false && lastVrrGovernorState == true)
+            board::ResetToStockDisplay();
+
+        if (newCpuGovernorState != lastCpuGovernorState || newGpuGovernorState != lastGpuGovernorState || newVrrGovernorState != lastVrrGovernorState) {
+            fileUtils::LogLine("[mgr] Governor state changed: CPU %s, GPU %s, VRR %s", newCpuGovernorState ? "enabled" : "disabled", newGpuGovernorState ? "enabled" : "disabled", newVrrGovernorState ? "enabled" : "disabled");
+            lastCpuGovernorState = newCpuGovernorState;
+            lastGpuGovernorState = newGpuGovernorState;
+            lastVrrGovernorState = newVrrGovernorState;
+        }
+    }
+
+    u32 SchedutilTargetHz(u32 util, u32 tableMaxHz) {
+        u64 hz = (u64)tableMaxHz * util / STEP_UTIL;
+        return (u32)(std::min(hz, static_cast<u64>(tableMaxHz)));
+    }
+
+    u32 TableIndexForHz(const clockManager::FreqTable& table, u32 targetHz) {
+        for (u32 i = 0; i < table.count; i++)
+            if (table.list[i] >= targetHz)
+                return i;
+        return table.count - 1;
+    }
+
+    u32 ResolveTargetHz(HocClkModule module) {
+        u32 hz = clockManager::gContext.overrideFreqs[module];
+        if (!hz)
+            hz = config::GetAutoClockHz(
+                    clockManager::gContext.applicationId, module,
+                    clockManager::gContext.profile, false);
+        if (!hz)
+            hz = config::GetAutoClockHz(
+                    HOCCLK_GLOBAL_PROFILE_TID, module,
+                    clockManager::gContext.profile, false);
+        return hz;
+    }
+
+    void GovernorThread(void* arg) {
+        (void)arg;
+
+        u32 cpuDownHoldRemaining = 0;
+        u32 cpuLastHz = 0;
+        u32 gpuDownHoldRemaining = 0;
+        u32 gpuLastHz = 0;
+        u32 minHz = 612;
+        u32 cpuTick = 0;
+        u8 vrrTick = 0;
+        u8 vrrFocusTick = 0;
+
+        for (;;) {
+
+            if (!clockManager::gRunning) {
+                cpuDownHoldRemaining = 0;
+                cpuLastHz = 0;
+                gpuDownHoldRemaining = 0;
+                gpuLastHz = 0;
+                svcSleepThread(POLL_NS);
+                continue;
+            }
+
+            if (isCpuGovernorEnabled) {
+                u32 mode = 0;
+                Result rc = apmExtGetCurrentPerformanceConfiguration(&mode);
+
+                if (R_SUCCEEDED(rc) && apmExtIsBoostMode(mode)) {
+                    isCpuGovernorInBoostMode = true;
+                    cpuDownHoldRemaining = 0;
+                    cpuLastHz = 0;
+                } else {
+                    isCpuGovernorInBoostMode = false;
+
+                    auto& table = clockManager::gFreqTable[HocClkModule_CPU];
+                    std::scoped_lock lock{clockManager::gContextMutex};
+
+                    u32 cpuLoad = board::GetPartLoad(HocClkPartLoad_CPUMax);
+                    u32 tableMaxHz = table.list[table.count - 1];
+                    u32 desiredHz = SchedutilTargetHz(cpuLoad, tableMaxHz);
+                    u32 targetHz = ResolveTargetHz(HocClkModule_CPU);
+                    u32 maxHz = clockManager::GetMaxAllowedHz(HocClkModule_CPU, clockManager::gContext.profile);
+
+                    if (targetHz && desiredHz > targetHz)
+                        desiredHz = targetHz;
+                    if (maxHz    && desiredHz > maxHz)
+                        desiredHz = maxHz;
+
+                    u32 newHz = table.list[TableIndexForHz(table, desiredHz)];
+                    bool goingDown = (cpuLastHz != 0) && (newHz < cpuLastHz);
+
+                    if (!goingDown)
+                        cpuDownHoldRemaining = 0;
+                    else if (cpuDownHoldRemaining == 0)
+                        cpuDownHoldRemaining = DOWN_HOLD_TICKS;
+
+                    if (cpuDownHoldRemaining > 0)
+                        cpuDownHoldRemaining--;
+
+                    if (++cpuTick > 50) {
+                        minHz = config::GetConfigValue(HocClkConfigValue_CpuGovernorMinimumFreq);
+                        cpuTick = 0;
+                    }
+
+                    if (newHz < minHz)
+                        newHz = minHz;
+
+                    if ((!goingDown || (cpuDownHoldRemaining == 0)) && clockManager::IsAssignableHz(HocClkModule_CPU, newHz)) {
+                        board::SetHz(HocClkModule_CPU, newHz);
+                        clockManager::gContext.freqs[HocClkModule_CPU] = newHz;
+                        clockManager::gContext.stable.freqs[HocClkModule_CPU] = newHz;
+                        cpuLastHz = newHz;
+                    }
+                }
+            } else {
+                isCpuGovernorInBoostMode = false;
+                cpuDownHoldRemaining = 0;
+                cpuLastHz = 0;
+            }
+
+            if (isGpuGovernorEnabled) {
+                auto& table = clockManager::gFreqTable[HocClkModule_GPU];
+                std::scoped_lock lock{clockManager::gContextMutex};
+
+                u32 gpuLoad = board::GetPartLoad(HocClkPartLoad_GPU);
+                u32 tableMaxHz = table.list[table.count - 1];
+                u32 desiredHz = SchedutilTargetHz(gpuLoad, tableMaxHz);
+                u32 targetHz = ResolveTargetHz(HocClkModule_GPU);
+                u32 maxHz = clockManager::GetMaxAllowedHz(HocClkModule_GPU, clockManager::gContext.profile);
+
+                if (targetHz && desiredHz > targetHz)
+                    desiredHz = targetHz;
+                if (maxHz    && desiredHz > maxHz)
+                    desiredHz = maxHz;
+
+                u32 newHz = table.list[TableIndexForHz(table, desiredHz)];
+                bool goingDown = (gpuLastHz != 0) && (newHz < gpuLastHz);
+
+                if (!goingDown)
+                    gpuDownHoldRemaining = 0;
+                else if (gpuDownHoldRemaining == 0)
+                    gpuDownHoldRemaining = DOWN_HOLD_TICKS;
+
+                if (gpuDownHoldRemaining > 0)
+                    gpuDownHoldRemaining--;
+
+                if ((!goingDown || (gpuDownHoldRemaining == 0)) && clockManager::IsAssignableHz(HocClkModule_GPU, newHz)) {
+                    board::SetHz(HocClkModule_GPU, newHz);
+                    clockManager::gContext.freqs[HocClkModule_GPU] = newHz;
+                    clockManager::gContext.stable.freqs[HocClkModule_GPU] = newHz;
+                    gpuLastHz = newHz;
+                }
+            } else {
+                gpuDownHoldRemaining = 0;
+                gpuLastHz = 0;
+            }
+
+            if (isVRREnabled && clockManager::gContext.profile != HocClkProfile_Docked && clockManager::gContext.isSaltyNXInstalled) {
+                bool skipVrr = false;
+
+                if (++vrrFocusTick > 100) {
+                    vrrFocusTick = 0;
+                    bool isApplicationOutOfFocus = false;
+                    Result rc = processManagement::isApplicationOutOfFocus(&isApplicationOutOfFocus);
+                    if (R_FAILED(rc) || isApplicationOutOfFocus) {
+                        board::ResetToStockDisplay();
+                        skipVrr = true;
+                    }
+                }
+
+                if (!skipVrr) {
+                    u8 fps = integrations::GetSaltyNXFPS();
+
+                    if (fps != 254) {
+                        std::scoped_lock lock{clockManager::gContextMutex};
+
+                        u32 targetHz = clockManager::gContext.overrideFreqs[HocClkModule_Display];
+                        if (!targetHz) {
+                            targetHz = config::GetAutoClockHz(clockManager::gContext.applicationId, HocClkModule_Display, clockManager::gContext.profile, false);
+                            if (!targetHz)
+                                targetHz = config::GetAutoClockHz(HOCCLK_GLOBAL_PROFILE_TID, HocClkModule_Display, clockManager::gContext.profile, false);
+                        }
+
+                        u8 maxDisplay = targetHz ? (u8)targetHz : 60;
+                        u8 minDisplay = board::GetConsoleType() == HocClkConsoleType_Aula ? 45 : 40;
+
+                        if (maxDisplay != minDisplay) {
+                            if (fps >= minDisplay && fps <= maxDisplay) {
+                                board::SetHz(HocClkModule_Display, fps);
+                                clockManager::gContext.freqs[HocClkModule_Display] = fps;
+                                clockManager::gContext.realFreqs[HocClkModule_Display] = fps;
+                                clockManager::gContext.stable.freqs[HocClkModule_Display] = fps;
+                                clockManager::gContext.stable.realFreqs[HocClkModule_Display] = fps;
+                            } else {
+                                for (u32 i = 0; i < 10; i++) {
+                                    u32 compareHz = fps * i;
+                                    if (compareHz >= minDisplay && compareHz <= maxDisplay) {
+                                        board::SetHz(HocClkModule_Display, compareHz);
+                                        clockManager::gContext.freqs[HocClkModule_Display] = compareHz;
+                                        clockManager::gContext.realFreqs[HocClkModule_Display] = compareHz;
+                                        clockManager::gContext.stable.freqs[HocClkModule_Display] = compareHz;
+                                        clockManager::gContext.stable.realFreqs[HocClkModule_Display] = compareHz;
+                                        break;
+                                    }
+                                }
+                            }
+
+                            if (++vrrTick > 50) {
+                                vrrTick = 0;
+                                board::SetHz(HocClkModule_Display, maxDisplay);
+                                svcSleepThread(50'000'000);
+                            }
+                        }
+                    }
+                }
+            }
+
+            svcSleepThread(POLL_NS);
+        }
+    }
+
+    void startThreads() {
+        threadCreate(
+            &governorTHREAD,
+            GovernorThread,
+            nullptr,
+            NULL,
+            0x2000,
+            0x3F,
+            -2
+        );
+        threadStart(&governorTHREAD);
+    }
+
+    void exitThreads() {
+        threadClose(&governorTHREAD);
+    }
+}

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

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Souldbminer and Horizon OC Contributors
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <switch.h>
+#include <hocclk.h>
+#include "../board/board.hpp"
+#include "clock_manager.hpp"
+#include <cstring>
+#include "../file/file_utils.hpp"
+#include "../board/board.hpp"
+#include "../file/errors.hpp"
+#include "../file/config.hpp"
+#include "../hos/integrations.hpp"
+#include "../util/lockable_mutex.h"
+
+namespace governor {
+    extern bool isCpuGovernorInBoostMode;
+    extern bool isVRREnabled;
+    extern bool isGpuGovernorEnabled;
+    extern bool isCpuGovernorEnabled;
+    extern bool lastGpuGovernorState;
+    extern bool lastCpuGovernorState;
+    extern bool lastVrrGovernorState;
+    void startThreads();
+    void exitThreads();
+    void HandleGovernor(uint32_t targetHz);
+}