OmniNX/Horizon-OC
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

hoc-sys/loader/config-pc/config-device - move unsafe freqs setting to hoc-sys

Browse Source 
This allows stuff to be changed on the fly
This commit is contained in:
souldbminersmwc
2025-10-23 15:54:20 -04:00
parent e14fed0be9
commit 708be969cb
28 changed files with 309 additions and 450 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Source/sys-clk/common/include/sysclk/board.h
View File

@@ -36,6 +36,8 @@ typedef enum
SysClkModule_CPU = 0,
SysClkModule_GPU,
SysClkModule_MEM,
HocClkModule_CPUUndervolt,
HocClkModule_GPUUndervolt,
SysClkModule_EnumMax
} SysClkModule;

4
Source/sys-clk/common/include/sysclk/clock_manager.h
View File

@@ -30,8 +30,8 @@ typedef struct
typedef struct
{
union {
uint32_t mhz[SysClkProfile_EnumMax * SysClkModule_EnumMax];
uint32_t mhzMap[SysClkProfile_EnumMax][SysClkModule_EnumMax];
uint32_t mhz[(uint32_t)SysClkProfile_EnumMax * (uint32_t)SysClkModule_EnumMax];
uint32_t mhzMap[(uint32_t)SysClkProfile_EnumMax][(uint32_t)SysClkModule_EnumMax];
};
} SysClkTitleProfileList;

40
Source/sys-clk/common/include/sysclk/config.h
View File

@@ -15,16 +15,15 @@
typedef enum {
SysClkConfigValue_PollingIntervalMs = 0,
SysClkConfigValue_TempLogIntervalMs,
SysClkConfigValue_FreqLogIntervalMs,
SysClkConfigValue_PowerLogIntervalMs,
SysClkConfigValue_CsvWriteIntervalMs,
HocClkConfigValue_UncappedClocks,
HocClkConfigValue_OverwriteBoostMode,
HocClkConfigValue_SyncReverseNXMode,
HocClkConfigValue_DockedGovernor,
HocClkConfigValue_HandheldGovernor,
SysClkConfigValue_EnumMax,
SysClkConfigValue_TempLogIntervalMs = 1,
SysClkConfigValue_FreqLogIntervalMs = 2,
SysClkConfigValue_PowerLogIntervalMs = 3,
SysClkConfigValue_CsvWriteIntervalMs = 4,
HocClkConfigValue_UncappedClocks = 5,
HocClkConfigValue_OverwriteBoostMode = 6,
HocClkConfigValue_MaxCpuClock = 7,
HocClkConfigValue_MaxGpuClock = 8,
SysClkConfigValue_EnumMax = 9,
} SysClkConfigValue;
typedef struct {
@@ -49,14 +48,12 @@ static inline const char* sysclkFormatConfigValue(SysClkConfigValue val, bool pr
return pretty ? "Uncapped Clocks" : "uncapped_clocks";
case HocClkConfigValue_OverwriteBoostMode:
return pretty ? "Overwrite Boost Mode" : "ow_boost";
case HocClkConfigValue_SyncReverseNXMode:
return pretty ? "ReverseNX Sync" : "rnx_sync";
case HocClkConfigValue_DockedGovernor:
return pretty ? "Docked Governor" : "governor_d";
case HocClkConfigValue_HandheldGovernor:
return pretty ? "Handheld Governor" : "governor_hh";
case HocClkConfigValue_MaxCpuClock:
return pretty ? "Max CPU Clock" : "cpu_max";
case HocClkConfigValue_MaxGpuClock:
return pretty ? "Max GPU Clock" : "gpu_max";
default:
return NULL;
return pretty ? "Null" : "null";
}
}
@@ -72,8 +69,11 @@ static inline uint64_t sysclkDefaultConfigValue(SysClkConfigValue val)
case SysClkConfigValue_CsvWriteIntervalMs:
case HocClkConfigValue_UncappedClocks:
case HocClkConfigValue_OverwriteBoostMode:
case HocClkConfigValue_SyncReverseNXMode:
return 0ULL;
case HocClkConfigValue_MaxCpuClock:
return 1785ULL;
case HocClkConfigValue_MaxGpuClock:
return 921ULL;
default:
return 0ULL;
}
@@ -92,8 +92,10 @@ static inline uint64_t sysclkValidConfigValue(SysClkConfigValue val, uint64_t in
return input >= 0;
case HocClkConfigValue_OverwriteBoostMode:
case HocClkConfigValue_UncappedClocks:
case HocClkConfigValue_SyncReverseNXMode:
return (input & 0x1) == input;
case HocClkConfigValue_MaxCpuClock:
case HocClkConfigValue_MaxGpuClock:
return input > 0;
default:
return false;
}

1
Source/sys-clk/common/include/sysclk/errors.h
View File

@@ -18,4 +18,5 @@ typedef enum
SysClkError_Generic = 0,
SysClkError_ConfigNotLoaded = 1,
SysClkError_ConfigSaveFailed = 2,
HocClkError_SocThermFail = 3,
} SysClkError;

10
Source/sys-clk/manager/src/app_profiles_tab.cpp
View File

@@ -87,11 +87,11 @@ AppProfilesTab::AppProfilesTab()
}
// Name
if (!langEntry->name)
{
i++;
continue;
}
// if (!langEntry->name)
// {
// i++;
// continue;
// }
Title* title = (Title*) malloc(sizeof(Title));
title->tid = tid;

3
Source/sys-clk/overlay/src/ui/gui/app_profile_gui.cpp
View File

@@ -46,7 +46,8 @@ void AppProfileGui::openFreqChoiceGui(tsl::elm::ListItem* listItem, SysClkProfil
}
return true;
});
}, true
);
}
void AppProfileGui::addModuleListItem(SysClkProfile profile, SysClkModule module)

23
Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.cpp
View File

@@ -13,15 +13,21 @@
#include "../format.h"
#include "fatal_gui.h"
FreqChoiceGui::FreqChoiceGui(std::uint32_t selectedHz, std::uint32_t *hzList, std::uint32_t hzCount, SysClkModule module, FreqChoiceListener listener)
FreqChoiceGui::FreqChoiceGui(std::uint32_t selectedHz, std::uint32_t *hzList, std::uint32_t hzCount, SysClkModule module, FreqChoiceListener listener, bool checkMax)
{
this->selectedHz = selectedHz;
this->hzList = hzList;
this->hzCount = hzCount;
this->module = module; // Add this
this->module = module;
this->listener = listener;
this->checkMax = checkMax;
this->configList = new SysClkConfigValueList {};
}
FreqChoiceGui::~FreqChoiceGui()
{
delete this->configList;
}
tsl::elm::ListItem* FreqChoiceGui::createFreqListItem(std::uint32_t hz, bool selected, int safety)
{
std::string text = formatListFreqHz(hz);
@@ -61,6 +67,7 @@
void FreqChoiceGui::listUI()
{
sysclkIpcGetConfigValues(this->configList);
// Add CategoryHeader based on module
std::string moduleName = sysclkFormatModule(this->module, false);
this->listElement->addItem(new tsl::elm::CategoryHeader(moduleName));
@@ -72,6 +79,16 @@
hz = this->hzList[i];
uint32_t mhz = hz / 1000000;
// Skip 204 MHz exactly
if(checkMax) {
if (this->configList->values[HocClkConfigValue_MaxCpuClock] < mhz && moduleName == "cpu") {
continue;
}
if (this->configList->values[HocClkConfigValue_MaxGpuClock] < mhz&& moduleName == "gpu") {
continue;
}
}
if (moduleName == "mem" && mhz <= 600)
{
continue;

33
Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.h
View File

@@ -11,7 +11,7 @@
#pragma once
#include <list>
#include <functional>
#include "base_menu_gui.h"
using FreqChoiceListener = std::function<bool(std::uint32_t hz)>;
@@ -20,16 +20,25 @@ using FreqChoiceListener = std::function<bool(std::uint32_t hz)>;
class FreqChoiceGui : public BaseMenuGui
{
protected:
std::uint32_t selectedHz;
std::uint32_t* hzList;
std::uint32_t hzCount;
SysClkModule module; // Added
FreqChoiceListener listener;
tsl::elm::ListItem* createFreqListItem(std::uint32_t hz, bool selected, int safety);
protected:
SysClkConfigValueList* configList;
std::uint32_t selectedHz;
std::uint32_t* hzList;
std::uint32_t hzCount;
SysClkModule module; // added module
FreqChoiceListener listener;
bool checkMax; // new member
tsl::elm::ListItem* createFreqListItem(std::uint32_t hz, bool selected, int safety);
public:
FreqChoiceGui(std::uint32_t selectedHz, std::uint32_t* hzList, std::uint32_t hzCount, SysClkModule module, FreqChoiceListener listener);
~FreqChoiceGui() {}
void listUI() override;
public:
// Updated constructor with checkMaxValue
FreqChoiceGui(std::uint32_t selectedHz,
std::uint32_t* hzList,
std::uint32_t hzCount,
SysClkModule module,
FreqChoiceListener listener,
bool checkMax = true);
~FreqChoiceGui();
void listUI() override;
};

2
Source/sys-clk/overlay/src/ui/gui/global_override_gui.cpp
View File

@@ -44,7 +44,7 @@ void GlobalOverrideGui::openFreqChoiceGui(SysClkModule module)
this->context->overrideFreqs[module] = hz;
return true;
});
}, true);
}
void GlobalOverrideGui::addModuleListItem(SysClkModule module)

94
Source/sys-clk/overlay/src/ui/gui/misc_gui.cpp
View File

@@ -3,7 +3,7 @@
#include "../format.h"
#include <cstdio>
#include <cstring>
//#include <sstream>
#include <vector>
MiscGui::MiscGui()
{
@@ -14,9 +14,10 @@ MiscGui::~MiscGui()
{
delete this->configList;
this->configToggles.clear();
this->configTrackbars.clear();
}
void MiscGui::addConfigToggle(SysClkConfigValue configVal, const char* altName = nullptr) {
void MiscGui::addConfigToggle(SysClkConfigValue configVal, const char* altName) {
const char* configName = altName ? altName : sysclkFormatConfigValue(configVal, true);
tsl::elm::ToggleListItem* toggle = new tsl::elm::ToggleListItem(configName, this->configList->values[configVal]);
toggle->setStateChangedListener([this, configVal](bool state) {
@@ -24,13 +25,74 @@ void MiscGui::addConfigToggle(SysClkConfigValue configVal, const char* altName =
Result rc = sysclkIpcSetConfigValues(this->configList);
if (R_FAILED(rc))
FatalGui::openWithResultCode("sysclkIpcSetConfigValues", rc);
this->lastContextUpdate = armGetSystemTick();
});
this->listElement->addItem(toggle);
this->configToggles[configVal] = toggle;
}
void MiscGui::addConfigButton(SysClkConfigValue configVal, const char* altName, SysClkModule module) {
const char* configName = altName ? altName : sysclkFormatConfigValue(configVal, true);
// Create button list item
tsl::elm::ListItem* listItem = new tsl::elm::ListItem(configName);
// Set initial label text (MHz)
uint64_t currentMHz = this->configList->values[configVal];
char valueText[32];
snprintf(valueText, sizeof(valueText), "%lu MHz", currentMHz);
listItem->setValue(valueText);
// Click listener to open FreqChoiceGui
listItem->setClickListener([this, configVal, module](u64 keys) {
if ((keys & HidNpadButton_A) == 0)
return false;
std::uint32_t hzList[SYSCLK_FREQ_LIST_MAX];
std::uint32_t hzCount;
// Get frequency list from sys-clk
Result rc = sysclkIpcGetFreqList(module, hzList, SYSCLK_FREQ_LIST_MAX, &hzCount);
if (R_FAILED(rc)) {
FatalGui::openWithResultCode("sysclkIpcGetFreqList", rc);
return false;
}
std::uint32_t currentHz = this->configList->values[configVal] * 1'000'000;
tsl::changeTo<FreqChoiceGui>(
currentHz,
hzList,
hzCount,
module,
[this, configVal](std::uint32_t hz) {
// Convert to MHz for config storage
uint64_t mhz = hz / 1'000'000;
this->configList->values[configVal] = mhz;
// Push new config value
Result rc = sysclkIpcSetConfigValues(this->configList);
if (R_FAILED(rc)) {
FatalGui::openWithResultCode("sysclkIpcSetConfigValues", rc);
return false;
}
this->lastContextUpdate = armGetSystemTick();
return true;
},
false
);
return true;
});
// Add to UI and internal map for refresh updates
this->listElement->addItem(listItem);
this->configButtons[configVal] = listItem;
}
void MiscGui::updateConfigToggles() {
for (const auto& [value, toggle] : this->configToggles) {
if (toggle != nullptr)
@@ -41,20 +103,28 @@ void MiscGui::updateConfigToggles() {
void MiscGui::listUI()
{
this->listElement->addItem(new tsl::elm::CategoryHeader("Config"));
addConfigToggle(HocClkConfigValue_UncappedClocks);
addConfigToggle(HocClkConfigValue_OverwriteBoostMode);
addConfigToggle(HocClkConfigValue_SyncReverseNXMode);
addConfigToggle(HocClkConfigValue_UncappedClocks, nullptr);
addConfigToggle(HocClkConfigValue_OverwriteBoostMode, nullptr);
addConfigButton(HocClkConfigValue_MaxCpuClock, nullptr, SysClkModule_CPU);
addConfigButton(HocClkConfigValue_MaxGpuClock, nullptr, SysClkModule_GPU);
}
void MiscGui::refresh() {
BaseMenuGui::refresh();
// Update the enabled toggle state
if (this->context && ++frameCounter >= 60)
{
if (this->context && ++frameCounter >= 60) {
frameCounter = 0;
sysclkIpcGetConfigValues(this->configList);
updateConfigToggles();
}
sysclkIpcGetConfigValues(this->configList);
updateConfigToggles();
for (const auto& [configVal, button] : this->configButtons) {
uint64_t mhz = this->configList->values[configVal];
char valueText[32];
snprintf(valueText, sizeof(valueText), "%lu MHz", mhz);
button->setValue(valueText);
}
}
}

38
Source/sys-clk/overlay/src/ui/gui/misc_gui.h
View File

@@ -3,23 +3,27 @@
#include "base_menu_gui.h"
#include <unordered_map>
#include <string>
#include <vector>
#include "freq_choice_gui.h"
class MiscGui : public BaseMenuGui
{
public:
MiscGui();
~MiscGui();
public:
MiscGui();
~MiscGui();
void listUI() override;
void refresh() override;
protected:
SysClkConfigValueList* configList;
std::map<SysClkConfigValue, tsl::elm::ToggleListItem*> configToggles;
void addConfigToggle(SysClkConfigValue, const char*);
void updateConfigToggles();
tsl::elm::ToggleListItem* enabledToggle;
u8 frameCounter = 60;
};
void listUI() override;
void refresh() override;
protected:
std::map<SysClkConfigValue, tsl::elm::ListItem*> configButtons;
SysClkConfigValueList* configList;
std::map<SysClkConfigValue, tsl::elm::ToggleListItem*> configToggles;
std::map<SysClkConfigValue, std::tuple<tsl::elm::TrackBar*, tsl::elm::ListItem*, std::vector<uint64_t>>> configTrackbars;
void addConfigToggle(SysClkConfigValue configVal, const char* altName);
void addConfigButton(SysClkConfigValue configVal, const char* altName, SysClkModule module);
void updateConfigToggles();
tsl::elm::ToggleListItem* enabledToggle;
u8 frameCounter = 60;
};

2
Source/sys-clk/sysmodule/src/clock_manager.cpp
View File

@@ -292,7 +292,7 @@ bool ClockManager::RefreshContext()
// restore clocks to stock values on app or profile change
if (hasChanged)
{
this->rnxSync->ToggleSync(this->GetConfig()->GetConfigValue(HocClkConfigValue_SyncReverseNXMode));
// this->rnxSync->ToggleSync(this->GetConfig()->GetConfigValue(HocClkConfigValue_SyncReverseNXMode));
Board::ResetToStock();
this->WaitForNextTick();
}

2
Source/sys-clk/sysmodule/src/config.cpp
View File

@@ -419,7 +419,7 @@ bool Config::SetConfigValues(SysClkConfigValueList* configValues, bool immediate
char* iniValues[SysClkConfigValue_EnumMax + 1];
// char arrays to build strings
char valuesStr[SysClkConfigValue_EnumMax * 0x20];
char valuesStr[SysClkConfigValue_EnumMax * 0x80];
// Iteration pointers
char* sv = &valuesStr[0];