From 3a2f113d257026ba2ef22954920c2a74913884d9 Mon Sep 17 00:00:00 2001 From: souldbminersmwc Date: Sat, 13 Dec 2025 16:48:55 -0500 Subject: [PATCH] sysclk: add kip editing feature --- Source/Configurator/src/settings.py | 3 + Source/Horizon-OC-Monitor/source/Utils.hpp | 18 +- .../source/modes/FPS_Graph.hpp | 4 +- .../Horizon-OC-Monitor/source/modes/Full.hpp | 2 +- .../Horizon-OC-Monitor/source/modes/Micro.hpp | 2 +- .../Horizon-OC-Monitor/source/modes/Mini.hpp | 2 +- Source/Horizon-OC-Monitor/source/sysclk_ipc.c | 128 ------ .../common/include/sysclk/client/ipc.h | 2 + Source/sys-clk/common/include/sysclk/config.h | 176 +++++--- Source/sys-clk/common/src/client/ipc.c | 4 +- .../overlay/src/ui/gui/freq_choice_gui.cpp | 312 +++++++------- .../overlay/src/ui/gui/freq_choice_gui.h | 15 +- .../sys-clk/overlay/src/ui/gui/misc_gui.cpp | 210 ++++++--- Source/sys-clk/overlay/src/ui/gui/misc_gui.h | 9 +- .../overlay/src/ui/gui/value_choice_gui.cpp | 228 +++++----- .../overlay/src/ui/gui/value_choice_gui.h | 123 +++--- .../sys-clk/sysmodule/src/clock_manager.cpp | 307 ++++++-------- Source/sys-clk/sysmodule/src/clock_manager.h | 1 - Source/sys-clk/sysmodule/src/config.cpp | 65 ++- Source/sys-clk/sysmodule/src/config.h | 2 +- Source/sys-clk/sysmodule/src/ipc_service.cpp | 9 +- Source/sys-clk/sysmodule/src/kip.h | 398 ++++++++++++++++++ Source/sys-clk/sysmodule/src/kip_handler.h | 182 -------- dist/README.md | 63 +-- .../contents/00FF0000636C6BFF/exefs.nsp | Bin 185515 -> 194680 bytes .../contents/00FF0000636C6BFF/toolbox.json | 2 +- 26 files changed, 1252 insertions(+), 1015 deletions(-) delete mode 100644 Source/Horizon-OC-Monitor/source/sysclk_ipc.c create mode 100644 Source/sys-clk/sysmodule/src/kip.h delete mode 100644 Source/sys-clk/sysmodule/src/kip_handler.h diff --git a/Source/Configurator/src/settings.py b/Source/Configurator/src/settings.py index 65282019..385d6a6b 100644 --- a/Source/Configurator/src/settings.py +++ b/Source/Configurator/src/settings.py @@ -102,6 +102,7 @@ variables = [ ("commonGpuVoltOffset", "u32"), # advanced config + ("gpuSpeedo", "u32"), ("marikoGpuFullUnlock", "u32"), @@ -215,6 +216,8 @@ def load_all_vars(): c.load_entry_object("marikoGpuVmax", 3) c.load_entry_object("commonGpuVoltOffset", 3) + c.load_entry_object("gpuSpeedo", 3) + c.load_entry_object("marikoGpuFullUnlock", 3) erista_freqs = [ diff --git a/Source/Horizon-OC-Monitor/source/Utils.hpp b/Source/Horizon-OC-Monitor/source/Utils.hpp index eff2c6da..0aa772f8 100644 --- a/Source/Horizon-OC-Monitor/source/Utils.hpp +++ b/Source/Horizon-OC-Monitor/source/Utils.hpp @@ -18,14 +18,13 @@ #include "rgltr_services.h" // for extern Service g_rgltrSrv, etc. +#include "../../sys-clk/common/include/sysclk/client/ipc.h" #if defined(__cplusplus) extern "C" { #endif -#include - #if defined(__cplusplus) } #endif @@ -576,16 +575,13 @@ void Misc(void*) { realCPU_Hz = sysclkCTX.realFreqs[SysClkModule_CPU]; realGPU_Hz = sysclkCTX.realFreqs[SysClkModule_GPU]; realRAM_Hz = sysclkCTX.realFreqs[SysClkModule_MEM]; - ramLoad[SysClkRamLoad_All] = sysclkCTX.ramLoad[SysClkRamLoad_All]; - ramLoad[SysClkRamLoad_Cpu] = sysclkCTX.ramLoad[SysClkRamLoad_Cpu]; + ramLoad[SysClkPartLoad_EMC] = sysclkCTX.PartLoad[SysClkPartLoad_EMC]; + ramLoad[SysClkPartLoad_EMCCpu] = sysclkCTX.ramLoad[SysClkPartLoad_EMCCpu]; - // If using EOS, get voltages from sys-clk - if (isUsingEOS && realVoltsPolling) { - realCPU_mV = sysclkCTX.realVolts[0]; - realGPU_mV = sysclkCTX.realVolts[1]; - realRAM_mV = sysclkCTX.realVolts[2]; - realSOC_mV = sysclkCTX.realVolts[3]; - } + realCPU_mV = sysclkCTX.voltages[HocClkVoltage_CPU]; + realGPU_mV = sysclkCTX.realVolts[HocClkVoltage_GPU]; + realRAM_mV = sysclkCTX.realVolts[HocClkVoltage_EMCVDD2]; + realSOC_mV = sysclkCTX.realVolts[HocClkVoltage_SOC]; } } diff --git a/Source/Horizon-OC-Monitor/source/modes/FPS_Graph.hpp b/Source/Horizon-OC-Monitor/source/modes/FPS_Graph.hpp index 5b001f56..22a2da29 100644 --- a/Source/Horizon-OC-Monitor/source/modes/FPS_Graph.hpp +++ b/Source/Horizon-OC-Monitor/source/modes/FPS_Graph.hpp @@ -496,8 +496,8 @@ public: snprintf(CPU_Load_c, sizeof(CPU_Load_c), "%.1f%%", cpu_usageM); snprintf(GPU_Load_c, sizeof(GPU_Load_c), "%d.%d%%", GPU_Load_u / 10, GPU_Load_u % 10); snprintf(RAM_Load_c, sizeof(RAM_Load_c), "%hu.%hhu%%", - ramLoad[SysClkRamLoad_All] / 10, - ramLoad[SysClkRamLoad_All] % 10); + PartLoad[SysClkPartLoad_EMC] / 10, + PartLoad[SysClkPartLoad_EMC] % 10); mutexUnlock(&mutex_Misc); diff --git a/Source/Horizon-OC-Monitor/source/modes/Full.hpp b/Source/Horizon-OC-Monitor/source/modes/Full.hpp index 239d6f8b..e4b1e6b7 100644 --- a/Source/Horizon-OC-Monitor/source/modes/Full.hpp +++ b/Source/Horizon-OC-Monitor/source/modes/Full.hpp @@ -446,7 +446,7 @@ public: ); if (R_SUCCEEDED(sysclkCheck)) { - const int RAM_GPU_Load = ramLoad[SysClkRamLoad_All] - ramLoad[SysClkRamLoad_Cpu]; + const int RAM_GPU_Load = PartLoad[SysClkPartLoad_EMC] - PartLoad[SysClkPartLoad_EMCCpu]; snprintf(RAM_load_c, sizeof RAM_load_c, "%u.%u%% CPU %u.%u%% GPU %u.%u%%", ramLoad[SysClkRamLoad_All] / 10, ramLoad[SysClkRamLoad_All] % 10, diff --git a/Source/Horizon-OC-Monitor/source/modes/Micro.hpp b/Source/Horizon-OC-Monitor/source/modes/Micro.hpp index 5537cbb3..69b9207a 100644 --- a/Source/Horizon-OC-Monitor/source/modes/Micro.hpp +++ b/Source/Horizon-OC-Monitor/source/modes/Micro.hpp @@ -821,7 +821,7 @@ public: if (R_SUCCEEDED(sysclkCheck)) { // Use sys-clk's RAM load if available snprintf(MICRO_RAM_all_c, sizeof(MICRO_RAM_all_c), "%hu%%", - ramLoad[SysClkRamLoad_All] / 10); + PartLoad[SysClkPartLoad_EMC] / 10); } else { // Calculate percentage manually when sys-clk isn't available const uint64_t RAM_Total_all = RAM_Total_application_u + RAM_Total_applet_u + RAM_Total_system_u + RAM_Total_systemunsafe_u; diff --git a/Source/Horizon-OC-Monitor/source/modes/Mini.hpp b/Source/Horizon-OC-Monitor/source/modes/Mini.hpp index f44a7994..49e6e62d 100644 --- a/Source/Horizon-OC-Monitor/source/modes/Mini.hpp +++ b/Source/Horizon-OC-Monitor/source/modes/Mini.hpp @@ -994,7 +994,7 @@ public: unsigned ramLoadInt; if (R_SUCCEEDED(sysclkCheck)) { - ramLoadInt = ramLoad[SysClkRamLoad_All] / 10; + ramLoadInt = PartLoad[SysClkPartLoad_EMC] / 10; if (settings.showRAMLoadCPUGPU) { unsigned ramCpuLoadInt = ramLoad[SysClkRamLoad_Cpu] / 10; diff --git a/Source/Horizon-OC-Monitor/source/sysclk_ipc.c b/Source/Horizon-OC-Monitor/source/sysclk_ipc.c deleted file mode 100644 index 7c6e853c..00000000 --- a/Source/Horizon-OC-Monitor/source/sysclk_ipc.c +++ /dev/null @@ -1,128 +0,0 @@ -/* - * -------------------------------------------------------------------------- - * "THE BEER-WARE LICENSE" (Revision 42): - * , , - * 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 - * -------------------------------------------------------------------------- - */ - -#define NX_SERVICE_ASSUME_NON_DOMAIN -#include -#include -#include -#include - -static Service g_sysclkSrv; -static atomic_size_t g_refCnt; - -bool sysclkIpcRunning() -{ - Handle handle; - const bool running = R_FAILED(smRegisterService(&handle, smEncodeName(SYSCLK_IPC_SERVICE_NAME), false, 1)); - - if (!running) - { - smUnregisterService(smEncodeName(SYSCLK_IPC_SERVICE_NAME)); - } - - return running; -} - -Result sysclkIpcInitialize(void) -{ - Result rc = 0; - - g_refCnt++; - - if (serviceIsActive(&g_sysclkSrv)) - return 0; - - rc = smGetService(&g_sysclkSrv, SYSCLK_IPC_SERVICE_NAME); - - if (R_FAILED(rc)) sysclkIpcExit(); - - return rc; -} - -void sysclkIpcExit(void) -{ - if (--g_refCnt == 0) - { - serviceClose(&g_sysclkSrv); - } -} - -Result sysclkIpcGetAPIVersion(u32* out_ver) -{ - return serviceDispatchOut(&g_sysclkSrv, SysClkIpcCmd_GetApiVersion, *out_ver); -} - -Result sysclkIpcGetVersionString(char* out, size_t len) -{ - return serviceDispatch(&g_sysclkSrv, SysClkIpcCmd_GetVersionString, - .buffer_attrs = { SfBufferAttr_HipcMapAlias | SfBufferAttr_Out }, - .buffers = {{out, len}}, - ); -} - -Result sysclkIpcGetCurrentContext(SysClkContext* out_context) -{ - return serviceDispatchOut(&g_sysclkSrv, SysClkIpcCmd_GetCurrentContext, *out_context); -} - -Result sysclkIpcGetProfileCount(u64 tid, u8* out_count) -{ - return serviceDispatchInOut(&g_sysclkSrv, SysClkIpcCmd_GetProfileCount, tid, *out_count); -} - -Result sysclkIpcSetEnabled(bool enabled) -{ - u8 enabledRaw = (u8)enabled; - return serviceDispatchIn(&g_sysclkSrv, SysClkIpcCmd_SetEnabled, enabledRaw); -} - -Result sysclkIpcSetOverride(SysClkModule module, u32 hz) -{ - SysClkIpc_SetOverride_Args args = { - .module = module, - .hz = hz - }; - return serviceDispatchIn(&g_sysclkSrv, SysClkIpcCmd_SetOverride, args); -} - -Result sysclkIpcGetProfiles(u64 tid, SysClkTitleProfileList* out_profiles) -{ - return serviceDispatchInOut(&g_sysclkSrv, SysClkIpcCmd_GetProfiles, tid, *out_profiles); -} - -Result sysclkIpcSetProfiles(u64 tid, SysClkTitleProfileList* profiles) -{ - SysClkIpc_SetProfiles_Args args; - args.tid = tid; - memcpy(&args.profiles, profiles, sizeof(SysClkTitleProfileList)); - return serviceDispatchIn(&g_sysclkSrv, SysClkIpcCmd_SetProfiles, args); -} - -Result sysclkIpcGetConfigValues(SysClkConfigValueList* out_configValues) -{ - return serviceDispatchOut(&g_sysclkSrv, SysClkIpcCmd_GetConfigValues, *out_configValues); -} - -Result sysclkIpcSetConfigValues(SysClkConfigValueList* configValues) -{ - return serviceDispatchIn(&g_sysclkSrv, SysClkIpcCmd_SetConfigValues, *configValues); -} - -Result sysclkIpcGetFreqList(SysClkModule module, u32* list, u32 maxCount, u32* outCount) -{ - SysClkIpc_GetFreqList_Args args = { - .module = module, - .maxCount = maxCount - }; - return serviceDispatchInOut(&g_sysclkSrv, SysClkIpcCmd_GetFreqList, args, *outCount, - .buffer_attrs = { SfBufferAttr_HipcAutoSelect | SfBufferAttr_Out }, - .buffers = {{list, maxCount * sizeof(u32)}}, - ); -} \ No newline at end of file diff --git a/Source/sys-clk/common/include/sysclk/client/ipc.h b/Source/sys-clk/common/include/sysclk/client/ipc.h index 3f36d02e..b61a0511 100644 --- a/Source/sys-clk/common/include/sysclk/client/ipc.h +++ b/Source/sys-clk/common/include/sysclk/client/ipc.h @@ -49,6 +49,8 @@ Result sysclkIpcGetConfigValues(SysClkConfigValueList* out_configValues); Result sysclkIpcSetConfigValues(SysClkConfigValueList* configValues); Result sysclkIpcGetFreqList(SysClkModule module, u32* list, u32 maxCount, u32* outCount); Result sysclkIpcSetReverseNXRTMode(ReverseNXMode mode); +Result hocClkIpcSetKipData(); +Result hocClkIpcGetKipData(); static inline Result sysclkIpcRemoveOverride(SysClkModule module) { diff --git a/Source/sys-clk/common/include/sysclk/config.h b/Source/sys-clk/common/include/sysclk/config.h index c25cc9ce..7f21f21d 100644 --- a/Source/sys-clk/common/include/sysclk/config.h +++ b/Source/sys-clk/common/include/sysclk/config.h @@ -60,21 +60,18 @@ typedef enum { HocClkConfigValue_EnforceBoardLimit, - KipConfigValue_MTCConf, - KipConfigValue_commonCpuBoostClock, + KipConfigValue_custRev, + KipConfigValue_mtcConf, KipConfigValue_hpMode, + + /* EMC */ KipConfigValue_commonEmcMemVolt, - KipConfigValue_eristaCpuMaxVolt, KipConfigValue_eristaEmcMaxClock, - KipConfigValue_marikoCpuMaxVolt, KipConfigValue_marikoEmcMaxClock, KipConfigValue_marikoEmcVddqVolt, - KipConfigValue_marikoCpuUV, - KipConfigValue_marikoGpuUV, - KipConfigValue_eristaCpuUV, - KipConfigValue_eristaGpuUV, - KipConfigValue_commonGpuVoltOffset, - KipConfigValue_marikoEmcDvbShift, + KipConfigValue_emcDvbShift, + + /* Memory timings */ KipConfigValue_t1_tRCD, KipConfigValue_t2_tRP, KipConfigValue_t3_tRAS, @@ -83,20 +80,40 @@ typedef enum { KipConfigValue_t6_tRTW, KipConfigValue_t7_tWTR, KipConfigValue_t8_tREFI, - KipConfigValue_mem_burst_read_latency, KipConfigValue_mem_burst_write_latency, - KipConfigValue_marikoCpuHighVmin, - KipConfigValue_marikoCpuLowVmin, + /* CPU – Erista */ + KipConfigValue_eristaCpuUV, + KipConfigValue_eristaCpuMaxVolt, + /* CPU – Mariko */ + KipConfigValue_marikoCpuUVLow, + KipConfigValue_marikoCpuUVHigh, + KipConfigValue_tableConf, + KipConfigValue_marikoCpuLowVmin, + KipConfigValue_marikoCpuHighVmin, + KipConfigValue_marikoCpuMaxVolt, + + KipConfigValue_eristaCpuBoostClock, + KipConfigValue_marikoCpuBoostClock, + + /* GPU – Erista */ + KipConfigValue_eristaGpuUV, KipConfigValue_eristaGpuVmin, + + /* GPU – Mariko */ + KipConfigValue_marikoGpuUV, KipConfigValue_marikoGpuVmin, KipConfigValue_marikoGpuVmax, + KipConfigValue_commonGpuVoltOffset, + KipConfigValue_gpuSpeedo, KipConfigValue_marikoGpuFullUnlock, - // Mariko GPU voltages + /* ============================= */ + /* Mariko GPU voltages (24) */ + /* ============================= */ KipConfigValue_g_volt_76800, KipConfigValue_g_volt_153600, KipConfigValue_g_volt_230400, @@ -122,7 +139,9 @@ typedef enum { KipConfigValue_g_volt_1497600, KipConfigValue_g_volt_1536000, - // Erista GPU voltages + /* ============================= */ + /* Erista GPU voltages (27) */ + /* ============================= */ KipConfigValue_g_volt_e_76800, KipConfigValue_g_volt_e_115200, KipConfigValue_g_volt_e_153600, @@ -172,24 +191,25 @@ static inline const char* sysclkFormatConfigValue(SysClkConfigValue val, bool pr return pretty ? "Power logging interval (ms)" : "power_log_interval_ms"; case SysClkConfigValue_CsvWriteIntervalMs: return pretty ? "CSV write interval (ms)" : "csv_write_interval_ms"; + case HocClkConfigValue_UncappedClocks: return pretty ? "Uncapped Clocks" : "uncapped_clocks"; case HocClkConfigValue_OverwriteBoostMode: return pretty ? "Overwrite Boost Mode" : "ow_boost"; case HocClkConfigValue_EristaMaxCpuClock: - return pretty ? "Max CPU Clock" : "cpu_max_e"; + return pretty ? "Erista Max CPU Clock" : "cpu_max_e"; case HocClkConfigValue_EristaMaxGpuClock: - return pretty ? "Max GPU Clock" : "gpu_max_e"; + return pretty ? "Erista Max GPU Clock" : "gpu_max_e"; case HocClkConfigValue_EristaMaxMemClock: - return pretty ? "Max MEM Clock" : "mem_max_e"; + return pretty ? "Erista Max MEM Clock" : "mem_max_e"; case HocClkConfigValue_MarikoMaxCpuClock: - return pretty ? "Max CPU Clock" : "cpu_max_m"; + return pretty ? "Mariko Max CPU Clock" : "cpu_max_m"; case HocClkConfigValue_MarikoMaxGpuClock: - return pretty ? "Max GPU Clock" : "gpu_max_m"; + return pretty ? "Mariko Max GPU Clock" : "gpu_max_m"; case HocClkConfigValue_MarikoMaxMemClock: - return pretty ? "Max MEM Clock" : "mem_max_m"; + return pretty ? "Mariko Max MEM Clock" : "mem_max_m"; case HocClkConfigValue_ThermalThrottle: return pretty ? "Thermal Throttle" : "thermal_throttle"; @@ -197,53 +217,44 @@ static inline const char* sysclkFormatConfigValue(SysClkConfigValue val, bool pr case HocClkConfigValue_ThermalThrottleThreshold: return pretty ? "Thermal Throttle Threshold" : "thermal_throttle_threshold"; + case HocClkConfigValue_HandheldGovernor: + return pretty ? "Handheld Governor" : "governor"; case HocClkConfigValue_DockedGovernor: return pretty ? "Docked Governor" : "governor_docked"; - case HocClkConfigValue_HandheldGovernor: - return pretty ? "Governor" : "governor"; case HocClkConfigValue_HandheldTDP: return pretty ? "Handheld TDP" : "handheld_tdp"; case HocClkConfigValue_HandheldTDPLimit: - return pretty ? "TDP Limit" : "tdp_limit"; + return pretty ? "Handheld TDP Limit" : "tdp_limit"; case HocClkConfigValue_LiteTDPLimit: return pretty ? "Lite TDP Limit" : "tdp_limit_l"; - // KIP raw values not normally user-facing + case HocClkConfigValue_EnforceBoardLimit: + return pretty ? "Enforce Board Limit" : "enforce_board_limit"; // KIP config values - case KipConfigValue_MTCConf: + case KipConfigValue_custRev: + return pretty ? "Custom Revision" : "kip_cust_rev"; + case KipConfigValue_mtcConf: return pretty ? "MTC Config" : "kip_mtc_conf"; case KipConfigValue_hpMode: - return pretty ? "KIP HP Mode" : "kip_hp_mode"; - case KipConfigValue_commonCpuBoostClock: - return pretty ? "Common CPU Boost Clock" : "common_cpu_boost_clock"; + return pretty ? "HP Mode" : "kip_hp_mode"; + + // EMC case KipConfigValue_commonEmcMemVolt: return pretty ? "Common EMC/MEM Voltage" : "common_emc_mem_volt"; - case KipConfigValue_eristaCpuMaxVolt: - return pretty ? "Erista CPU Max Voltage" : "erista_cpu_max_volt"; case KipConfigValue_eristaEmcMaxClock: return pretty ? "Erista EMC Max Clock" : "erista_emc_max_clock"; - case KipConfigValue_marikoCpuMaxVolt: - return pretty ? "Mariko CPU Max Voltage" : "mariko_cpu_max_volt"; case KipConfigValue_marikoEmcMaxClock: return pretty ? "Mariko EMC Max Clock" : "mariko_emc_max_clock"; case KipConfigValue_marikoEmcVddqVolt: return pretty ? "Mariko EMC VDDQ Voltage" : "mariko_emc_vddq_volt"; - case KipConfigValue_marikoCpuUV: - return pretty ? "Mariko CPU Undervolt" : "mariko_cpu_uv"; - case KipConfigValue_marikoGpuUV: - return pretty ? "Mariko GPU Undervolt" : "mariko_gpu_uv"; - case KipConfigValue_eristaCpuUV: - return pretty ? "Erista CPU Undervolt" : "erista_cpu_uv"; - case KipConfigValue_eristaGpuUV: - return pretty ? "Erista GPU Undervolt" : "erista_gpu_uv"; - case KipConfigValue_commonGpuVoltOffset: - return pretty ? "Common GPU Voltage Offset" : "common_gpu_volt_offset"; - case KipConfigValue_marikoEmcDvbShift: - return pretty ? "Mariko EMC DVB Shift" : "mariko_emc_dvb_shift"; + case KipConfigValue_emcDvbShift: + return pretty ? "EMC DVB Shift" : "emc_dvb_shift"; + + // Memory timings case KipConfigValue_t1_tRCD: return pretty ? "t1 - tRCD" : "t1_trcd"; case KipConfigValue_t2_tRP: @@ -264,20 +275,54 @@ static inline const char* sysclkFormatConfigValue(SysClkConfigValue val, bool pr return pretty ? "Memory Burst Read Latency" : "mem_burst_read_latency"; case KipConfigValue_mem_burst_write_latency: return pretty ? "Memory Burst Write Latency" : "mem_burst_write_latency"; - case KipConfigValue_marikoCpuHighVmin: - return pretty ? "Mariko CPU High Vmin" : "mariko_cpu_high_vmin"; + + // CPU – Erista + case KipConfigValue_eristaCpuUV: + return pretty ? "Erista CPU Undervolt" : "erista_cpu_uv"; + case KipConfigValue_eristaCpuMaxVolt: + return pretty ? "Erista CPU Max Voltage" : "erista_cpu_max_volt"; + + // CPU – Mariko + case KipConfigValue_marikoCpuUVLow: + return pretty ? "Mariko CPU Undervolt (Low)" : "mariko_cpu_uv_low"; + case KipConfigValue_marikoCpuUVHigh: + return pretty ? "Mariko CPU Undervolt (High)" : "mariko_cpu_uv_high"; + case KipConfigValue_tableConf: + return pretty ? "Table Config" : "kip_table_conf"; case KipConfigValue_marikoCpuLowVmin: return pretty ? "Mariko CPU Low Vmin" : "mariko_cpu_low_vmin"; + case KipConfigValue_marikoCpuHighVmin: + return pretty ? "Mariko CPU High Vmin" : "mariko_cpu_high_vmin"; + case KipConfigValue_marikoCpuMaxVolt: + return pretty ? "Mariko CPU Max Voltage" : "mariko_cpu_max_volt"; + + case KipConfigValue_eristaCpuBoostClock: + return pretty ? "Erista CPU Boost Clock" : "erista_cpu_boost_clock"; + case KipConfigValue_marikoCpuBoostClock: + return pretty ? "Mariko CPU Boost Clock" : "mariko_cpu_boost_clock"; + + // GPU – Erista + case KipConfigValue_eristaGpuUV: + return pretty ? "Erista GPU Undervolt" : "erista_gpu_uv"; case KipConfigValue_eristaGpuVmin: return pretty ? "Erista GPU Vmin" : "erista_gpu_vmin"; + + // GPU – Mariko + case KipConfigValue_marikoGpuUV: + return pretty ? "Mariko GPU Undervolt" : "mariko_gpu_uv"; case KipConfigValue_marikoGpuVmin: return pretty ? "Mariko GPU Vmin" : "mariko_gpu_vmin"; case KipConfigValue_marikoGpuVmax: return pretty ? "Mariko GPU Vmax" : "mariko_gpu_vmax"; + + case KipConfigValue_commonGpuVoltOffset: + return pretty ? "Common GPU Voltage Offset" : "common_gpu_volt_offset"; + case KipConfigValue_gpuSpeedo: + return pretty ? "GPU Speedo" : "gpu_speedo"; case KipConfigValue_marikoGpuFullUnlock: return pretty ? "Mariko GPU Full Unlock" : "mariko_gpu_full_unlock"; - // Mariko GPU voltages + // Mariko GPU voltages (24) case KipConfigValue_g_volt_76800: return pretty ? "Mariko GPU Volt 76 MHz" : "g_volt_76800"; case KipConfigValue_g_volt_153600: return pretty ? "Mariko GPU Volt 153 MHz" : "g_volt_153600"; case KipConfigValue_g_volt_230400: return pretty ? "Mariko GPU Volt 230 MHz" : "g_volt_230400"; @@ -303,7 +348,7 @@ static inline const char* sysclkFormatConfigValue(SysClkConfigValue val, bool pr case KipConfigValue_g_volt_1497600: return pretty ? "Mariko GPU Volt 1497 MHz" : "g_volt_1497600"; case KipConfigValue_g_volt_1536000: return pretty ? "Mariko GPU Volt 1536 MHz" : "g_volt_1536000"; - // Erista GPU voltages + // Erista GPU voltages (27) case KipConfigValue_g_volt_e_76800: return pretty ? "Erista GPU Volt 76 MHz" : "g_volt_e_76800"; case KipConfigValue_g_volt_e_115200: return pretty ? "Erista GPU Volt 115 MHz" : "g_volt_e_115200"; case KipConfigValue_g_volt_e_153600: return pretty ? "Erista GPU Volt 153 MHz" : "g_volt_e_153600"; @@ -395,6 +440,7 @@ static inline uint64_t sysclkValidConfigValue(SysClkConfigValue val, uint64_t in case HocClkConfigValue_LiteTDPLimit: case SysClkConfigValue_PollingIntervalMs: return input > 0; + case SysClkConfigValue_TempLogIntervalMs: case SysClkConfigValue_FreqLogIntervalMs: case SysClkConfigValue_PowerLogIntervalMs: @@ -405,22 +451,17 @@ static inline uint64_t sysclkValidConfigValue(SysClkConfigValue val, uint64_t in case HocClkConfigValue_DockedGovernor: case HocClkConfigValue_HandheldGovernor: case HocClkConfigValue_HandheldTDP: + case HocClkConfigValue_EnforceBoardLimit: return (input & 0x1) == input; - case KipConfigValue_MTCConf: - case KipConfigValue_commonCpuBoostClock: + case KipConfigValue_custRev: + case KipConfigValue_mtcConf: + case KipConfigValue_hpMode: case KipConfigValue_commonEmcMemVolt: - case KipConfigValue_eristaCpuMaxVolt: case KipConfigValue_eristaEmcMaxClock: - case KipConfigValue_marikoCpuMaxVolt: case KipConfigValue_marikoEmcMaxClock: case KipConfigValue_marikoEmcVddqVolt: - case KipConfigValue_marikoCpuUV: - case KipConfigValue_marikoGpuUV: - case KipConfigValue_eristaCpuUV: - case KipConfigValue_eristaGpuUV: - case KipConfigValue_commonGpuVoltOffset: - case KipConfigValue_marikoEmcDvbShift: + case KipConfigValue_emcDvbShift: case KipConfigValue_t1_tRCD: case KipConfigValue_t2_tRP: case KipConfigValue_t3_tRAS: @@ -431,11 +472,23 @@ static inline uint64_t sysclkValidConfigValue(SysClkConfigValue val, uint64_t in case KipConfigValue_t8_tREFI: case KipConfigValue_mem_burst_read_latency: case KipConfigValue_mem_burst_write_latency: - case KipConfigValue_marikoCpuHighVmin: + case KipConfigValue_eristaCpuUV: + case KipConfigValue_eristaCpuMaxVolt: + case KipConfigValue_marikoCpuUVLow: + case KipConfigValue_marikoCpuUVHigh: + case KipConfigValue_tableConf: case KipConfigValue_marikoCpuLowVmin: + case KipConfigValue_marikoCpuHighVmin: + case KipConfigValue_marikoCpuMaxVolt: + case KipConfigValue_eristaCpuBoostClock: + case KipConfigValue_marikoCpuBoostClock: + case KipConfigValue_eristaGpuUV: case KipConfigValue_eristaGpuVmin: + case KipConfigValue_marikoGpuUV: case KipConfigValue_marikoGpuVmin: case KipConfigValue_marikoGpuVmax: + case KipConfigValue_commonGpuVoltOffset: + case KipConfigValue_gpuSpeedo: case KipConfigValue_marikoGpuFullUnlock: case KipConfigValue_g_volt_76800: case KipConfigValue_g_volt_153600: @@ -488,7 +541,8 @@ static inline uint64_t sysclkValidConfigValue(SysClkConfigValue val, uint64_t in case KipConfigValue_g_volt_e_998400: case KipConfigValue_g_volt_e_1036800: case KipConfigValue_g_volt_e_1075200: - return input >= 0; + return true; + default: return false; } diff --git a/Source/sys-clk/common/src/client/ipc.c b/Source/sys-clk/common/src/client/ipc.c index 85567a9f..93c67273 100644 --- a/Source/sys-clk/common/src/client/ipc.c +++ b/Source/sys-clk/common/src/client/ipc.c @@ -161,12 +161,12 @@ Result sysclkIpcSetReverseNXRTMode(ReverseNXMode mode) Result hocClkIpcSetKipData() { - u32 temp; + u32 temp = 0; return serviceDispatchIn(&g_sysclkSrv, HocClkIpcCmd_SetKipData, temp); } Result hocClkIpcGetKipData() { - u32 temp; + u32 temp = 0; return serviceDispatchIn(&g_sysclkSrv, HocClkIpcCmd_GetKipData, temp); } \ No newline at end of file diff --git a/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.cpp b/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.cpp index 0adfc561..79b6418b 100644 --- a/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.cpp +++ b/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.cpp @@ -25,154 +25,184 @@ */ - #include "freq_choice_gui.h" +#include "freq_choice_gui.h" + +#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, + bool checkMax, + std::map labels) +{ + this->selectedHz = selectedHz; + this->hzList = hzList; + this->hzCount = hzCount; + this->module = module; + this->listener = listener; + this->checkMax = checkMax; + this->labels = labels; // NEW + this->configList = new SysClkConfigValueList {}; +} - #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, bool checkMax) - { - this->selectedHz = selectedHz; - this->hzList = hzList; - this->hzCount = hzCount; - 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); - if (selected) text += " \uE14B"; - - tsl::elm::ListItem* listItem = new tsl::elm::ListItem(text, "", false); - - switch (safety) - { - case 0: - listItem->setTextColor(tsl::Color(255, 255, 255, 255)); - listItem->setValueColor(tsl::Color(255, 255, 255, 255)); - break; - case 1: - listItem->setTextColor(tsl::Color(255, 165, 0, 255)); - listItem->setValueColor(tsl::Color(255, 165, 0, 255)); - break; - case 2: - listItem->setTextColor(tsl::Color(255, 0, 0, 255)); - listItem->setValueColor(tsl::Color(255, 0, 0, 255)); - break; - } - - listItem->setClickListener([this, hz](u64 keys) - { - if ((keys & HidNpadButton_A) == HidNpadButton_A && this->listener) { - if (this->listener(hz)) { - tsl::goBack(); - } - return true; - } - return false; - }); - - return listItem; - } - - 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)); - - this->listElement->addItem(this->createFreqListItem(0, this->selectedHz == 0, false)); - std::uint32_t hz; - for (std::uint32_t i = 0; i < this->hzCount; i++) - { - hz = this->hzList[i]; - uint32_t mhz = hz / 1000000; - // Skip 204 MHz exactly - if(checkMax && IsMariko()) { - if (this->configList->values[HocClkConfigValue_MarikoMaxCpuClock] < mhz && moduleName == "cpu") { - continue; - } - - if (this->configList->values[HocClkConfigValue_MarikoMaxGpuClock] < mhz && moduleName == "gpu") { - continue; - } - if (this->configList->values[HocClkConfigValue_MarikoMaxMemClock] < mhz && moduleName == "mem") { - continue; - } - } else if (checkMax && IsErista()) { - if (this->configList->values[HocClkConfigValue_EristaMaxCpuClock] < mhz && moduleName == "cpu") { - continue; - } - - if (this->configList->values[HocClkConfigValue_EristaMaxGpuClock] < mhz && moduleName == "gpu") { - continue; - } - if (this->configList->values[HocClkConfigValue_EristaMaxMemClock] < mhz && moduleName == "mem") { - continue; - } - } - if (moduleName == "mem" && mhz <= 600) - { - continue; - } - uint32_t unsafe_cpu; - uint32_t unsafe_gpu; - uint32_t danger_cpu; - uint32_t danger_gpu; - if (IsMariko()) - { - unsafe_cpu = 1964; - unsafe_gpu = 1076; - danger_cpu = 2398; - danger_gpu = 1306; - } - else - { - unsafe_cpu = 1786; - unsafe_gpu = 922; - danger_cpu = 2092; - danger_gpu = 999; - } +tsl::elm::ListItem* FreqChoiceGui::createFreqListItem(std::uint32_t hz, bool selected, int safety) +{ + std::string text = formatListFreqHz(hz); + if (selected) + text += " \uE14B"; - if (moduleName == "cpu") { - if (mhz >= danger_cpu) { - this->listElement->addItem(this->createFreqListItem(hz, mhz == this->selectedHz / 1000000, 2)); - continue; - } - if (mhz >= unsafe_cpu) { - this->listElement->addItem(this->createFreqListItem(hz, mhz == this->selectedHz / 1000000, 1)); - continue; - } - if (mhz <= unsafe_cpu) { - this->listElement->addItem(this->createFreqListItem(hz, mhz == this->selectedHz / 1000000, 0)); + // NEW: Right-side label + std::string rightText = ""; + auto it = labels.find(hz); + if (it != labels.end()) + rightText = it->second; + + tsl::elm::ListItem* listItem = + new tsl::elm::ListItem(text, rightText, false); + + switch (safety) + { + case 0: + listItem->setTextColor(tsl::Color(255, 255, 255, 255)); + listItem->setValueColor(tsl::Color(255, 255, 255, 255)); + break; + case 1: + listItem->setTextColor(tsl::Color(255, 165, 0, 255)); + listItem->setValueColor(tsl::Color(255, 165, 0, 255)); + break; + case 2: + listItem->setTextColor(tsl::Color(255, 0, 0, 255)); + listItem->setValueColor(tsl::Color(255, 0, 0, 255)); + break; + } + + // Make annotation grey + if (!rightText.empty()) + listItem->setValueColor(tsl::Color(180, 180, 180, 255)); + + listItem->setClickListener([this, hz](u64 keys) + { + if ((keys & HidNpadButton_A) == HidNpadButton_A && this->listener) { + if (this->listener(hz)) { + tsl::goBack(); + } + return true; + } + return false; + }); + + return listItem; +} + +void FreqChoiceGui::listUI() +{ + sysclkIpcGetConfigValues(this->configList); + + // Header based on CPU/GPU/MEM module + std::string moduleName = sysclkFormatModule(this->module, false); + this->listElement->addItem(new tsl::elm::CategoryHeader(moduleName)); + + // Default option + this->listElement->addItem( + this->createFreqListItem(0, this->selectedHz == 0, 0)); + + for (std::uint32_t i = 0; i < this->hzCount; i++) + { + std::uint32_t hz = this->hzList[i]; + uint32_t mhz = hz / 1000000; + + if (checkMax && IsMariko()) { + if (moduleName == "cpu" && + this->configList->values[HocClkConfigValue_MarikoMaxCpuClock] < mhz) continue; - } - } else if (moduleName == "gpu") { - if (mhz >= danger_gpu) { - this->listElement->addItem(this->createFreqListItem(hz, mhz == this->selectedHz / 1000000, 2)); - continue; - } - if (mhz >= unsafe_gpu) { - this->listElement->addItem(this->createFreqListItem(hz, mhz == this->selectedHz / 1000000, 1)); - continue; - } - if (mhz <= unsafe_gpu) { - this->listElement->addItem(this->createFreqListItem(hz, mhz == this->selectedHz / 1000000, 0)); + + if (moduleName == "gpu" && + this->configList->values[HocClkConfigValue_MarikoMaxGpuClock] < mhz) continue; - } - } else if (moduleName == "mem") { - this->listElement->addItem(this->createFreqListItem(hz, mhz == this->selectedHz / 1000000, 0)); + + if (moduleName == "mem" && + this->configList->values[HocClkConfigValue_MarikoMaxMemClock] < mhz) + continue; + + } else if (checkMax && IsErista()) { + if (moduleName == "cpu" && + this->configList->values[HocClkConfigValue_EristaMaxCpuClock] < mhz) + continue; + + if (moduleName == "gpu" && + this->configList->values[HocClkConfigValue_EristaMaxGpuClock] < mhz) + continue; + + if (moduleName == "mem" && + this->configList->values[HocClkConfigValue_EristaMaxMemClock] < mhz) + continue; + } + + if (moduleName == "mem" && mhz <= 600) continue; - } - - } - this->listElement->jumpToItem("", ""); - } \ No newline at end of file + + uint32_t unsafe_cpu; + uint32_t unsafe_gpu; + uint32_t danger_cpu; + uint32_t danger_gpu; + + if (IsMariko()) + { + unsafe_cpu = 1964; + unsafe_gpu = 1076; + danger_cpu = 2398; + danger_gpu = 1306; + } + else + { + unsafe_cpu = 1786; + unsafe_gpu = 922; + danger_cpu = 2092; + danger_gpu = 999; + } + + int safety = 0; + + if (moduleName == "cpu") { + + if (mhz >= danger_cpu) + safety = 2; + else if (mhz >= unsafe_cpu) + safety = 1; + else + safety = 0; + + } else if (moduleName == "gpu") { + + if (mhz >= danger_gpu) + safety = 2; + else if (mhz >= unsafe_gpu) + safety = 1; + else + safety = 0; + + } else if (moduleName == "mem") { + + safety = 0; + + } + + this->listElement->addItem( + this->createFreqListItem( + hz, + (mhz == this->selectedHz / 1000000), + safety + ) + ); + } + + this->listElement->jumpToItem("", ""); +} \ No newline at end of file diff --git a/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.h b/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.h index cc13e2e9..085a2620 100644 --- a/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.h +++ b/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.h @@ -29,6 +29,7 @@ #include #include +#include #include "base_menu_gui.h" using FreqChoiceListener = std::function; @@ -42,20 +43,24 @@ protected: std::uint32_t selectedHz; std::uint32_t* hzList; std::uint32_t hzCount; - SysClkModule module; // added module + SysClkModule module; FreqChoiceListener listener; - bool checkMax; // new member + bool checkMax; + + std::map labels; + tsl::elm::ListItem* createFreqListItem(std::uint32_t hz, bool selected, int safety); 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); + bool checkMax = true, + std::map labels = {}); + ~FreqChoiceGui(); void listUI() override; -}; +}; \ No newline at end of file diff --git a/Source/sys-clk/overlay/src/ui/gui/misc_gui.cpp b/Source/sys-clk/overlay/src/ui/gui/misc_gui.cpp index 0ccac0b8..139221c9 100644 --- a/Source/sys-clk/overlay/src/ui/gui/misc_gui.cpp +++ b/Source/sys-clk/overlay/src/ui/gui/misc_gui.cpp @@ -59,7 +59,8 @@ void MiscGui::addConfigButton(SysClkConfigValue configVal, const char* altName, const ValueRange& range, const std::string& categoryName, - const ValueThresholds* thresholds) + const ValueThresholds* thresholds, + const std::map& labels) { const char* configName = altName ? altName : sysclkFormatConfigValue(configVal, true); @@ -82,7 +83,7 @@ void MiscGui::addConfigButton(SysClkConfigValue configVal, ValueThresholds thresholdsCopy = (thresholds ? *thresholds : ValueThresholds{}); listItem->setClickListener( - [this, configVal, range, categoryName, thresholdsCopy](u64 keys) + [this, configVal, range, categoryName, thresholdsCopy, labels](u64 keys) { if ((keys & HidNpadButton_A) == 0) return false; @@ -106,7 +107,8 @@ void MiscGui::addConfigButton(SysClkConfigValue configVal, return true; }, thresholdsCopy, - true + true, + labels // <── NEW ); } else { @@ -123,7 +125,10 @@ void MiscGui::addConfigButton(SysClkConfigValue configVal, } this->lastContextUpdate = armGetSystemTick(); return true; - } + }, + ValueThresholds(), + false, + labels // <── NEW ); } @@ -135,7 +140,11 @@ void MiscGui::addConfigButton(SysClkConfigValue configVal, this->configRanges[configVal] = range; } -void MiscGui::addFreqButton(SysClkConfigValue configVal, const char* altName, SysClkModule module) { +void MiscGui::addFreqButton(SysClkConfigValue configVal, + const char* altName, + SysClkModule module, + const std::map& labels) +{ const char* configName = altName ? altName : sysclkFormatConfigValue(configVal, true); tsl::elm::ListItem* listItem = new tsl::elm::ListItem(configName); @@ -145,45 +154,48 @@ void MiscGui::addFreqButton(SysClkConfigValue configVal, const char* altName, Sy snprintf(valueText, sizeof(valueText), "%lu MHz", currentMHz); listItem->setValue(valueText); - listItem->setClickListener([this, configVal, module](u64 keys) { - if ((keys & HidNpadButton_A) == 0) - return false; + listItem->setClickListener( + [this, configVal, module, labels](u64 keys) + { + if ((keys & HidNpadButton_A) == 0) + return false; - std::uint32_t hzList[SYSCLK_FREQ_LIST_MAX]; - std::uint32_t hzCount; + std::uint32_t hzList[SYSCLK_FREQ_LIST_MAX]; + std::uint32_t hzCount; - Result rc = sysclkIpcGetFreqList(module, hzList, SYSCLK_FREQ_LIST_MAX, &hzCount); - if (R_FAILED(rc)) { - FatalGui::openWithResultCode("sysclkIpcGetFreqList", rc); - return false; - } + 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; + std::uint32_t currentHz = this->configList->values[configVal] * 1'000'000; - tsl::changeTo( - currentHz, - hzList, - hzCount, - module, - [this, configVal](std::uint32_t hz) { + tsl::changeTo( + currentHz, + hzList, + hzCount, + module, + [this, configVal](std::uint32_t hz) + { + uint64_t mhz = hz / 1'000'000; + this->configList->values[configVal] = mhz; - uint64_t mhz = hz / 1'000'000; - this->configList->values[configVal] = mhz; + Result rc = sysclkIpcSetConfigValues(this->configList); + if (R_FAILED(rc)) { + FatalGui::openWithResultCode("sysclkIpcSetConfigValues", rc); + return false; + } - Result rc = sysclkIpcSetConfigValues(this->configList); - if (R_FAILED(rc)) { - FatalGui::openWithResultCode("sysclkIpcSetConfigValues", rc); - return false; - } + this->lastContextUpdate = armGetSystemTick(); + return true; + }, + false, + labels + ); - this->lastContextUpdate = armGetSystemTick(); - return true; - }, - false - ); - - return true; - }); + return true; + }); this->listElement->addItem(listItem); this->configButtons[configVal] = listItem; @@ -209,14 +221,20 @@ void MiscGui::listUI() this->listElement->addItem(new tsl::elm::CategoryHeader("Experimental")); addConfigToggle(HocClkConfigValue_ThermalThrottle, nullptr); addConfigToggle(HocClkConfigValue_HandheldTDP, nullptr); - + std::map labels_pwr_r = { + {8600, "Official Rating"} + }; + std::map labels_pwr_l = { + {6400, "Official Rating"} + }; ValueThresholds tdpThresholds(8600, 9500); addConfigButton( HocClkConfigValue_HandheldTDPLimit, "TDP Threshold", ValueRange(5000, 10000, 100, "mW", 1), "Power", - &tdpThresholds + &tdpThresholds, + labels_pwr_r ); ValueThresholds tdpThresholdsLite(6400, 7500); @@ -225,7 +243,8 @@ void MiscGui::listUI() "Lite TDP Threshold", ValueRange(4000, 8000, 100, "mW", 1), "Power", - &tdpThresholdsLite + &tdpThresholdsLite, + labels_pwr_r ); ValueThresholds throttleThresholds(70, 80); @@ -236,16 +255,113 @@ void MiscGui::listUI() "Temp", &throttleThresholds ); - this->listElement->addItem(new tsl::elm::CategoryHeader("Max Clocks")); + + + std::map cpu_freq_label_m = { + {612000000, "Sleep Mode"}, + {1020000000, "Stock"}, + {1224000000, "Dev OC"}, + {1785000000, "Boost Mode"}, + {1963000000, "Safe Max"}, + {2397000000, "Unsafe Max"}, + {2805000000, "Aboslute Max"}, + }; + + std::map cpu_freq_label_e = { + {612000000, "Sleep Mode"}, + {1020000000, "Stock"}, + {1224000000, "Dev OC"}, + {1785000000, "Boost Mode & Safe Max"}, + {2091000000, "Unsafe Max"}, + {2295000000, "Aboslute Max"}, + }; + + std::map gpu_freq_label_e = { + {76800000, "Boost Mode"}, + {307200000, "Handheld"}, + {384000000, "Handheld"}, + {460800000, "Handheld Safe Max"}, + {768000000, "Docked"}, + {844000000, "Safe Max"}, + {998400000, "Unsafe Max"}, + {1075200000, "Aboslute Max"}, + }; + + std::map gpu_freq_label_m = { + {76800000, "Boost Mode"}, + {307200000, "Handheld"}, + {384000000, "Handheld"}, + {460800000, "Handheld"}, + {614400000, "Handheld Safe Max"}, + {768000000, "Docked"}, + {1152200000, "Safe Max"}, + {1305600000, "Unsafe Max"}, + {1536000000, "Aboslute Max"}, + }; + + std::map emc_freq_label_e = { + {133120000, "Handheld"}, + {160000000, "Docked & Safe Max"}, + {213100000, "JEDEC Max"}, + {236000000, "Absolute Max"}, + }; + + + std::map emc_freq_label_m = { + {133120000, "Handheld"}, + {160000000, "Docked"}, + {186600000, "Safe Max (3733MT/s)"}, + {213300000, "Safe Max (4266MT/s)"}, + {320000000, "Absolute Max"}, + }; + + + + + if(IsMariko()) { - addFreqButton(HocClkConfigValue_MarikoMaxCpuClock, nullptr, SysClkModule_CPU); - addFreqButton(HocClkConfigValue_MarikoMaxGpuClock, nullptr, SysClkModule_GPU); - addFreqButton(HocClkConfigValue_MarikoMaxMemClock, nullptr, SysClkModule_MEM); + addFreqButton(HocClkConfigValue_MarikoMaxCpuClock, nullptr, SysClkModule_CPU, cpu_freq_label_m); + addFreqButton(HocClkConfigValue_MarikoMaxGpuClock, nullptr, SysClkModule_GPU, gpu_freq_label_m); + addFreqButton(HocClkConfigValue_MarikoMaxMemClock, nullptr, SysClkModule_MEM, emc_freq_label_m); } else { - addFreqButton(HocClkConfigValue_EristaMaxCpuClock, nullptr, SysClkModule_CPU); - addFreqButton(HocClkConfigValue_EristaMaxGpuClock, nullptr, SysClkModule_GPU); - addFreqButton(HocClkConfigValue_EristaMaxMemClock, nullptr, SysClkModule_MEM); + addFreqButton(HocClkConfigValue_EristaMaxCpuClock, nullptr, SysClkModule_CPU, cpu_freq_label_e); + addFreqButton(HocClkConfigValue_EristaMaxGpuClock, nullptr, SysClkModule_GPU, gpu_freq_label_e); + addFreqButton(HocClkConfigValue_EristaMaxMemClock, nullptr, SysClkModule_MEM, emc_freq_label_e); } + + this->listElement->addItem(new tsl::elm::CategoryHeader("KIP")); + + std::map emc_voltage_label = { + {1100000, "Default (Mariko)"}, + {1125000, "Default (Erista)"}, + {1175000, "Rating"}, + {1212500, "Safe Max"}, + }; + + + + ValueThresholds vdd2Thresholds(1212500, 1250000); + addConfigButton( + KipConfigValue_commonEmcMemVolt, + "EMC VDD2 Voltage", + ValueRange(912500, 1350000, 12500, "mV", 1000), + "Voltage", + &vdd2Thresholds + ); + + tsl::elm::ListItem* saveBtn = new tsl::elm::ListItem("Save KIP Settings"); + saveBtn->setClickListener([](u64 keys) { + if (keys & HidNpadButton_A) { + Result rc = hocClkIpcSetKipData(); + if (R_FAILED(rc)) { + FatalGui::openWithResultCode("hocClkIpcSetKipData", rc); + return false; + } + return true; + } + return false; + }); + this->listElement->addItem(saveBtn); } void MiscGui::refresh() { diff --git a/Source/sys-clk/overlay/src/ui/gui/misc_gui.h b/Source/sys-clk/overlay/src/ui/gui/misc_gui.h index 0192b888..16f01192 100644 --- a/Source/sys-clk/overlay/src/ui/gui/misc_gui.h +++ b/Source/sys-clk/overlay/src/ui/gui/misc_gui.h @@ -27,9 +27,12 @@ protected: const char* altName, const ValueRange& range, const std::string& categoryName, - const ValueThresholds* thresholds = nullptr); - void addFreqButton(SysClkConfigValue configVal, const char* altName, SysClkModule module); - void updateConfigToggles(); + const ValueThresholds* thresholds, + const std::map& labels = {}); + void addFreqButton(SysClkConfigValue configVal, + const char* altName, + SysClkModule module, + const std::map& labels = {}); void updateConfigToggles(); tsl::elm::ToggleListItem* enabledToggle; u8 frameCounter = 60; diff --git a/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.cpp b/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.cpp index ed5108df..d2e848fa 100644 --- a/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.cpp +++ b/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.cpp @@ -1,145 +1,121 @@ -/* - * 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 . - * - */ - -/* -------------------------------------------------------------------------- - * "THE BEER-WARE LICENSE" (Revision 42): - * , , - * 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 "value_choice_gui.h" +#include "../format.h" +#include "fatal_gui.h" +#include +#include +ValueChoiceGui::ValueChoiceGui(std::uint32_t selectedValue, + const ValueRange& range, + const std::string& categoryName, + ValueChoiceListener listener, + const ValueThresholds& thresholds, + bool enableThresholds, + std::map labels) + : selectedValue(selectedValue), + range(range), + categoryName(categoryName), + listener(listener), + thresholds(thresholds), + enableThresholds(enableThresholds), + labels(labels) +{ +} - #include "value_choice_gui.h" - #include "../format.h" - #include "fatal_gui.h" - #include - #include +ValueChoiceGui::~ValueChoiceGui() +{ +} - ValueChoiceGui::ValueChoiceGui(std::uint32_t selectedValue, - const ValueRange& range, - const std::string& categoryName, - ValueChoiceListener listener, - const ValueThresholds& thresholds, - bool enableThresholds) - : selectedValue(selectedValue), - range(range), - categoryName(categoryName), - listener(listener), - thresholds(thresholds), - enableThresholds(enableThresholds) - { - } +std::string ValueChoiceGui::formatValue(std::uint32_t value) +{ + std::ostringstream oss; - ValueChoiceGui::~ValueChoiceGui() - { - } + if (value == 0) { + return VALUE_DEFAULT_TEXT; + } - std::string ValueChoiceGui::formatValue(std::uint32_t value) - { - std::ostringstream oss; + double displayValue = static_cast(value) / static_cast(range.divisor); - if (value == 0) { + oss << std::fixed << std::setprecision(range.decimalPlaces) << displayValue; - return VALUE_DEFAULT_TEXT; - } + if (!range.suffix.empty()) { + oss << " " << range.suffix; + } + return oss.str(); +} - std::uint32_t displayValue = value / range.divisor; +int ValueChoiceGui::getSafetyLevel(std::uint32_t value) +{ + if (value > thresholds.danger) { + return 2; + } + if (value > thresholds.warning) { + return 1; + } + return 0; +} - oss << displayValue; - if (!range.suffix.empty()) { - oss << " " << range.suffix; - } - return oss.str(); - } +tsl::elm::ListItem* ValueChoiceGui::createValueListItem(std::uint32_t value, bool selected, int safety) +{ + std::string text = formatValue(value); + if (selected) { + text += " \uE14B"; + } - int ValueChoiceGui::getSafetyLevel(std::uint32_t value) - { - if (!enableThresholds) { - return 0; - } + std::string rightText = ""; + auto it = labels.find(value); + if (it != labels.end()) { + rightText = it->second; + } - std::uint32_t scaledValue = value / range.divisor; + tsl::elm::ListItem* listItem = new tsl::elm::ListItem(text, rightText, false); - if (scaledValue > thresholds.danger) { - return 2; - } - if (scaledValue > thresholds.warning) { - return 1; - } - return 0; - } + switch (safety) + { + case 0: + listItem->setTextColor(tsl::Color(255, 255, 255, 255)); + listItem->setValueColor(tsl::Color(255, 255, 255, 255)); + break; + case 1: + listItem->setTextColor(tsl::Color(255, 165, 0, 255)); + listItem->setValueColor(tsl::Color(255, 165, 0, 255)); + break; + case 2: + listItem->setTextColor(tsl::Color(255, 0, 0, 255)); + listItem->setValueColor(tsl::Color(255, 0, 0, 255)); + break; + } - tsl::elm::ListItem* ValueChoiceGui::createValueListItem(std::uint32_t value, bool selected, int safety) - { - std::string text = formatValue(value); - if (selected) { - text += " \uE14B"; - } + if (!rightText.empty()) + listItem->setValueColor(tsl::Color(180, 180, 180, 255)); - tsl::elm::ListItem* listItem = new tsl::elm::ListItem(text, "", false); + listItem->setClickListener([this, value](u64 keys) + { + if ((keys & HidNpadButton_A) == HidNpadButton_A && this->listener) { + if (this->listener(value)) { + tsl::goBack(); + } + return true; + } + return false; + }); - switch (safety) - { - case 0: - listItem->setTextColor(tsl::Color(255, 255, 255, 255)); - listItem->setValueColor(tsl::Color(255, 255, 255, 255)); - break; - case 1: - listItem->setTextColor(tsl::Color(255, 165, 0, 255)); - listItem->setValueColor(tsl::Color(255, 165, 0, 255)); - break; - case 2: - listItem->setTextColor(tsl::Color(255, 0, 0, 255)); - listItem->setValueColor(tsl::Color(255, 0, 0, 255)); - break; - } + return listItem; +} - listItem->setClickListener([this, value](u64 keys) - { - if ((keys & HidNpadButton_A) == HidNpadButton_A && this->listener) { +void ValueChoiceGui::listUI() +{ + if (!categoryName.empty()) { + this->listElement->addItem(new tsl::elm::CategoryHeader(categoryName)); + } - if (this->listener(value)) { - tsl::goBack(); - } - return true; - } - return false; - }); + this->listElement->addItem(this->createValueListItem(0, this->selectedValue == 0, 0)); - return listItem; - } + for (std::uint32_t value = range.min; value <= range.max; value += range.step) + { + int safety = getSafetyLevel(value); + bool selected = (value == this->selectedValue); + this->listElement->addItem(this->createValueListItem(value, selected, safety)); + } - void ValueChoiceGui::listUI() - { - - if (!categoryName.empty()) { - this->listElement->addItem(new tsl::elm::CategoryHeader(categoryName)); - } - - this->listElement->addItem(this->createValueListItem(0, this->selectedValue == 0, 0)); - - for (std::uint32_t value = range.min; value <= range.max; value += range.step) - { - int safety = getSafetyLevel(value); - bool selected = (value == this->selectedValue); - this->listElement->addItem(this->createValueListItem(value, selected, safety)); - } - - this->listElement->jumpToItem("", "\uE14B"); - } \ No newline at end of file + this->listElement->jumpToItem("", "\uE14B"); +} \ No newline at end of file diff --git a/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.h b/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.h index 160de655..73350973 100644 --- a/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.h +++ b/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.h @@ -25,62 +25,69 @@ */ - #pragma once +#pragma once - #include - #include - #include - #include "base_menu_gui.h" - - using ValueChoiceListener = std::function; - - #define VALUE_DEFAULT_TEXT "Default" - - struct ValueRange { - std::uint32_t min; - std::uint32_t max; - std::uint32_t step; - std::string suffix; - std::uint32_t divisor; // Divide input values by this for display - - // Default constructor - ValueRange() : min(0), max(0), step(1), suffix(""), divisor(1) {} - - ValueRange(std::uint32_t min, std::uint32_t max, std::uint32_t step, - const std::string& suffix = "", std::uint32_t divisor = 1) - : min(min), max(max), step(step), suffix(suffix), divisor(divisor) {} - }; - - struct ValueThresholds { - std::uint32_t warning; // Values >= this show orange - std::uint32_t danger; // Values >= this show red - - ValueThresholds(std::uint32_t warning = 0, std::uint32_t danger = 0) - : warning(warning), danger(danger) {} - }; - - class ValueChoiceGui : public BaseMenuGui - { - protected: - std::uint32_t selectedValue; - ValueRange range; - std::string categoryName; - ValueChoiceListener listener; - ValueThresholds thresholds; - bool enableThresholds; - - tsl::elm::ListItem* createValueListItem(std::uint32_t value, bool selected, int safety); - std::string formatValue(std::uint32_t value); - int getSafetyLevel(std::uint32_t value); - - public: - ValueChoiceGui(std::uint32_t selectedValue, - const ValueRange& range, - const std::string& categoryName, - ValueChoiceListener listener, - const ValueThresholds& thresholds = ValueThresholds(), - bool enableThresholds = false); - ~ValueChoiceGui(); - - void listUI() override; - }; \ No newline at end of file +#include +#include +#include +#include +#include "base_menu_gui.h" + +using ValueChoiceListener = std::function; + +#define VALUE_DEFAULT_TEXT "Default" + +struct ValueRange { + std::uint32_t min; + std::uint32_t max; + std::uint32_t step; + std::string suffix; + std::uint32_t divisor; + int decimalPlaces; + + ValueRange() + : min(0), max(0), step(1), suffix(""), divisor(1), decimalPlaces(0) {} + + ValueRange(std::uint32_t min, std::uint32_t max, std::uint32_t step, + const std::string& suffix = "", std::uint32_t divisor = 1, int decimalPlaces = 0) + : min(min), max(max), step(step), suffix(suffix), + divisor(divisor), decimalPlaces(decimalPlaces) {} +}; + +struct ValueThresholds { + std::uint32_t warning; + std::uint32_t danger; + + ValueThresholds(std::uint32_t warning = 0, std::uint32_t danger = 0) + : warning(warning), danger(danger) {} +}; + +class ValueChoiceGui : public BaseMenuGui +{ +protected: + std::uint32_t selectedValue; + ValueRange range; + std::string categoryName; + ValueChoiceListener listener; + ValueThresholds thresholds; + bool enableThresholds; + + // NEW — map of value → right-side text (like version numbers) + std::map labels; + + tsl::elm::ListItem* createValueListItem(std::uint32_t value, bool selected, int safety); + std::string formatValue(std::uint32_t value); + int getSafetyLevel(std::uint32_t value); + +public: + ValueChoiceGui(std::uint32_t selectedValue, + const ValueRange& range, + const std::string& categoryName, + ValueChoiceListener listener, + const ValueThresholds& thresholds = ValueThresholds(), + bool enableThresholds = false, + std::map labels = {}); + ~ValueChoiceGui(); + + void listUI() override; +}; \ No newline at end of file diff --git a/Source/sys-clk/sysmodule/src/clock_manager.cpp b/Source/sys-clk/sysmodule/src/clock_manager.cpp index 561b11a7..bb56c2f6 100644 --- a/Source/sys-clk/sysmodule/src/clock_manager.cpp +++ b/Source/sys-clk/sysmodule/src/clock_manager.cpp @@ -32,12 +32,11 @@ #include "process_management.h" #include "errors.h" #include "ipc_service.h" - +#include "kip.h" #define HOSPPC_HAS_BOOST (hosversionAtLeast(7,0,0)) ClockManager *ClockManager::instance = NULL; -kip_data_t kip; ClockManager *ClockManager::GetInstance() { @@ -80,6 +79,7 @@ ClockManager::ClockManager() this->lastCsvWriteNs = 0; this->rnxSync = new ReverseNXSync; + this->GetKipData(); } ClockManager::~ClockManager() @@ -519,203 +519,150 @@ void ClockManager::SetRNXRTMode(ReverseNXMode mode) } void ClockManager::SetKipData() { - - // Populate KIP fields from current config. We preserve fields that - // don't have corresponding config entries (e.g. custRev, hpMode). - kip.mtcConf = (uint32_t)this->config->GetConfigValue(KipConfigValue_MTCConf); - kip.commonCpuBoostClock = (uint32_t)this->config->GetConfigValue(KipConfigValue_commonCpuBoostClock); - kip.commonEmcMemVolt = (uint32_t)this->config->GetConfigValue(KipConfigValue_commonEmcMemVolt); + std::scoped_lock lock{this->contextMutex}; - // Erista - kip.eristaCpuMaxVolt = (uint32_t)this->config->GetConfigValue(KipConfigValue_eristaCpuMaxVolt); - kip.eristaEmcMaxClock = (uint32_t)this->config->GetConfigValue(KipConfigValue_eristaEmcMaxClock); + const char* kip = "sdmc:/atmosphere/kips/hoc.kip"; + CustomizeTable table; - // Mariko - kip.marikoCpuMaxVolt = (uint32_t)this->config->GetConfigValue(KipConfigValue_marikoCpuMaxVolt); - kip.marikoEmcMaxClock = (uint32_t)this->config->GetConfigValue(KipConfigValue_marikoEmcMaxClock); - kip.marikoEmcVddqVolt = (uint32_t)this->config->GetConfigValue(KipConfigValue_marikoEmcVddqVolt); + // Read the KIP file ONCE + if (!cust_read_and_cache(kip, &table)) { + FileUtils::LogLine("[clock_manager] Failed to read KIP file"); + return; + } - // Undervolt / UV - kip.marikoCpuUV = (uint32_t)this->config->GetConfigValue(KipConfigValue_marikoCpuUV); - kip.marikoGpuUV = (uint32_t)this->config->GetConfigValue(KipConfigValue_marikoGpuUV); - kip.eristaCpuUV = (uint32_t)this->config->GetConfigValue(KipConfigValue_eristaCpuUV); - kip.eristaGpuUV = (uint32_t)this->config->GetConfigValue(KipConfigValue_eristaGpuUV); + // Update all fields in memory + CUST_WRITE_FIELD_BATCH(&table, custRev, this->config->GetConfigValue(KipConfigValue_custRev)); + CUST_WRITE_FIELD_BATCH(&table, mtcConf, this->config->GetConfigValue(KipConfigValue_mtcConf)); + CUST_WRITE_FIELD_BATCH(&table, hpMode, this->config->GetConfigValue(KipConfigValue_hpMode)); - // GPU offset / EMC DVB - kip.commonGpuVoltOffset = (uint32_t)this->config->GetConfigValue(KipConfigValue_commonGpuVoltOffset); - kip.marikoEmcDvbShift = (uint32_t)this->config->GetConfigValue(KipConfigValue_marikoEmcDvbShift); + CUST_WRITE_FIELD_BATCH(&table, commonEmcMemVolt, this->config->GetConfigValue(KipConfigValue_commonEmcMemVolt)); + CUST_WRITE_FIELD_BATCH(&table, eristaEmcMaxClock, this->config->GetConfigValue(KipConfigValue_eristaEmcMaxClock)); + CUST_WRITE_FIELD_BATCH(&table, marikoEmcMaxClock, this->config->GetConfigValue(KipConfigValue_marikoEmcMaxClock)); + CUST_WRITE_FIELD_BATCH(&table, marikoEmcVddqVolt, this->config->GetConfigValue(KipConfigValue_marikoEmcVddqVolt)); + CUST_WRITE_FIELD_BATCH(&table, emcDvbShift, this->config->GetConfigValue(KipConfigValue_emcDvbShift)); - // Memory timing values - kip.t1_tRCD = (uint32_t)this->config->GetConfigValue(KipConfigValue_t1_tRCD); - kip.t2_tRP = (uint32_t)this->config->GetConfigValue(KipConfigValue_t2_tRP); - kip.t3_tRAS = (uint32_t)this->config->GetConfigValue(KipConfigValue_t3_tRAS); - kip.t4_tRRD = (uint32_t)this->config->GetConfigValue(KipConfigValue_t4_tRRD); - kip.t5_tRFC = (uint32_t)this->config->GetConfigValue(KipConfigValue_t5_tRFC); - kip.t6_tRTW = (uint32_t)this->config->GetConfigValue(KipConfigValue_t6_tRTW); - kip.t7_tWTR = (uint32_t)this->config->GetConfigValue(KipConfigValue_t7_tWTR); - kip.t8_tREFI = (uint32_t)this->config->GetConfigValue(KipConfigValue_t8_tREFI); + CUST_WRITE_FIELD_BATCH(&table, t1_tRCD, this->config->GetConfigValue(KipConfigValue_t1_tRCD)); + CUST_WRITE_FIELD_BATCH(&table, t2_tRP, this->config->GetConfigValue(KipConfigValue_t2_tRP)); + CUST_WRITE_FIELD_BATCH(&table, t3_tRAS, this->config->GetConfigValue(KipConfigValue_t3_tRAS)); + CUST_WRITE_FIELD_BATCH(&table, t4_tRRD, this->config->GetConfigValue(KipConfigValue_t4_tRRD)); + CUST_WRITE_FIELD_BATCH(&table, t5_tRFC, this->config->GetConfigValue(KipConfigValue_t5_tRFC)); + CUST_WRITE_FIELD_BATCH(&table, t6_tRTW, this->config->GetConfigValue(KipConfigValue_t6_tRTW)); + CUST_WRITE_FIELD_BATCH(&table, t7_tWTR, this->config->GetConfigValue(KipConfigValue_t7_tWTR)); + CUST_WRITE_FIELD_BATCH(&table, t8_tREFI, this->config->GetConfigValue(KipConfigValue_t8_tREFI)); + CUST_WRITE_FIELD_BATCH(&table, mem_burst_read_latency, this->config->GetConfigValue(KipConfigValue_mem_burst_read_latency)); + CUST_WRITE_FIELD_BATCH(&table, mem_burst_write_latency, this->config->GetConfigValue(KipConfigValue_mem_burst_write_latency)); - kip.mem_burst_read_latency = (uint32_t)this->config->GetConfigValue(KipConfigValue_mem_burst_read_latency); - kip.mem_burst_write_latency = (uint32_t)this->config->GetConfigValue(KipConfigValue_mem_burst_write_latency); + CUST_WRITE_FIELD_BATCH(&table, eristaCpuUV, this->config->GetConfigValue(KipConfigValue_eristaCpuUV)); + CUST_WRITE_FIELD_BATCH(&table, eristaCpuMaxVolt, this->config->GetConfigValue(KipConfigValue_eristaCpuMaxVolt)); - // Additional voltages - kip.marikoCpuHighVmin = (uint32_t)this->config->GetConfigValue(KipConfigValue_marikoCpuHighVmin); - kip.marikoCpuLowVmin = (uint32_t)this->config->GetConfigValue(KipConfigValue_marikoCpuLowVmin); - kip.eristaGpuVmin = (uint32_t)this->config->GetConfigValue(KipConfigValue_eristaGpuVmin); - kip.marikoGpuVmin = (uint32_t)this->config->GetConfigValue(KipConfigValue_marikoGpuVmin); - kip.marikoGpuVmax = (uint32_t)this->config->GetConfigValue(KipConfigValue_marikoGpuVmax); + CUST_WRITE_FIELD_BATCH(&table, marikoCpuUVLow, this->config->GetConfigValue(KipConfigValue_marikoCpuUVLow)); + CUST_WRITE_FIELD_BATCH(&table, marikoCpuUVHigh, this->config->GetConfigValue(KipConfigValue_marikoCpuUVHigh)); + CUST_WRITE_FIELD_BATCH(&table, marikoCpuLowVmin, this->config->GetConfigValue(KipConfigValue_marikoCpuLowVmin)); + CUST_WRITE_FIELD_BATCH(&table, marikoCpuHighVmin, this->config->GetConfigValue(KipConfigValue_marikoCpuHighVmin)); + CUST_WRITE_FIELD_BATCH(&table, marikoCpuMaxVolt, this->config->GetConfigValue(KipConfigValue_marikoCpuMaxVolt)); - kip.marikoGpuFullUnlock = (uint32_t)this->config->GetConfigValue(KipConfigValue_marikoGpuFullUnlock); + CUST_WRITE_FIELD_BATCH(&table, eristaCpuBoostClock, this->config->GetConfigValue(KipConfigValue_eristaCpuBoostClock)); + CUST_WRITE_FIELD_BATCH(&table, marikoCpuBoostClock, this->config->GetConfigValue(KipConfigValue_marikoCpuBoostClock)); - // Mariko GPU voltages - kip.g_volt_76800 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_76800); - kip.g_volt_153600 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_153600); - kip.g_volt_230400 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_230400); - kip.g_volt_307200 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_307200); - kip.g_volt_384000 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_384000); - kip.g_volt_460800 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_460800); - kip.g_volt_537600 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_537600); - kip.g_volt_614400 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_614400); - kip.g_volt_691200 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_691200); - kip.g_volt_768000 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_768000); - kip.g_volt_844800 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_844800); - kip.g_volt_921600 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_921600); - kip.g_volt_998400 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_998400); - kip.g_volt_1075200 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_1075200); - kip.g_volt_1152000 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_1152000); - kip.g_volt_1228800 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_1228800); - kip.g_volt_1267200 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_1267200); - kip.g_volt_1305600 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_1305600); - kip.g_volt_1344000 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_1344000); - kip.g_volt_1382400 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_1382400); - kip.g_volt_1420800 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_1420800); - kip.g_volt_1459200 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_1459200); - kip.g_volt_1497600 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_1497600); - kip.g_volt_1536000 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_1536000); + CUST_WRITE_FIELD_BATCH(&table, eristaGpuUV, this->config->GetConfigValue(KipConfigValue_eristaGpuUV)); + CUST_WRITE_FIELD_BATCH(&table, eristaGpuVmin, this->config->GetConfigValue(KipConfigValue_eristaGpuVmin)); - // Erista GPU voltages - kip.g_volt_e_76800 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_76800); - kip.g_volt_e_115200 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_115200); - kip.g_volt_e_153600 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_153600); - kip.g_volt_e_192000 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_192000); - kip.g_volt_e_230400 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_230400); - kip.g_volt_e_268800 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_268800); - kip.g_volt_e_307200 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_307200); - kip.g_volt_e_345600 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_345600); - kip.g_volt_e_384000 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_384000); - kip.g_volt_e_422400 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_422400); - kip.g_volt_e_460800 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_460800); - kip.g_volt_e_499200 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_499200); - kip.g_volt_e_537600 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_537600); - kip.g_volt_e_576000 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_576000); - kip.g_volt_e_614400 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_614400); - kip.g_volt_e_652800 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_652800); - kip.g_volt_e_691200 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_691200); - kip.g_volt_e_729600 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_729600); - kip.g_volt_e_768000 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_768000); - kip.g_volt_e_806400 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_806400); - kip.g_volt_e_844800 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_844800); - kip.g_volt_e_883200 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_883200); - kip.g_volt_e_921600 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_921600); - kip.g_volt_e_960000 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_960000); - kip.g_volt_e_998400 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_998400); - kip.g_volt_e_1036800 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_1036800); - kip.g_volt_e_1075200 = (uint32_t)this->config->GetConfigValue(KipConfigValue_g_volt_e_1075200); + CUST_WRITE_FIELD_BATCH(&table, marikoGpuUV, this->config->GetConfigValue(KipConfigValue_marikoGpuUV)); + CUST_WRITE_FIELD_BATCH(&table, marikoGpuVmin, this->config->GetConfigValue(KipConfigValue_marikoGpuVmin)); + CUST_WRITE_FIELD_BATCH(&table, marikoGpuVmax, this->config->GetConfigValue(KipConfigValue_marikoGpuVmax)); - kip_write("loader.kip", &kip, sizeof(kip)); + CUST_WRITE_FIELD_BATCH(&table, commonGpuVoltOffset, this->config->GetConfigValue(KipConfigValue_commonGpuVoltOffset)); + CUST_WRITE_FIELD_BATCH(&table, gpuSpeedo, this->config->GetConfigValue(KipConfigValue_gpuSpeedo)); + CUST_WRITE_FIELD_BATCH(&table, marikoGpuFullUnlock, this->config->GetConfigValue(KipConfigValue_marikoGpuFullUnlock)); + + // Update MARIKO GPU voltages + for (int i = 0; i < 24; i++) { + table.marikoGpuVoltArray[i] = this->config->GetConfigValue((SysClkConfigValue)(KipConfigValue_g_volt_76800 + i)); + } + + // Update ERISTA GPU voltages + for (int i = 0; i < 27; i++) { + table.eristaGpuVoltArray[i] = this->config->GetConfigValue((SysClkConfigValue)(KipConfigValue_g_volt_e_76800 + i)); + } + + // Write the KIP file ONCE with all changes + if (!cust_write_table(kip, &table)) { + FileUtils::LogLine("[clock_manager] Failed to write KIP file"); + } } void ClockManager::GetKipData() { - kip_read("loader.kip", &kip, sizeof(kip)); + std::scoped_lock lock{this->contextMutex}; - this->config->SetConfigValue(KipConfigValue_MTCConf, kip.mtcConf); - this->config->SetConfigValue(KipConfigValue_commonCpuBoostClock, kip.commonCpuBoostClock); - this->config->SetConfigValue(KipConfigValue_hpMode, kip.hpMode); - this->config->SetConfigValue(KipConfigValue_commonEmcMemVolt, kip.commonEmcMemVolt); - this->config->SetConfigValue(KipConfigValue_eristaCpuMaxVolt, kip.eristaCpuMaxVolt); - this->config->SetConfigValue(KipConfigValue_eristaEmcMaxClock, kip.eristaEmcMaxClock); - this->config->SetConfigValue(KipConfigValue_marikoCpuMaxVolt, kip.marikoCpuMaxVolt); - this->config->SetConfigValue(KipConfigValue_marikoEmcMaxClock, kip.marikoEmcMaxClock); - this->config->SetConfigValue(KipConfigValue_marikoEmcVddqVolt, kip.marikoEmcVddqVolt); - this->config->SetConfigValue(KipConfigValue_marikoCpuUV, kip.marikoCpuUV); - this->config->SetConfigValue(KipConfigValue_marikoGpuUV, kip.marikoGpuUV); - this->config->SetConfigValue(KipConfigValue_eristaCpuUV, kip.eristaCpuUV); - this->config->SetConfigValue(KipConfigValue_eristaGpuUV, kip.eristaGpuUV); - this->config->SetConfigValue(KipConfigValue_commonGpuVoltOffset, kip.commonGpuVoltOffset); - this->config->SetConfigValue(KipConfigValue_marikoEmcDvbShift, kip.marikoEmcDvbShift); - this->config->SetConfigValue(KipConfigValue_t1_tRCD, kip.t1_tRCD); - this->config->SetConfigValue(KipConfigValue_t2_tRP, kip.t2_tRP); - this->config->SetConfigValue(KipConfigValue_t3_tRAS, kip.t3_tRAS); - this->config->SetConfigValue(KipConfigValue_t4_tRRD, kip.t4_tRRD); - this->config->SetConfigValue(KipConfigValue_t5_tRFC, kip.t5_tRFC); - this->config->SetConfigValue(KipConfigValue_t6_tRTW, kip.t6_tRTW); - this->config->SetConfigValue(KipConfigValue_t7_tWTR, kip.t7_tWTR); - this->config->SetConfigValue(KipConfigValue_t8_tREFI, kip.t8_tREFI); + const char* kip = "sdmc:/atmosphere/kips/hoc.kip"; + CustomizeTable table; - this->config->SetConfigValue(KipConfigValue_mem_burst_read_latency, kip.mem_burst_read_latency); - this->config->SetConfigValue(KipConfigValue_mem_burst_write_latency, kip.mem_burst_write_latency); + // Read the KIP file ONCE + if (!cust_read_and_cache(kip, &table)) { + FileUtils::LogLine("[clock_manager] Failed to read KIP file for GetKipData"); + return; + } - this->config->SetConfigValue(KipConfigValue_marikoCpuHighVmin, kip.marikoCpuHighVmin); - this->config->SetConfigValue(KipConfigValue_marikoCpuLowVmin, kip.marikoCpuLowVmin); + // Build a config value list to set all at once + SysClkConfigValueList configValues; + memset(&configValues, 0, sizeof(configValues)); - this->config->SetConfigValue(KipConfigValue_eristaGpuVmin, kip.eristaGpuVmin); - this->config->SetConfigValue(KipConfigValue_marikoGpuVmin, kip.marikoGpuVmin); - this->config->SetConfigValue(KipConfigValue_marikoGpuVmax, kip.marikoGpuVmax); + // Read all fields from KIP file + configValues.values[KipConfigValue_custRev] = cust_get_cust_rev(&table); + configValues.values[KipConfigValue_mtcConf] = cust_get_mtc_conf(&table); + configValues.values[KipConfigValue_hpMode] = cust_get_hp_mode(&table); - this->config->SetConfigValue(KipConfigValue_marikoGpuFullUnlock, kip.marikoGpuFullUnlock); + configValues.values[KipConfigValue_commonEmcMemVolt] = cust_get_common_emc_volt(&table); + configValues.values[KipConfigValue_eristaEmcMaxClock] = cust_get_erista_emc_max(&table); + configValues.values[KipConfigValue_marikoEmcMaxClock] = cust_get_mariko_emc_max(&table); + configValues.values[KipConfigValue_marikoEmcVddqVolt] = cust_get_mariko_emc_vddq(&table); + configValues.values[KipConfigValue_emcDvbShift] = cust_get_emc_dvb_shift(&table); - // Mariko GPU voltages - this->config->SetConfigValue(KipConfigValue_g_volt_76800, kip.g_volt_76800); - this->config->SetConfigValue(KipConfigValue_g_volt_153600, kip.g_volt_153600); - this->config->SetConfigValue(KipConfigValue_g_volt_230400, kip.g_volt_230400); - this->config->SetConfigValue(KipConfigValue_g_volt_307200, kip.g_volt_307200); - this->config->SetConfigValue(KipConfigValue_g_volt_384000, kip.g_volt_384000); - this->config->SetConfigValue(KipConfigValue_g_volt_460800, kip.g_volt_460800); - this->config->SetConfigValue(KipConfigValue_g_volt_537600, kip.g_volt_537600); - this->config->SetConfigValue(KipConfigValue_g_volt_614400, kip.g_volt_614400); - this->config->SetConfigValue(KipConfigValue_g_volt_691200, kip.g_volt_691200); - this->config->SetConfigValue(KipConfigValue_g_volt_768000, kip.g_volt_768000); - this->config->SetConfigValue(KipConfigValue_g_volt_844800, kip.g_volt_844800); - this->config->SetConfigValue(KipConfigValue_g_volt_921600, kip.g_volt_921600); - this->config->SetConfigValue(KipConfigValue_g_volt_998400, kip.g_volt_998400); - this->config->SetConfigValue(KipConfigValue_g_volt_1075200, kip.g_volt_1075200); - this->config->SetConfigValue(KipConfigValue_g_volt_1152000, kip.g_volt_1152000); - this->config->SetConfigValue(KipConfigValue_g_volt_1228800, kip.g_volt_1228800); - this->config->SetConfigValue(KipConfigValue_g_volt_1267200, kip.g_volt_1267200); - this->config->SetConfigValue(KipConfigValue_g_volt_1305600, kip.g_volt_1305600); - this->config->SetConfigValue(KipConfigValue_g_volt_1344000, kip.g_volt_1344000); - this->config->SetConfigValue(KipConfigValue_g_volt_1382400, kip.g_volt_1382400); - this->config->SetConfigValue(KipConfigValue_g_volt_1420800, kip.g_volt_1420800); - this->config->SetConfigValue(KipConfigValue_g_volt_1459200, kip.g_volt_1459200); - this->config->SetConfigValue(KipConfigValue_g_volt_1497600, kip.g_volt_1497600); - this->config->SetConfigValue(KipConfigValue_g_volt_1536000, kip.g_volt_1536000); + configValues.values[KipConfigValue_t1_tRCD] = cust_get_tRCD(&table); + configValues.values[KipConfigValue_t2_tRP] = cust_get_tRP(&table); + configValues.values[KipConfigValue_t3_tRAS] = cust_get_tRAS(&table); + configValues.values[KipConfigValue_t4_tRRD] = cust_get_tRRD(&table); + configValues.values[KipConfigValue_t5_tRFC] = cust_get_tRFC(&table); + configValues.values[KipConfigValue_t6_tRTW] = cust_get_tRTW(&table); + configValues.values[KipConfigValue_t7_tWTR] = cust_get_tWTR(&table); + configValues.values[KipConfigValue_t8_tREFI] = cust_get_tREFI(&table); + configValues.values[KipConfigValue_mem_burst_read_latency] = cust_get_burst_read_lat(&table); + configValues.values[KipConfigValue_mem_burst_write_latency] = cust_get_burst_write_lat(&table); - // Erista GPU voltages - this->config->SetConfigValue(KipConfigValue_g_volt_e_76800, kip.g_volt_e_76800); - this->config->SetConfigValue(KipConfigValue_g_volt_e_115200, kip.g_volt_e_115200); - this->config->SetConfigValue(KipConfigValue_g_volt_e_153600, kip.g_volt_e_153600); - this->config->SetConfigValue(KipConfigValue_g_volt_e_192000, kip.g_volt_e_192000); - this->config->SetConfigValue(KipConfigValue_g_volt_e_230400, kip.g_volt_e_230400); - this->config->SetConfigValue(KipConfigValue_g_volt_e_268800, kip.g_volt_e_268800); - this->config->SetConfigValue(KipConfigValue_g_volt_e_307200, kip.g_volt_e_307200); - this->config->SetConfigValue(KipConfigValue_g_volt_e_345600, kip.g_volt_e_345600); - this->config->SetConfigValue(KipConfigValue_g_volt_e_384000, kip.g_volt_e_384000); - this->config->SetConfigValue(KipConfigValue_g_volt_e_422400, kip.g_volt_e_422400); - this->config->SetConfigValue(KipConfigValue_g_volt_e_460800, kip.g_volt_e_460800); - this->config->SetConfigValue(KipConfigValue_g_volt_e_499200, kip.g_volt_e_499200); - this->config->SetConfigValue(KipConfigValue_g_volt_e_537600, kip.g_volt_e_537600); - this->config->SetConfigValue(KipConfigValue_g_volt_e_576000, kip.g_volt_e_576000); - this->config->SetConfigValue(KipConfigValue_g_volt_e_614400, kip.g_volt_e_614400); - this->config->SetConfigValue(KipConfigValue_g_volt_e_652800, kip.g_volt_e_652800); - this->config->SetConfigValue(KipConfigValue_g_volt_e_691200, kip.g_volt_e_691200); - this->config->SetConfigValue(KipConfigValue_g_volt_e_729600, kip.g_volt_e_729600); - this->config->SetConfigValue(KipConfigValue_g_volt_e_768000, kip.g_volt_e_768000); - this->config->SetConfigValue(KipConfigValue_g_volt_e_806400, kip.g_volt_e_806400); - this->config->SetConfigValue(KipConfigValue_g_volt_e_844800, kip.g_volt_e_844800); - this->config->SetConfigValue(KipConfigValue_g_volt_e_883200, kip.g_volt_e_883200); - this->config->SetConfigValue(KipConfigValue_g_volt_e_921600, kip.g_volt_e_921600); - this->config->SetConfigValue(KipConfigValue_g_volt_e_960000, kip.g_volt_e_960000); - this->config->SetConfigValue(KipConfigValue_g_volt_e_998400, kip.g_volt_e_998400); - this->config->SetConfigValue(KipConfigValue_g_volt_e_1036800, kip.g_volt_e_1036800); - this->config->SetConfigValue(KipConfigValue_g_volt_e_1075200, kip.g_volt_e_1075200); + configValues.values[KipConfigValue_eristaCpuUV] = cust_get_erista_cpu_uv(&table); + configValues.values[KipConfigValue_eristaCpuMaxVolt] = cust_get_erista_cpu_max_volt(&table); + configValues.values[KipConfigValue_marikoCpuUVLow] = cust_get_mariko_cpu_uv_low(&table); + configValues.values[KipConfigValue_marikoCpuUVHigh] = cust_get_mariko_cpu_uv_high(&table); + configValues.values[KipConfigValue_marikoCpuLowVmin] = cust_get_mariko_cpu_low_vmin(&table); + configValues.values[KipConfigValue_marikoCpuHighVmin] = cust_get_mariko_cpu_high_vmin(&table); + configValues.values[KipConfigValue_marikoCpuMaxVolt] = cust_get_mariko_cpu_max_volt(&table); + configValues.values[KipConfigValue_eristaCpuBoostClock] = cust_get_erista_cpu_boost(&table); + configValues.values[KipConfigValue_marikoCpuBoostClock] = cust_get_mariko_cpu_boost(&table); + + configValues.values[KipConfigValue_eristaGpuUV] = cust_get_erista_gpu_uv(&table); + configValues.values[KipConfigValue_eristaGpuVmin] = cust_get_erista_gpu_vmin(&table); + configValues.values[KipConfigValue_marikoGpuUV] = cust_get_mariko_gpu_uv(&table); + configValues.values[KipConfigValue_marikoGpuVmin] = cust_get_mariko_gpu_vmin(&table); + configValues.values[KipConfigValue_marikoGpuVmax] = cust_get_mariko_gpu_vmax(&table); + configValues.values[KipConfigValue_commonGpuVoltOffset] = cust_get_common_gpu_offset(&table); + configValues.values[KipConfigValue_gpuSpeedo] = cust_get_gpu_speedo(&table); + configValues.values[KipConfigValue_marikoGpuFullUnlock] = cust_get_mariko_gpu_unlock(&table); + + for (int i = 0; i < 24; i++) { + configValues.values[KipConfigValue_g_volt_76800 + i] = cust_get_mariko_gpu_volt(&table, i); + } + + for (int i = 0; i < 27; i++) { + configValues.values[KipConfigValue_g_volt_e_76800 + i] = cust_get_erista_gpu_volt(&table, i); + } + + if (sizeof(SysClkConfigValueList) <= sizeof(configValues)) { + if (this->config->SetConfigValues(&configValues, false)) { + FileUtils::LogLine("[clock_manager] Successfully loaded KIP data into config"); + } else { + FileUtils::LogLine("[clock_manager] Warning: Failed to set config values from KIP"); + } + } else { + FileUtils::LogLine("[clock_manager] Error: Config value list buffer size mismatch"); + } } \ No newline at end of file diff --git a/Source/sys-clk/sysmodule/src/clock_manager.h b/Source/sys-clk/sysmodule/src/clock_manager.h index 733a060c..c9fab4e9 100644 --- a/Source/sys-clk/sysmodule/src/clock_manager.h +++ b/Source/sys-clk/sysmodule/src/clock_manager.h @@ -35,7 +35,6 @@ #include "board.h" #include #include "integrations.h" -#include "kip_handler.h" class ReverseNXSync; diff --git a/Source/sys-clk/sysmodule/src/config.cpp b/Source/sys-clk/sysmodule/src/config.cpp index 7565efcc..37918716 100644 --- a/Source/sys-clk/sysmodule/src/config.cpp +++ b/Source/sys-clk/sysmodule/src/config.cpp @@ -405,22 +405,6 @@ std::uint64_t Config::GetConfigValue(SysClkConfigValue kval) return this->configValues[kval]; } -void Config::SetConfigValue(SysClkConfigValue kval, std::uint64_t value) -{ - ASSERT_ENUM_VALID(SysClkConfigValue, kval); - - std::scoped_lock lock{this->configMutex}; - - if(sysclkValidConfigValue(kval, value)) - { - this->configValues[kval] = value; - } - else - { - this->configValues[kval] = sysclkDefaultConfigValue(kval); - } -} - const char* Config::GetConfigValueName(SysClkConfigValue kval, bool pretty) { ASSERT_ENUM_VALID(SysClkConfigValue, kval); @@ -444,7 +428,6 @@ bool Config::SetConfigValues(SysClkConfigValueList* configValues, bool immediate { std::scoped_lock lock{this->configMutex}; - // Use dynamic allocation instead of fixed stack buffers std::vector iniKeys; std::vector iniValues; @@ -496,5 +479,53 @@ bool Config::SetConfigValues(SysClkConfigValueList* configValues, bool immediate } } + return true; +} + +bool Config::ResetConfigValue(SysClkConfigValue kval) +{ + // Check enum validity BEFORE acquiring lock + if (!SYSCLK_ENUM_VALID(SysClkConfigValue, kval)) { + FileUtils::LogLine("[cfg] Invalid SysClkConfigValue: %u", kval); + return false; + } + + std::scoped_lock lock{this->configMutex}; + + std::uint64_t defaultValue = sysclkDefaultConfigValue(kval); + + // Build key-value pair for INI file (empty value to remove) + std::vector iniKeys; + std::vector iniValues; + + iniKeys.reserve(2); // key + NULL terminator + iniValues.reserve(1); + + const char* keyStr = sysclkFormatConfigValue(kval, false); + + iniKeys.push_back(keyStr); + iniValues.push_back(""); // Empty string to remove the key + + // Null terminate keys + iniKeys.push_back(NULL); + + // Build value pointers array + std::vector valuePointers; + valuePointers.reserve(iniValues.size() + 1); + for (const auto& val : iniValues) { + valuePointers.push_back(val.c_str()); + } + valuePointers.push_back(NULL); + + // Write to INI file + if (!ini_putsection(CONFIG_VAL_SECTION, iniKeys.data(), valuePointers.data(), this->path.c_str())) { + FileUtils::LogLine("[cfg] Failed to reset config value %u in INI", kval); + return false; + } + + // Apply default value in memory + this->configValues[kval] = defaultValue; + FileUtils::LogLine("[cfg] Reset config value %u to default: %llu", kval, defaultValue); + return true; } \ No newline at end of file diff --git a/Source/sys-clk/sysmodule/src/config.h b/Source/sys-clk/sysmodule/src/config.h index 18a90cb9..4718d356 100644 --- a/Source/sys-clk/sysmodule/src/config.h +++ b/Source/sys-clk/sysmodule/src/config.h @@ -62,10 +62,10 @@ class Config std::uint32_t GetOverrideHz(SysClkModule module); std::uint64_t GetConfigValue(SysClkConfigValue val); - void SetConfigValue(SysClkConfigValue val, std::uint64_t value); const char* GetConfigValueName(SysClkConfigValue val, bool pretty); void GetConfigValues(SysClkConfigValueList* out_configValues); bool SetConfigValues(SysClkConfigValueList* configValues, bool immediate); + bool ResetConfigValue(SysClkConfigValue kval); protected: void Load(); void Close(); diff --git a/Source/sys-clk/sysmodule/src/ipc_service.cpp b/Source/sys-clk/sysmodule/src/ipc_service.cpp index 5f717167..91f9933d 100644 --- a/Source/sys-clk/sysmodule/src/ipc_service.cpp +++ b/Source/sys-clk/sysmodule/src/ipc_service.cpp @@ -205,7 +205,9 @@ Result IpcService::ServiceHandlerFunc(void* arg, const IpcServerRequest* r, u8* } break; case HocClkIpcCmd_SetKipData: - return ipcSrv->SetKipData(); + if (r->data.size >= 0) { + return ipcSrv->SetKipData(); + } } return SYSCLK_ERROR(Generic); @@ -359,18 +361,17 @@ Result IpcService::GetFreqList(SysClkIpc_GetFreqList_Args* args, std::uint32_t* } Result IpcService::SetReverseNXRTMode(ReverseNXMode mode) { - ClockManager::GetInstance()->SetRNXRTMode(mode); return 0; } Result IpcService::SetKipData() { - ClockManager::GetInstance()->SetKipData(); + this->clockMgr->SetKipData(); return 0; } Result IpcService::GetKipData() { - ClockManager::GetInstance()->GetKipData(); + this->clockMgr->GetKipData(); return 0; } diff --git a/Source/sys-clk/sysmodule/src/kip.h b/Source/sys-clk/sysmodule/src/kip.h new file mode 100644 index 00000000..7bdcc265 --- /dev/null +++ b/Source/sys-clk/sysmodule/src/kip.h @@ -0,0 +1,398 @@ +#pragma once +#include +#include +#include +#include +#include + +#pragma pack(push, 1) + +typedef struct { + u8 cust[4]; + u32 custRev; + u32 mtcConf; + u32 hpMode; + u32 commonEmcMemVolt; + u32 eristaEmcMaxClock; + u32 marikoEmcMaxClock; + u32 marikoEmcVddqVolt; + u32 emcDvbShift; + u32 t1_tRCD; + u32 t2_tRP; + u32 t3_tRAS; + u32 t4_tRRD; + u32 t5_tRFC; + u32 t6_tRTW; + u32 t7_tWTR; + u32 t8_tREFI; + u32 mem_burst_read_latency; + u32 mem_burst_write_latency; + u32 eristaCpuUV; + u32 eristaCpuMaxVolt; + u32 marikoCpuUVLow; + u32 marikoCpuUVHigh; + u32 tableConf; + u32 marikoCpuLowVmin; + u32 marikoCpuHighVmin; + u32 marikoCpuMaxVolt; + u32 eristaCpuBoostClock; + u32 marikoCpuBoostClock; + u32 eristaGpuUV; + u32 eristaGpuVmin; + u32 marikoGpuUV; + u32 marikoGpuVmin; + u32 marikoGpuVmax; + u32 commonGpuVoltOffset; + u32 gpuSpeedo; + u32 marikoGpuFullUnlock; + u32 eristaGpuVoltArray[27]; + u32 marikoGpuVoltArray[24]; +} CustomizeTable; + +#pragma pack(pop) + +#define CUST_MAGIC "CUST" +#define CUST_MAGIC_LEN 4 + +typedef struct { + FILE* file; + long offset; + CustomizeTable cached_table; + bool has_cache; +} CustHandle; + +static inline bool cust_find_offset(FILE* f, long* out_offset) { + u8 buf[512]; + long pos = 0; + fseek(f, 0, SEEK_SET); + + while (1) { + size_t r = fread(buf, 1, sizeof(buf), f); + if (r < CUST_MAGIC_LEN) break; + + for (size_t i = 0; i <= r - CUST_MAGIC_LEN; i++) { + if (memcmp(&buf[i], CUST_MAGIC, CUST_MAGIC_LEN) == 0) { + *out_offset = pos + (long)i; + return true; + } + } + pos += (long)(r - (CUST_MAGIC_LEN - 1)); + fseek(f, pos, SEEK_SET); + } + return false; +} + +static inline bool cust_read_table(const char* path, CustomizeTable* out) { + FILE* f = fopen(path, "rb"); + if (!f) return false; + + long off; + if (!cust_find_offset(f, &off)) { + fclose(f); + return false; + } + + fseek(f, 0, SEEK_END); + long size = ftell(f); + + if (off + (long)sizeof(CustomizeTable) > size) { + fclose(f); + return false; + } + + fseek(f, off, SEEK_SET); + bool ok = fread(out, 1, sizeof(CustomizeTable), f) == sizeof(CustomizeTable); + fclose(f); + + return ok && memcmp(out->cust, CUST_MAGIC, 4) == 0; +} + +static inline bool cust_write_table(const char* path, const CustomizeTable* in) { + FILE* f = fopen(path, "r+b"); + if (!f) return false; + + long off; + if (!cust_find_offset(f, &off)) { + fclose(f); + return false; + } + + fseek(f, 0, SEEK_END); + long size = ftell(f); + + if (off + (long)sizeof(CustomizeTable) > size) { + fclose(f); + return false; + } + + fseek(f, off, SEEK_SET); + bool ok = fwrite(in, 1, sizeof(CustomizeTable), f) == sizeof(CustomizeTable); + fflush(f); + fclose(f); + + return ok; +} + + +static inline bool cust_read_and_cache(const char* path, CustomizeTable* out) { + return cust_read_table(path, out); +} + +#define CUST_WRITE_FIELD_BATCH(table, field, val) \ + do { \ + (table)->field = (val); \ + } while (0) + +#define CUST_WRITE_FIELD(path, field, val) \ + do { \ + CustomizeTable t; \ + if (!cust_read_table(path, &t)) return false; \ + t.field = (val); \ + return cust_write_table(path, &t); \ + } while (0) + +static inline bool cust_set_cust_rev(const char* p, u32 v) { CUST_WRITE_FIELD(p, custRev, v); } +static inline bool cust_set_mtc_conf(const char* p, u32 v) { CUST_WRITE_FIELD(p, mtcConf, v); } +static inline bool cust_set_hp_mode(const char* p, u32 v) { CUST_WRITE_FIELD(p, hpMode, v); } + +static inline bool cust_set_common_emc_volt(const char* p, u32 v) { CUST_WRITE_FIELD(p, commonEmcMemVolt, v); } +static inline bool cust_set_erista_emc_max(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaEmcMaxClock, v); } +static inline bool cust_set_mariko_emc_max(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoEmcMaxClock, v); } +static inline bool cust_set_mariko_emc_vddq(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoEmcVddqVolt, v); } +static inline bool cust_set_emc_dvb_shift(const char* p, u32 v) { CUST_WRITE_FIELD(p, emcDvbShift, v); } + +static inline bool cust_set_tRCD(const char* p, u32 v) { CUST_WRITE_FIELD(p, t1_tRCD, v); } +static inline bool cust_set_tRP(const char* p, u32 v) { CUST_WRITE_FIELD(p, t2_tRP, v); } +static inline bool cust_set_tRAS(const char* p, u32 v) { CUST_WRITE_FIELD(p, t3_tRAS, v); } +static inline bool cust_set_tRRD(const char* p, u32 v) { CUST_WRITE_FIELD(p, t4_tRRD, v); } +static inline bool cust_set_tRFC(const char* p, u32 v) { CUST_WRITE_FIELD(p, t5_tRFC, v); } +static inline bool cust_set_tRTW(const char* p, u32 v) { CUST_WRITE_FIELD(p, t6_tRTW, v); } +static inline bool cust_set_tWTR(const char* p, u32 v) { CUST_WRITE_FIELD(p, t7_tWTR, v); } +static inline bool cust_set_tREFI(const char* p, u32 v) { CUST_WRITE_FIELD(p, t8_tREFI, v); } +static inline bool cust_set_burst_read_lat(const char* p, u32 v) { CUST_WRITE_FIELD(p, mem_burst_read_latency, v); } +static inline bool cust_set_burst_write_lat(const char* p, u32 v) { CUST_WRITE_FIELD(p, mem_burst_write_latency, v); } + +static inline bool cust_set_erista_cpu_uv(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaCpuUV, v); } +static inline bool cust_set_erista_cpu_max_volt(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaCpuMaxVolt, v); } +static inline bool cust_set_mariko_cpu_uv_low(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoCpuUVLow, v); } +static inline bool cust_set_mariko_cpu_uv_high(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoCpuUVHigh, v); } +static inline bool cust_set_mariko_cpu_low_vmin(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoCpuLowVmin, v); } +static inline bool cust_set_mariko_cpu_high_vmin(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoCpuHighVmin, v); } +static inline bool cust_set_mariko_cpu_max_volt(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoCpuMaxVolt, v); } +static inline bool cust_set_erista_cpu_boost(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaCpuBoostClock, v); } +static inline bool cust_set_mariko_cpu_boost(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoCpuBoostClock, v); } + +static inline bool cust_set_erista_gpu_uv(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaGpuUV, v); } +static inline bool cust_set_erista_gpu_vmin(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaGpuVmin, v); } +static inline bool cust_set_mariko_gpu_uv(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoGpuUV, v); } +static inline bool cust_set_mariko_gpu_vmin(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoGpuVmin, v); } +static inline bool cust_set_mariko_gpu_vmax(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoGpuVmax, v); } +static inline bool cust_set_common_gpu_offset(const char* p, u32 v) { CUST_WRITE_FIELD(p, commonGpuVoltOffset, v); } +static inline bool cust_set_gpu_speedo(const char* p, u32 v) { CUST_WRITE_FIELD(p, gpuSpeedo, v); } +static inline bool cust_set_mariko_gpu_unlock(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoGpuFullUnlock, v); } + +/* GPU VOLT ARRAY HELPERS */ +static inline bool cust_set_erista_gpu_volt(const char* p, int idx, u32 v) { + if (idx < 0 || idx >= 27) return false; + CustomizeTable t; + if (!cust_read_table(p, &t)) return false; + t.eristaGpuVoltArray[idx] = v; + return cust_write_table(p, &t); +} + +static inline bool cust_set_mariko_gpu_volt(const char* p, int idx, u32 v) { + if (idx < 0 || idx >= 24) return false; + CustomizeTable t; + if (!cust_read_table(p, &t)) return false; + t.marikoGpuVoltArray[idx] = v; + return cust_write_table(p, &t); +} + +static inline u32 cust_get_field(const CustomizeTable* t, u32 offset) { + if (!t) return 0; + return *(u32*)((u8*)t + offset); +} + +#define CUST_GET_FIELD(table, field) ((table) ? (table)->field : 0) + +static inline u32 cust_get_cust_rev(const CustomizeTable* t) { return CUST_GET_FIELD(t, custRev); } +static inline u32 cust_get_mtc_conf(const CustomizeTable* t) { return CUST_GET_FIELD(t, mtcConf); } +static inline u32 cust_get_hp_mode(const CustomizeTable* t) { return CUST_GET_FIELD(t, hpMode); } + +static inline u32 cust_get_common_emc_volt(const CustomizeTable* t) { return CUST_GET_FIELD(t, commonEmcMemVolt); } +static inline u32 cust_get_erista_emc_max(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaEmcMaxClock); } +static inline u32 cust_get_mariko_emc_max(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoEmcMaxClock); } +static inline u32 cust_get_mariko_emc_vddq(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoEmcVddqVolt); } +static inline u32 cust_get_emc_dvb_shift(const CustomizeTable* t) { return CUST_GET_FIELD(t, emcDvbShift); } + +static inline u32 cust_get_tRCD(const CustomizeTable* t) { return CUST_GET_FIELD(t, t1_tRCD); } +static inline u32 cust_get_tRP(const CustomizeTable* t) { return CUST_GET_FIELD(t, t2_tRP); } +static inline u32 cust_get_tRAS(const CustomizeTable* t) { return CUST_GET_FIELD(t, t3_tRAS); } +static inline u32 cust_get_tRRD(const CustomizeTable* t) { return CUST_GET_FIELD(t, t4_tRRD); } +static inline u32 cust_get_tRFC(const CustomizeTable* t) { return CUST_GET_FIELD(t, t5_tRFC); } +static inline u32 cust_get_tRTW(const CustomizeTable* t) { return CUST_GET_FIELD(t, t6_tRTW); } +static inline u32 cust_get_tWTR(const CustomizeTable* t) { return CUST_GET_FIELD(t, t7_tWTR); } +static inline u32 cust_get_tREFI(const CustomizeTable* t) { return CUST_GET_FIELD(t, t8_tREFI); } +static inline u32 cust_get_burst_read_lat(const CustomizeTable* t) { return CUST_GET_FIELD(t, mem_burst_read_latency); } +static inline u32 cust_get_burst_write_lat(const CustomizeTable* t) { return CUST_GET_FIELD(t, mem_burst_write_latency); } + +static inline u32 cust_get_erista_cpu_uv(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaCpuUV); } +static inline u32 cust_get_erista_cpu_max_volt(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaCpuMaxVolt); } +static inline u32 cust_get_mariko_cpu_uv_low(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoCpuUVLow); } +static inline u32 cust_get_mariko_cpu_uv_high(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoCpuUVHigh); } +static inline u32 cust_get_mariko_cpu_low_vmin(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoCpuLowVmin); } +static inline u32 cust_get_mariko_cpu_high_vmin(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoCpuHighVmin); } +static inline u32 cust_get_mariko_cpu_max_volt(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoCpuMaxVolt); } +static inline u32 cust_get_erista_cpu_boost(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaCpuBoostClock); } +static inline u32 cust_get_mariko_cpu_boost(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoCpuBoostClock); } + +static inline u32 cust_get_erista_gpu_uv(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaGpuUV); } +static inline u32 cust_get_erista_gpu_vmin(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaGpuVmin); } +static inline u32 cust_get_mariko_gpu_uv(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoGpuUV); } +static inline u32 cust_get_mariko_gpu_vmin(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoGpuVmin); } +static inline u32 cust_get_mariko_gpu_vmax(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoGpuVmax); } +static inline u32 cust_get_common_gpu_offset(const CustomizeTable* t) { return CUST_GET_FIELD(t, commonGpuVoltOffset); } +static inline u32 cust_get_gpu_speedo(const CustomizeTable* t) { return CUST_GET_FIELD(t, gpuSpeedo); } +static inline u32 cust_get_mariko_gpu_unlock(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoGpuFullUnlock); } + +static inline u32 cust_get_erista_gpu_volt(const CustomizeTable* t, int idx) { + if (!t || idx < 0 || idx >= 27) return 0; + return t->eristaGpuVoltArray[idx]; +} + +static inline u32 cust_get_mariko_gpu_volt(const CustomizeTable* t, int idx) { + if (!t || idx < 0 || idx >= 24) return 0; + return t->marikoGpuVoltArray[idx]; +} + +#define DECL_ERISTA_GPU_VOLT_HELPER(freq, idx) \ +static inline bool cust_set_erista_gpu_volt_##freq( \ + const char* p, u32 v) { \ + return cust_set_erista_gpu_volt(p, idx, v); \ +} + +#define DECL_MARIKO_GPU_VOLT_HELPER(freq, idx) \ +static inline bool cust_set_mariko_gpu_volt_##freq( \ + const char* p, u32 v) { \ + return cust_set_mariko_gpu_volt(p, idx, v); \ +} + +DECL_ERISTA_GPU_VOLT_HELPER(76800, 0) +DECL_ERISTA_GPU_VOLT_HELPER(115200, 1) +DECL_ERISTA_GPU_VOLT_HELPER(153600, 2) +DECL_ERISTA_GPU_VOLT_HELPER(192000, 3) +DECL_ERISTA_GPU_VOLT_HELPER(230400, 4) +DECL_ERISTA_GPU_VOLT_HELPER(268800, 5) +DECL_ERISTA_GPU_VOLT_HELPER(307200, 6) +DECL_ERISTA_GPU_VOLT_HELPER(345600, 7) +DECL_ERISTA_GPU_VOLT_HELPER(384000, 8) +DECL_ERISTA_GPU_VOLT_HELPER(422400, 9) +DECL_ERISTA_GPU_VOLT_HELPER(460800, 10) +DECL_ERISTA_GPU_VOLT_HELPER(499200, 11) +DECL_ERISTA_GPU_VOLT_HELPER(537600, 12) +DECL_ERISTA_GPU_VOLT_HELPER(576000, 13) +DECL_ERISTA_GPU_VOLT_HELPER(614400, 14) +DECL_ERISTA_GPU_VOLT_HELPER(652800, 15) +DECL_ERISTA_GPU_VOLT_HELPER(691200, 16) +DECL_ERISTA_GPU_VOLT_HELPER(729600, 17) +DECL_ERISTA_GPU_VOLT_HELPER(768000, 18) +DECL_ERISTA_GPU_VOLT_HELPER(806400, 19) +DECL_ERISTA_GPU_VOLT_HELPER(844800, 20) +DECL_ERISTA_GPU_VOLT_HELPER(883200, 21) +DECL_ERISTA_GPU_VOLT_HELPER(921600, 22) +DECL_ERISTA_GPU_VOLT_HELPER(960000, 23) +DECL_ERISTA_GPU_VOLT_HELPER(998400, 24) +DECL_ERISTA_GPU_VOLT_HELPER(1036800, 25) +DECL_ERISTA_GPU_VOLT_HELPER(1075200, 26) + +DECL_MARIKO_GPU_VOLT_HELPER(76800, 0) +DECL_MARIKO_GPU_VOLT_HELPER(153600, 1) +DECL_MARIKO_GPU_VOLT_HELPER(230400, 2) +DECL_MARIKO_GPU_VOLT_HELPER(307200, 3) +DECL_MARIKO_GPU_VOLT_HELPER(384000, 4) +DECL_MARIKO_GPU_VOLT_HELPER(460800, 5) +DECL_MARIKO_GPU_VOLT_HELPER(537600, 6) +DECL_MARIKO_GPU_VOLT_HELPER(614400, 7) +DECL_MARIKO_GPU_VOLT_HELPER(691200, 8) +DECL_MARIKO_GPU_VOLT_HELPER(768000, 9) +DECL_MARIKO_GPU_VOLT_HELPER(844800, 10) +DECL_MARIKO_GPU_VOLT_HELPER(921600, 11) +DECL_MARIKO_GPU_VOLT_HELPER(998400, 12) +DECL_MARIKO_GPU_VOLT_HELPER(1075200, 13) +DECL_MARIKO_GPU_VOLT_HELPER(1152000, 14) +DECL_MARIKO_GPU_VOLT_HELPER(1228800, 15) +DECL_MARIKO_GPU_VOLT_HELPER(1267200, 16) +DECL_MARIKO_GPU_VOLT_HELPER(1305600, 17) +DECL_MARIKO_GPU_VOLT_HELPER(1344000, 18) +DECL_MARIKO_GPU_VOLT_HELPER(1382400, 19) +DECL_MARIKO_GPU_VOLT_HELPER(1420800, 20) +DECL_MARIKO_GPU_VOLT_HELPER(1459200, 21) +DECL_MARIKO_GPU_VOLT_HELPER(1497600, 22) +DECL_MARIKO_GPU_VOLT_HELPER(1536000, 23) + + +#define DECL_ERISTA_GPU_VOLT_GET(freq, idx) \ +static inline u32 cust_get_erista_gpu_volt_##freq##_val(const char* p) { \ + CustomizeTable t; \ + if (!cust_read_table(p, &t)) return 0; \ + return cust_get_erista_gpu_volt(&t, idx); \ +} +#define DECL_MARIKO_GPU_VOLT_GET(freq, idx) \ +static inline u32 cust_get_mariko_gpu_volt_##freq##_val(const char* p) { \ + CustomizeTable t; \ + if (!cust_read_table(p, &t)) return 0; \ + return cust_get_mariko_gpu_volt(&t, idx); \ +} + +DECL_ERISTA_GPU_VOLT_GET(76800, 0) +DECL_ERISTA_GPU_VOLT_GET(115200, 1) +DECL_ERISTA_GPU_VOLT_GET(153600, 2) +DECL_ERISTA_GPU_VOLT_GET(192000, 3) +DECL_ERISTA_GPU_VOLT_GET(230400, 4) +DECL_ERISTA_GPU_VOLT_GET(268800, 5) +DECL_ERISTA_GPU_VOLT_GET(307200, 6) +DECL_ERISTA_GPU_VOLT_GET(345600, 7) +DECL_ERISTA_GPU_VOLT_GET(384000, 8) +DECL_ERISTA_GPU_VOLT_GET(422400, 9) +DECL_ERISTA_GPU_VOLT_GET(460800, 10) +DECL_ERISTA_GPU_VOLT_GET(499200, 11) +DECL_ERISTA_GPU_VOLT_GET(537600, 12) +DECL_ERISTA_GPU_VOLT_GET(576000, 13) +DECL_ERISTA_GPU_VOLT_GET(614400, 14) +DECL_ERISTA_GPU_VOLT_GET(652800, 15) +DECL_ERISTA_GPU_VOLT_GET(691200, 16) +DECL_ERISTA_GPU_VOLT_GET(729600, 17) +DECL_ERISTA_GPU_VOLT_GET(768000, 18) +DECL_ERISTA_GPU_VOLT_GET(806400, 19) +DECL_ERISTA_GPU_VOLT_GET(844800, 20) +DECL_ERISTA_GPU_VOLT_GET(883200, 21) +DECL_ERISTA_GPU_VOLT_GET(921600, 22) +DECL_ERISTA_GPU_VOLT_GET(960000, 23) +DECL_ERISTA_GPU_VOLT_GET(998400, 24) +DECL_ERISTA_GPU_VOLT_GET(1036800, 25) +DECL_ERISTA_GPU_VOLT_GET(1075200, 26) + +DECL_MARIKO_GPU_VOLT_GET(76800, 0) +DECL_MARIKO_GPU_VOLT_GET(153600, 1) +DECL_MARIKO_GPU_VOLT_GET(230400, 2) +DECL_MARIKO_GPU_VOLT_GET(307200, 3) +DECL_MARIKO_GPU_VOLT_GET(384000, 4) +DECL_MARIKO_GPU_VOLT_GET(460800, 5) +DECL_MARIKO_GPU_VOLT_GET(537600, 6) +DECL_MARIKO_GPU_VOLT_GET(614400, 7) +DECL_MARIKO_GPU_VOLT_GET(691200, 8) +DECL_MARIKO_GPU_VOLT_GET(768000, 9) +DECL_MARIKO_GPU_VOLT_GET(844800, 10) +DECL_MARIKO_GPU_VOLT_GET(921600, 11) +DECL_MARIKO_GPU_VOLT_GET(998400, 12) +DECL_MARIKO_GPU_VOLT_GET(1075200, 13) +DECL_MARIKO_GPU_VOLT_GET(1152000, 14) +DECL_MARIKO_GPU_VOLT_GET(1228800, 15) +DECL_MARIKO_GPU_VOLT_GET(1267200, 16) +DECL_MARIKO_GPU_VOLT_GET(1305600, 17) +DECL_MARIKO_GPU_VOLT_GET(1344000, 18) +DECL_MARIKO_GPU_VOLT_GET(1382400, 19) +DECL_MARIKO_GPU_VOLT_GET(1420800, 20) +DECL_MARIKO_GPU_VOLT_GET(1459200, 21) +DECL_MARIKO_GPU_VOLT_GET(1497600, 22) +DECL_MARIKO_GPU_VOLT_GET(1536000, 23) \ No newline at end of file diff --git a/Source/sys-clk/sysmodule/src/kip_handler.h b/Source/sys-clk/sysmodule/src/kip_handler.h deleted file mode 100644 index 0d54c857..00000000 --- a/Source/sys-clk/sysmodule/src/kip_handler.h +++ /dev/null @@ -1,182 +0,0 @@ -#ifndef KIP_H -#define KIP_H - -#include -#include -#include - -#define KIP_MAGIC "CUST" -#define KIP_MAGIC_LEN 4 -#define KIP_MAX_STRUCT 4096 - -typedef struct { - uint32_t custRev; - uint32_t mtcConf; - uint32_t hpMode; - uint32_t commonCpuBoostClock; - uint32_t commonEmcMemVolt; - uint32_t eristaCpuMaxVolt; - uint32_t eristaEmcMaxClock; - uint32_t marikoCpuMaxVolt; - uint32_t marikoEmcMaxClock; - uint32_t marikoEmcVddqVolt; - uint32_t marikoCpuUV; - uint32_t marikoGpuUV; - uint32_t eristaCpuUV; - uint32_t eristaGpuUV; - uint32_t commonGpuVoltOffset; - uint32_t marikoEmcDvbShift; - - uint32_t t1_tRCD; - uint32_t t2_tRP; - uint32_t t3_tRAS; - uint32_t t4_tRRD; - uint32_t t5_tRFC; - uint32_t t6_tRTW; - uint32_t t7_tWTR; - uint32_t t8_tREFI; - uint32_t mem_burst_read_latency; - uint32_t mem_burst_write_latency; - uint32_t marikoCpuHighVmin; - uint32_t marikoCpuLowVmin; - uint32_t eristaGpuVmin; - uint32_t marikoGpuVmin; - uint32_t marikoGpuVmax; - - uint32_t marikoGpuFullUnlock; - - uint32_t g_volt_76800; - uint32_t g_volt_153600; - uint32_t g_volt_230400; - uint32_t g_volt_307200; - uint32_t g_volt_384000; - uint32_t g_volt_460800; - uint32_t g_volt_537600; - uint32_t g_volt_614400; - uint32_t g_volt_691200; - uint32_t g_volt_768000; - uint32_t g_volt_844800; - uint32_t g_volt_921600; - uint32_t g_volt_998400; - uint32_t g_volt_1075200; - uint32_t g_volt_1152000; - uint32_t g_volt_1228800; - uint32_t g_volt_1267200; - uint32_t g_volt_1305600; - uint32_t g_volt_1344000; - uint32_t g_volt_1382400; - uint32_t g_volt_1420800; - uint32_t g_volt_1459200; - uint32_t g_volt_1497600; - uint32_t g_volt_1536000; - - uint32_t g_volt_e_76800; - uint32_t g_volt_e_115200; - uint32_t g_volt_e_153600; - uint32_t g_volt_e_192000; - uint32_t g_volt_e_230400; - uint32_t g_volt_e_268800; - uint32_t g_volt_e_307200; - uint32_t g_volt_e_345600; - uint32_t g_volt_e_384000; - uint32_t g_volt_e_422400; - uint32_t g_volt_e_460800; - uint32_t g_volt_e_499200; - uint32_t g_volt_e_537600; - uint32_t g_volt_e_576000; - uint32_t g_volt_e_614400; - uint32_t g_volt_e_652800; - uint32_t g_volt_e_691200; - uint32_t g_volt_e_729600; - uint32_t g_volt_e_768000; - uint32_t g_volt_e_806400; - uint32_t g_volt_e_844800; - uint32_t g_volt_e_883200; - uint32_t g_volt_e_921600; - uint32_t g_volt_e_960000; - uint32_t g_volt_e_998400; - uint32_t g_volt_e_1036800; - uint32_t g_volt_e_1075200; -} kip_data_t; - - - -static long kip_find_magic(FILE *f) -{ - unsigned char buf[4096 + KIP_MAGIC_LEN]; - size_t r; - long offset = 0; - - memset(buf, 0, sizeof(buf)); - fseek(f, 0, SEEK_SET); - - while ((r = fread(buf + KIP_MAGIC_LEN, 1, 4096, f)) > 0) - { - for (size_t i = 0; i < r; i++) - { - if (memcmp(buf + i, KIP_MAGIC, KIP_MAGIC_LEN) == 0) - { - return offset + i; - } - } - - memcpy(buf, buf + 4096, KIP_MAGIC_LEN); - offset += r; - } - - return -1; -} - - - -static int kip_read(const char *path, void *out_struct, size_t struct_size) -{ - if (struct_size > KIP_MAX_STRUCT) - return -3; - - FILE *f = fopen(path, "rb"); - if (!f) - return -1; - - long magic_pos = kip_find_magic(f); - if (magic_pos < 0) { - fclose(f); - return -2; /* magic not found */ - } - - long data_pos = magic_pos + KIP_MAGIC_LEN; - fseek(f, data_pos, SEEK_SET); - - size_t r = fread(out_struct, 1, struct_size, f); - fclose(f); - - return (r == struct_size) ? 0 : -4; -} - - - -static int kip_write(const char *path, const void *in_struct, size_t struct_size) -{ - if (struct_size > KIP_MAX_STRUCT) - return -3; - - FILE *f = fopen(path, "r+b"); - if (!f) - return -1; - - long magic_pos = kip_find_magic(f); - if (magic_pos < 0) { - fclose(f); - return -2; - } - - long data_pos = magic_pos + KIP_MAGIC_LEN; - fseek(f, data_pos, SEEK_SET); - - size_t w = fwrite(in_struct, 1, struct_size, f); - fclose(f); - - return (w == struct_size) ? 0 : -4; -} - -#endif /* KIP_H */ diff --git a/dist/README.md b/dist/README.md index 32beca37..242747ff 100644 --- a/dist/README.md +++ b/dist/README.md @@ -1,7 +1,7 @@
-logo +logo --- @@ -19,8 +19,8 @@ ## ⚠️ Disclaimer > **THIS TOOL CAN BE DANGEROUS IF MISUSED. PROCEED WITH CAUTION.** -> Due to the design of Horizon OS, **overclocking RAM can cause NAND DAMAGE.** -> Ensure you have a **full NAND backup** before proceeding. +> Due to the design of Horizon OS, **overclocking RAM can cause NAND OR SD CORRUPTION.** +> Ensure you have a **full NAND, PROINFO, EMUMMC and SD backup** before proceeding. --- @@ -31,21 +31,21 @@ It enables advanced CPU, GPU, and RAM tuning with user-friendly configuration to --- -## 🚀 Features +## Features -* **CPU:** Up to `2397MHz` (Mariko) / `2091MHz` (Erista) -* **GPU:** Up to `1305MHz` (Mariko) / `998MHz` (Erista) -* **RAM:** Up to `3200MHz` (Mariko) / `2360MHz` (Erista) +* **CPU:** Up to 1963MHz (Mariko) / 1785MHz (Erista) +* **GPU:** Up to 1075MHz (Mariko) / 998MHz (Erista) +* **RAM:** Up to 1866MHz (Mariko) / 1600MHz (Erista) * Over/undervolting support * Built-in configurator * Compatible with most homebrew -> *Higher (potentially dangerous) frequencies are unlockable.* -> *Exact maximum values vary per console.* +> *Higher (potentially dangerous) frequencies are unlockable via configuration.* +> *The exact maximum overclock possible varies per console, although most consoles should be able to do this safely.* --- -## 🧩 Installation +## Installation 1. Ensure you have the latest versions of @@ -55,7 +55,7 @@ It enables advanced CPU, GPU, and RAM tuning with user-friendly configuration to 3. If using **Hekate**, edit `hekate_ipl.ini` to include: ``` - kip1=atmosphere/kips/* + kip1=atmosphere/kips/hoc.kip ``` *(No changes needed if using fusee.)* @@ -64,7 +64,7 @@ It enables advanced CPU, GPU, and RAM tuning with user-friendly configuration to --- -## ⚙️ Configuration +## Configuration 1. Download the latest **Configurator** on your computer. 2. Run the executable. @@ -74,40 +74,19 @@ It enables advanced CPU, GPU, and RAM tuning with user-friendly configuration to --- -## 🧱 Building from Source +## Building from Source -1. Set up a development environment for compiling **Atmosphere**. -2. Clone Atmosphere: - - ```bash - git clone https://github.com/Atmosphere-NX/Atmosphere.git - ``` -3. Move the cloned folder into `build/`. -4. Insert your `Source/stratosphere` folder into `build/`. -5. Run: (On Windows you need to use "make -j %NUMBER_OF_PROCESSORS%") - - ```bash - ./build.sh - ``` - - - -To build the Configurator: - -```bash -cd Source/Configurator -build.bat -# or -python -m PyInstaller --onefile --add-data "assets;assets" --icon=assets/icon.ico --noconsole src/main.py -``` +Refer to COMPILATION.md --- -## 💎 Credits +## Credits -* **Lightos** & **Dominatorul** – RAM timings -* **KazushiMe** & **meha** – Switch-OC-Suite +* **Lightos** – RAM timings +* **ScriesM** - Atmosphere CFW +* **KazushiMe** – Switch OC Suite +* **B3711** - UV Tables * **sys-clk team** – sys-clk * **b0rd2death** – Ultrahand sys-clk fork -* **Lightos** & **Sammybigio2011** – Early testing - +* **MasaGratoR and ZachyCatGames** - General help +* **Lightos, Dom, Samybigio, Dom, Arcdelta, Miki, Algie, Happy, Flopsider, Winnerboi77, Blaise, Alvise, TRRR and Xenshen** - Testing diff --git a/dist/atmosphere/contents/00FF0000636C6BFF/exefs.nsp b/dist/atmosphere/contents/00FF0000636C6BFF/exefs.nsp index 7884b485dfebd666af2cd9658b3d6dd015932def..c4ff5f2db71a315a3bc41b9210799b792d227f3e 100644 GIT binary patch delta 101827 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 MH~6>z_u!5H4l)9&W&i*H delta 92081 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μmQl1pqQdG4+sEEJd%!{MQZXK4?JGe>yFm-NW8B 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∨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 PGws5K8SVAI-o51yYW~cP diff --git a/dist/atmosphere/contents/00FF0000636C6BFF/toolbox.json b/dist/atmosphere/contents/00FF0000636C6BFF/toolbox.json index 4874c6c7..83ac964c 100644 --- a/dist/atmosphere/contents/00FF0000636C6BFF/toolbox.json +++ b/dist/atmosphere/contents/00FF0000636C6BFF/toolbox.json @@ -1,5 +1,5 @@ { - "name" : "Horizon OC", + "name" : "hoc-clk", "tid" : "00FF0000636C6BFF", "requires_reboot": false } \ No newline at end of file