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

sysclk & loader: fix configuration

Browse Source
This commit is contained in:
souldbminersmwc
2025-12-17 18:49:40 -05:00
parent abbd9fe79d
commit 2ad8767ffc
10 changed files with 395 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
Source/Atmosphere/stratosphere/loader/source/oc/customize.cpp
View File

@@ -26,7 +26,7 @@
#define DISABLED 0 #define DISABLED 0
#define DEACTIVATED_GPU_FREQ 2000 #define DEACTIVATED_GPU_FREQ 2000
#define CPU_MAX_MAX_VOLT 1235000 #define CPU_MAX_MAX_VOLT 1235000
#define GPU_MIN_MIN_VOLT 480000
namespace ams::ldr::oc { namespace ams::ldr::oc {
volatile CustomizeTable C = { volatile CustomizeTable C = {
@@ -38,7 +38,7 @@ volatile CustomizeTable C = {
.eristaEmcMaxClock = 1600000, // Maximum HB-MGCH ram rating .eristaEmcMaxClock = 1600000, // Maximum HB-MGCH ram rating
.marikoEmcMaxClock = 2133000, .marikoEmcMaxClock = 2133000,
.marikoEmcVddqVolt = 640000, .marikoEmcVddqVolt = 600000,
.emcDvbShift = 0, .emcDvbShift = 0,
// Primary // Primary
@@ -53,7 +53,7 @@ volatile CustomizeTable C = {
.t8_tREFI = 0, .t8_tREFI = 0,
/* Set to 4 read and 2 write for 1866bl. */ /* Set to 4 read and 2 write for 1866bl. */
/* For 2131bl: 8 read and 4 write. */ /* For 2133bl: 8 read and 4 write. */
.mem_burst_read_latency = 8, .mem_burst_read_latency = 8,
.mem_burst_write_latency = 4, .mem_burst_write_latency = 4,
@@ -67,11 +67,11 @@ volatile CustomizeTable C = {
.marikoCpuHighVmin = 750, .marikoCpuHighVmin = 750,
.marikoCpuMaxVolt = 1120, .marikoCpuMaxVolt = 1120,
/* Supported values: 2397000, 2499000, 2601000, 2703000. */ /* Supported values: 1963000, 2397000, 2499000, 2601000, 2703000. */
/* 2499000 should be used with caution. */ /* 2499000 should be used with caution. */
/* 2601000 exceeds pmic limit on most consoles. */ /* 2601000 exceeds pmic limit on most consoles. */
/* 2703000 is potentially dangerous and not advised. */ /* 2703000 is potentially dangerous and not advised. */
.marikoCpuMaxClock = 2397000, .marikoCpuMaxClock = 1963000,
.eristaCpuBoostClock = 1785000, // Default boost clock .eristaCpuBoostClock = 1785000, // Default boost clock
.marikoCpuBoostClock = 1963000, // Default boost clock .marikoCpuBoostClock = 1963000, // Default boost clock
@@ -80,8 +80,9 @@ volatile CustomizeTable C = {
.eristaGpuVmin = 810, .eristaGpuVmin = 810,
.marikoGpuUV = 0, .marikoGpuUV = 0,
/* For automatic vmin detection, set this to AUTO. */ /* For automatic vmin detection, set this to AUTO. */
.marikoGpuVmin = 621, .marikoGpuVmin = 610,
.marikoGpuVmax = 800, .marikoGpuVmax = 800,
@@ -148,7 +149,7 @@ volatile CustomizeTable C = {
AUTO /* 1075 */, AUTO /* 1075 */,
AUTO /* 1152 */, AUTO /* 1152 */,
AUTO /* 1228 */, AUTO /* 1228 */,
AUTO /* 1267 (Disabled by default) */, AUTO /* 1267 */,
DEACTIVATED_GPU_FREQ /* 1305 (Disabled by default) */, DEACTIVATED_GPU_FREQ /* 1305 (Disabled by default) */,
DEACTIVATED_GPU_FREQ /* 1344 (Disabled by default) */, DEACTIVATED_GPU_FREQ /* 1344 (Disabled by default) */,
DEACTIVATED_GPU_FREQ /* 1382 (Disabled by default) */, DEACTIVATED_GPU_FREQ /* 1382 (Disabled by default) */,
@@ -158,7 +159,8 @@ volatile CustomizeTable C = {
DEACTIVATED_GPU_FREQ /* 1536 (Disabled by default) */, DEACTIVATED_GPU_FREQ /* 1536 (Disabled by default) */,
}, },
/* You shouldn't have to anything past here. */ /* You shouldn't have to modify anything past here. */
.eristaCpuDvfsTable = { .eristaCpuDvfsTable = {
{ 204000, { 721094 }, {} }, { 204000, { 721094 }, {} },
{ 306000, { 754040 }, {} }, { 306000, { 754040 }, {} },
@@ -344,7 +346,7 @@ volatile CustomizeTable C = {
{ 844800, { }, { 1233208, 8144, -940, 808, -21583, 226 } }, { 844800, { }, { 1233208, 8144, -940, 808, -21583, 226 } },
{ 883200, { }, { 1275100, 8144, -940, 808, -21583, 226 } }, { 883200, { }, { 1275100, 8144, -940, 808, -21583, 226 } },
{ 921600, { }, { 1275100, 8144, -940, 808, -21583, 226 } }, { 921600, { }, { 1275100, 8144, -940, 808, -21583, 226 } },
// { 998400, { }, { 1316991, 8144, -940, 808, -21583, 226 } }, // { 998400, { }, { 1316991, 8144, -940, 808, -21583, 226 } },
// { 1075200, { }, { 1358882, 8144, -940, 808, -21583, 226 } }, // { 1075200, { }, { 1358882, 8144, -940, 808, -21583, 226 } },
}, },
@@ -408,9 +410,9 @@ volatile CustomizeTable C = {
}, },
.marikoGpuDvfsTable = { .marikoGpuDvfsTable = {
{ 76800, { }, { 480000, } }, { 76800, { }, { GPU_MIN_MIN_VOLT, } },
{ 153600, { }, { 480000, } }, { 153600, { }, { GPU_MIN_MIN_VOLT, } },
{ 230400, { }, { 480000, } }, { 230400, { }, { GPU_MIN_MIN_VOLT, } },
{ 307200, { }, { 738712, -7304, -552, 119, -3750, -2 } }, { 307200, { }, { 738712, -7304, -552, 119, -3750, -2 } },
{ 384000, { }, { 758712, -7304, -552, 119, -3750, -2 } }, { 384000, { }, { 758712, -7304, -552, 119, -3750, -2 } },
{ 460800, { }, { 778712, -7304, -552, 119, -3750, -2 } }, { 460800, { }, { 778712, -7304, -552, 119, -3750, -2 } },
@@ -423,14 +425,14 @@ volatile CustomizeTable C = {
{ 998400, { }, { 1065665,-16075, -497,-179, 3213, 9 } }, { 998400, { }, { 1065665,-16075, -497,-179, 3213, 9 } },
{ 1075200, { }, { 1132576,-16093, -648, 0, 1077, 40 } }, { 1075200, { }, { 1132576,-16093, -648, 0, 1077, 40 } },
{ 1152000, { }, { 1180029,-14534, -830, 0, 1469, 110 } }, { 1152000, { }, { 1180029,-14534, -830, 0, 1469, 110 } },
{ 1228800, { }, { 1248293,-16383, -859, 0, 3722, 313 } }, // { 1228800, { }, { 1248293,-16383, -859, 0, 3722, 313 } },
{ 1267200, { }, { 1286399,-17475, -867, 0, 3681, 559 } }, // { 1267200, { }, { 1286399,-17475, -867, 0, 3681, 559 } },
}, },
.marikoGpuDvfsTableSLT = { .marikoGpuDvfsTableSLT = {
{ 76800, { }, { 480000, } }, { 76800, { }, { GPU_MIN_MIN_VOLT, } },
{ 153600, { }, { 480000, } }, { 153600, { }, { GPU_MIN_MIN_VOLT, } },
{ 230400, { }, { 480000, } }, { 230400, { }, { GPU_MIN_MIN_VOLT, } },
{ 307200, { }, { 738712, -7304, -552, 119, -3750, -2 } }, { 307200, { }, { 738712, -7304, -552, 119, -3750, -2 } },
{ 384000, { }, { 758712, -7304, -552, 119, -3750, -2 } }, { 384000, { }, { 758712, -7304, -552, 119, -3750, -2 } },
{ 460800, { }, { 778712, -7304, -552, 119, -3750, -2 } }, { 460800, { }, { 778712, -7304, -552, 119, -3750, -2 } },
@@ -448,9 +450,9 @@ volatile CustomizeTable C = {
}, },
.marikoGpuDvfsTableHiOPT = { .marikoGpuDvfsTableHiOPT = {
{ 76800, { }, { 480000, } }, { 76800, { }, { GPU_MIN_MIN_VOLT, } },
{ 153600, { }, { 480000, } }, { 153600, { }, { GPU_MIN_MIN_VOLT, } },
{ 230400, { }, { 480000, } }, { 230400, { }, { GPU_MIN_MIN_VOLT, } },
{ 307200, { }, { 738712, -7304, -552, 119, -3750, -2 } }, { 307200, { }, { 738712, -7304, -552, 119, -3750, -2 } },
{ 384000, { }, { 758712, -7304, -552, 119, -3750, -2 } }, { 384000, { }, { 758712, -7304, -552, 119, -3750, -2 } },
{ 460800, { }, { 778712, -7304, -552, 119, -3750, -2 } }, { 460800, { }, { 778712, -7304, -552, 119, -3750, -2 } },

2
Source/Atmosphere/stratosphere/loader/source/oc/customize.hpp
View File

@@ -51,7 +51,7 @@ constexpr uint32_t ERISTA_MTC_MAGIC = 0x43544D45; // EMTC
constexpr uint32_t MARIKO_MTC_MAGIC = 0x43544D4D; // MMTC constexpr uint32_t MARIKO_MTC_MAGIC = 0x43544D4D; // MMTC
typedef struct CustomizeTable { typedef struct CustomizeTable {
u8 cust[4] = {'C', 'U', 'S', 'T'}; u8 cust[16] = {'H', 'O', 'C', 'K', 'I', 'P', 'C', 'U', 'S', 'T', '\0', '\0', '\0', '\0'};
u32 custRev = CUST_REV; u32 custRev = CUST_REV;
u32 mtcConf; u32 mtcConf;

4
Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.cpp
View File

@@ -73,8 +73,8 @@ Result MemVoltHandler(u32* ptr) {
} }
void SafetyCheck() { void SafetyCheck() {
if (C.custRev != CUST_REV) // if (C.custRev != CUST_REV) // causes more issues than help
CRASH("Triggered"); // CRASH("Triggered");
struct sValidator { struct sValidator {
volatile u32 value; volatile u32 value;

7
Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.hpp
View File

@@ -60,7 +60,8 @@ namespace ams::ldr::oc::pcv {
static constexpr s32 CpuVoltageSecondaryPatchOffsets[] = { -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; static constexpr s32 CpuVoltageSecondaryPatchOffsets[] = { -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
static_assert(sizeof(CpuVoltageSecondaryPatchValues) == sizeof(CpuVoltageSecondaryPatchOffsets), "Invalid secondary CpuVoltagePatch size"); static_assert(sizeof(CpuVoltageSecondaryPatchValues) == sizeof(CpuVoltageSecondaryPatchOffsets), "Invalid secondary CpuVoltagePatch size");
static constexpr u32 AllowedCpuMaxFrequencies[] = { 2'397'000, 2'499'000, 2'601'000, 2'703'000, }; static constexpr u32 AllowedCpuMaxFrequencies[] = { 1'963'000, 2'397'000, 2'499'000, 2'601'000, 2'703'000 /*, 2'805'000 */}; // 2805MHz should NOT be used unless you have a god speedo!
constexpr cvb_entry_t GpuCvbTableDefault[] = { constexpr cvb_entry_t GpuCvbTableDefault[] = {
// GPUB01_NA_CVB_TABLE // GPUB01_NA_CVB_TABLE
@@ -193,6 +194,8 @@ namespace ams::ldr::oc::pcv {
constexpr int GpuVminOfficial = 810; constexpr int GpuVminOfficial = 810;
constexpr int GpuVmaxOfficial = 1200; /* No point in patching this but here's the info if one needs it */
constexpr u32 CpuVoltOfficial = 1235; constexpr u32 CpuVoltOfficial = 1235;
constexpr u32 CpuVoltL4T = 1235'000; constexpr u32 CpuVoltL4T = 1235'000;
@@ -205,6 +208,8 @@ namespace ams::ldr::oc::pcv {
} }
constexpr u32 GpuClkPllLimit = 921'600'000; constexpr u32 GpuClkPllLimit = 921'600'000;
constexpr u32 GpuClkPllMax = 1300'000'000; /* No point in patching this but here's the info if one needs it */
constexpr u32 GpuClkPllLimit2 = 2'600'000; /* No point in patching this but here's the info if one needs it */
/* GPU Max Clock asm Pattern: /* GPU Max Clock asm Pattern:
* *

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

@@ -93,7 +93,7 @@ typedef enum {
KipConfigValue_marikoCpuLowVmin, KipConfigValue_marikoCpuLowVmin,
KipConfigValue_marikoCpuHighVmin, KipConfigValue_marikoCpuHighVmin,
KipConfigValue_marikoCpuMaxVolt, KipConfigValue_marikoCpuMaxVolt,
KipConfigValue_marikoCpuMaxClock,
KipConfigValue_eristaCpuBoostClock, KipConfigValue_eristaCpuBoostClock,
KipConfigValue_marikoCpuBoostClock, KipConfigValue_marikoCpuBoostClock,
@@ -298,6 +298,9 @@ static inline const char* sysclkFormatConfigValue(SysClkConfigValue val, bool pr
case KipConfigValue_marikoCpuBoostClock: case KipConfigValue_marikoCpuBoostClock:
return pretty ? "Mariko CPU Boost Clock" : "mariko_cpu_boost_clock"; return pretty ? "Mariko CPU Boost Clock" : "mariko_cpu_boost_clock";
case KipConfigValue_marikoCpuMaxClock:
return pretty ? "Mariko CPU Max Clock" : "mariko_cpu_max_clock";
// GPU – Erista // GPU – Erista
case KipConfigValue_eristaGpuUV: case KipConfigValue_eristaGpuUV:
return pretty ? "Erista GPU Undervolt" : "erista_gpu_uv"; return pretty ? "Erista GPU Undervolt" : "erista_gpu_uv";
@@ -375,7 +378,7 @@ static inline const char* sysclkFormatConfigValue(SysClkConfigValue val, bool pr
case KipConfigValue_g_volt_e_1075200: return pretty ? "Erista GPU Volt 1075 MHz" : "g_volt_e_1075200"; case KipConfigValue_g_volt_e_1075200: return pretty ? "Erista GPU Volt 1075 MHz" : "g_volt_e_1075200";
default: default:
return pretty ? "Null" : "null"; return pretty ? "[cfg] no enum format string" : "err_no_format_string";
} }
} }
@@ -484,6 +487,7 @@ static inline uint64_t sysclkValidConfigValue(SysClkConfigValue val, uint64_t in
case KipConfigValue_marikoCpuMaxVolt: case KipConfigValue_marikoCpuMaxVolt:
case KipConfigValue_eristaCpuBoostClock: case KipConfigValue_eristaCpuBoostClock:
case KipConfigValue_marikoCpuBoostClock: case KipConfigValue_marikoCpuBoostClock:
case KipConfigValue_marikoCpuMaxClock:
case KipConfigValue_eristaGpuUV: case KipConfigValue_eristaGpuUV:
case KipConfigValue_eristaGpuVmin: case KipConfigValue_eristaGpuVmin:
case KipConfigValue_marikoGpuUV: case KipConfigValue_marikoGpuUV:

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

@@ -655,7 +655,6 @@ void MiscGui::listUI()
NamedValue("No UV", 0), NamedValue("No UV", 0),
NamedValue("SLT Table", 1), NamedValue("SLT Table", 1),
NamedValue("HiOPT Table", 2), NamedValue("HiOPT Table", 2),
NamedValue("Custom Table", 3)
}; };
ValueThresholds mCpuVoltThresholds(1160, 1180); ValueThresholds mCpuVoltThresholds(1160, 1180);
@@ -746,6 +745,25 @@ void MiscGui::listUI()
false false
); );
std::vector<NamedValue> maxClkOptions = {
NamedValue("1963MHz", 1963000),
NamedValue("2397MHz", 2397000),
NamedValue("2499MHz", 2499000),
NamedValue("2601MHz", 2601000),
NamedValue("2703MHz", 2703000),
};
addConfigButton(
KipConfigValue_marikoCpuMaxClock,
"CPU Max Clock",
ValueRange(0, 0, 1, "", 1),
"CPU Max Voltage",
&thresholdsDisabled,
{},
maxClkOptions,
false
);
addConfigButton( addConfigButton(
KipConfigValue_marikoGpuUV, KipConfigValue_marikoGpuUV,
"GPU Undervolt Table", "GPU Undervolt Table",
@@ -799,518 +817,738 @@ void MiscGui::listUI()
this->listElement->addItem(new tsl::elm::CategoryHeader("GPU Custom Table")); this->listElement->addItem(new tsl::elm::CategoryHeader("GPU Custom Table"));
if(IsMariko()) { std::vector<NamedValue> mGpuVolts = {
NamedValue("Disabled", 2000),
NamedValue("Auto", 0),
NamedValue("480mV", 480),
NamedValue("485mV", 485),
NamedValue("490mV", 490),
NamedValue("495mV", 495),
NamedValue("500mV", 500),
NamedValue("505mV", 505),
NamedValue("510mV", 510),
NamedValue("515mV", 515),
NamedValue("520mV", 520),
NamedValue("525mV", 525),
NamedValue("530mV", 530),
NamedValue("535mV", 535),
NamedValue("540mV", 540),
NamedValue("545mV", 545),
NamedValue("550mV", 550),
NamedValue("555mV", 555),
NamedValue("560mV", 560),
NamedValue("565mV", 565),
NamedValue("570mV", 570),
NamedValue("575mV", 575),
NamedValue("580mV", 580),
NamedValue("585mV", 585),
NamedValue("590mV", 590),
NamedValue("595mV", 595),
NamedValue("600mV", 600),
NamedValue("605mV", 605),
NamedValue("610mV", 610),
NamedValue("615mV", 615),
NamedValue("620mV", 620),
NamedValue("625mV", 625),
NamedValue("630mV", 630),
NamedValue("635mV", 635),
NamedValue("640mV", 640),
NamedValue("645mV", 645),
NamedValue("650mV", 650),
NamedValue("655mV", 655),
NamedValue("660mV", 660),
NamedValue("665mV", 665),
NamedValue("670mV", 670),
NamedValue("675mV", 675),
NamedValue("680mV", 680),
NamedValue("685mV", 685),
NamedValue("690mV", 690),
NamedValue("695mV", 695),
NamedValue("700mV", 700),
NamedValue("705mV", 705),
NamedValue("710mV", 710),
NamedValue("715mV", 715),
NamedValue("720mV", 720),
NamedValue("725mV", 725),
NamedValue("730mV", 730),
NamedValue("735mV", 735),
NamedValue("740mV", 740),
NamedValue("745mV", 745),
NamedValue("750mV", 750),
NamedValue("755mV", 755),
NamedValue("760mV", 760),
NamedValue("765mV", 765),
NamedValue("770mV", 770),
NamedValue("775mV", 775),
NamedValue("780mV", 780),
NamedValue("785mV", 785),
NamedValue("790mV", 790),
NamedValue("795mV", 795),
NamedValue("800mV", 800),
NamedValue("805mV", 805),
NamedValue("810mV", 810),
NamedValue("815mV", 815),
NamedValue("820mV", 820),
NamedValue("825mV", 825),
NamedValue("830mV", 830),
NamedValue("835mV", 835),
NamedValue("840mV", 840),
NamedValue("845mV", 845),
NamedValue("850mV", 850),
NamedValue("855mV", 855),
NamedValue("860mV", 860),
NamedValue("865mV", 865),
NamedValue("870mV", 870),
NamedValue("875mV", 875),
NamedValue("880mV", 880),
NamedValue("885mV", 885),
NamedValue("890mV", 890),
NamedValue("895mV", 895),
NamedValue("900mV", 900),
NamedValue("905mV", 905),
NamedValue("910mV", 910),
NamedValue("915mV", 915),
NamedValue("920mV", 920),
NamedValue("925mV", 925),
NamedValue("930mV", 930),
NamedValue("935mV", 935),
NamedValue("940mV", 940),
NamedValue("945mV", 945),
NamedValue("950mV", 950),
NamedValue("955mV", 955),
NamedValue("960mV", 960),
};
std::vector<NamedValue> eGpuVolts = {
NamedValue("Disabled", 2000),
NamedValue("Auto", 0),
NamedValue("700mV", 700),
NamedValue("705mV", 705),
NamedValue("710mV", 710),
NamedValue("715mV", 715),
NamedValue("720mV", 720),
NamedValue("725mV", 725),
NamedValue("730mV", 730),
NamedValue("735mV", 735),
NamedValue("740mV", 740),
NamedValue("745mV", 745),
NamedValue("750mV", 750),
NamedValue("755mV", 755),
NamedValue("760mV", 760),
NamedValue("765mV", 765),
NamedValue("770mV", 770),
NamedValue("775mV", 775),
NamedValue("780mV", 780),
NamedValue("785mV", 785),
NamedValue("790mV", 790),
NamedValue("795mV", 795),
NamedValue("800mV", 800),
NamedValue("805mV", 805),
NamedValue("810mV", 810),
NamedValue("815mV", 815),
NamedValue("820mV", 820),
NamedValue("825mV", 825),
NamedValue("830mV", 830),
NamedValue("835mV", 835),
NamedValue("840mV", 840),
NamedValue("845mV", 845),
NamedValue("850mV", 850),
NamedValue("855mV", 855),
NamedValue("860mV", 860),
NamedValue("865mV", 865),
NamedValue("870mV", 870),
NamedValue("875mV", 875),
NamedValue("880mV", 880),
NamedValue("885mV", 885),
NamedValue("890mV", 890),
NamedValue("895mV", 895),
NamedValue("900mV", 900),
NamedValue("905mV", 905),
NamedValue("910mV", 910),
NamedValue("915mV", 915),
NamedValue("920mV", 920),
NamedValue("925mV", 925),
NamedValue("930mV", 930),
NamedValue("935mV", 935),
NamedValue("940mV", 940),
NamedValue("945mV", 945),
NamedValue("950mV", 950),
NamedValue("955mV", 955),
NamedValue("960mV", 960),
NamedValue("965mV", 965),
NamedValue("970mV", 970),
NamedValue("975mV", 975),
NamedValue("980mV", 980),
NamedValue("985mV", 985),
NamedValue("990mV", 990),
NamedValue("995mV", 995),
};
if (IsMariko()) {
addConfigButton( addConfigButton(
KipConfigValue_g_volt_76800, KipConfigValue_g_volt_76800,
"GPU Voltage (76.8MHz)", "GPU Voltage (76.8MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_153600, KipConfigValue_g_volt_153600,
"GPU Voltage (153.6MHz)", "GPU Voltage (153.6MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_230400, KipConfigValue_g_volt_230400,
"GPU Voltage (230.4MHz)", "GPU Voltage (230.4MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_307200, KipConfigValue_g_volt_307200,
"GPU Voltage (307.2MHz)", "GPU Voltage (307.2MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_384000, KipConfigValue_g_volt_384000,
"GPU Voltage (384.0MHz)", "GPU Voltage (384.0MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_460800, KipConfigValue_g_volt_460800,
"GPU Voltage (460.8MHz)", "GPU Voltage (460.8MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_537600, KipConfigValue_g_volt_537600,
"GPU Voltage (537.6MHz)", "GPU Voltage (537.6MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_614400, KipConfigValue_g_volt_614400,
"GPU Voltage (614.4MHz)", "GPU Voltage (614.4MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_691200, KipConfigValue_g_volt_691200,
"GPU Voltage (691.2MHz)", "GPU Voltage (691.2MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_768000, KipConfigValue_g_volt_768000,
"GPU Voltage (768.0MHz)", "GPU Voltage (768.0MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_844800, KipConfigValue_g_volt_844800,
"GPU Voltage (844.8MHz)", "GPU Voltage (844.8MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_921600, KipConfigValue_g_volt_921600,
"GPU Voltage (921.6MHz)", "GPU Voltage (921.6MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_998400, KipConfigValue_g_volt_998400,
"GPU Voltage (998.4MHz)", "GPU Voltage (998.4MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_1075200, KipConfigValue_g_volt_1075200,
"GPU Voltage (1075.2MHz)", "GPU Voltage (1075.2MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_1152000, KipConfigValue_g_volt_1152000,
"GPU Voltage (1152.0MHz)", "GPU Voltage (1152.0MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_1228800, KipConfigValue_g_volt_1228800,
"GPU Voltage (1228.8MHz)", "GPU Voltage (1228.8MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_1267200, KipConfigValue_g_volt_1267200,
"GPU Voltage (1267.2MHz)", "GPU Voltage (1267.2MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_1305600, KipConfigValue_g_volt_1305600,
"GPU Voltage (1305.6MHz)", "GPU Voltage (1305.6MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_1344000, KipConfigValue_g_volt_1344000,
"GPU Voltage (1344.0MHz)", "GPU Voltage (1344.0MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_1382400, KipConfigValue_g_volt_1382400,
"GPU Voltage (1382.4MHz)", "GPU Voltage (1382.4MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_1420800, KipConfigValue_g_volt_1420800,
"GPU Voltage (1420.8MHz)", "GPU Voltage (1420.8MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_1459200, KipConfigValue_g_volt_1459200,
"GPU Voltage (1459.2MHz)", "GPU Voltage (1459.2MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_1497600, KipConfigValue_g_volt_1497600,
"GPU Voltage (1497.6MHz)", "GPU Voltage (1497.6MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_1536000, KipConfigValue_g_volt_1536000,
"GPU Voltage (1536.0MHz)", "GPU Voltage (1536.0MHz)",
ValueRange(480, 960, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&MgpuVmaxThresholds, &MgpuVmaxThresholds,
{}, {},
{}, mGpuVolts,
false false
); );
} else { } else {
addConfigButton(
addConfigButton(
KipConfigValue_g_volt_e_76800, KipConfigValue_g_volt_e_76800,
"GPU Voltage (76.8MHz)", "GPU Voltage (76.8MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_115200, KipConfigValue_g_volt_e_115200,
"GPU Voltage (115.2MHz)", "GPU Voltage (115.2MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_153600, KipConfigValue_g_volt_e_153600,
"GPU Voltage (153.6MHz)", "GPU Voltage (153.6MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_192000, KipConfigValue_g_volt_e_192000,
"GPU Voltage (192.0MHz)", "GPU Voltage (192.0MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_230400, KipConfigValue_g_volt_e_230400,
"GPU Voltage (230.4MHz)", "GPU Voltage (230.4MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_268800, KipConfigValue_g_volt_e_268800,
"GPU Voltage (268.8MHz)", "GPU Voltage (268.8MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_307200, KipConfigValue_g_volt_e_307200,
"GPU Voltage (307.2MHz)", "GPU Voltage (307.2MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_345600, KipConfigValue_g_volt_e_345600,
"GPU Voltage (345.6MHz)", "GPU Voltage (345.6MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_384000, KipConfigValue_g_volt_e_384000,
"GPU Voltage (384.0MHz)", "GPU Voltage (384.0MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_422400, KipConfigValue_g_volt_e_422400,
"GPU Voltage (422.4MHz)", "GPU Voltage (422.4MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_460800, KipConfigValue_g_volt_e_460800,
"GPU Voltage (460.8MHz)", "GPU Voltage (460.8MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_499200, KipConfigValue_g_volt_e_499200,
"GPU Voltage (499.2MHz)", "GPU Voltage (499.2MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_537600, KipConfigValue_g_volt_e_537600,
"GPU Voltage (537.6MHz)", "GPU Voltage (537.6MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_576000, KipConfigValue_g_volt_e_576000,
"GPU Voltage (576.0MHz)", "GPU Voltage (576.0MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_614400, KipConfigValue_g_volt_e_614400,
"GPU Voltage (614.4MHz)", "GPU Voltage (614.4MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_652800, KipConfigValue_g_volt_e_652800,
"GPU Voltage (652.8MHz)", "GPU Voltage (652.8MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_691200, KipConfigValue_g_volt_e_691200,
"GPU Voltage (691.2MHz)", "GPU Voltage (691.2MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_729600, KipConfigValue_g_volt_e_729600,
"GPU Voltage (729.6MHz)", "GPU Voltage (729.6MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_768000, KipConfigValue_g_volt_e_768000,
"GPU Voltage (768.0MHz)", "GPU Voltage (768.0MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_806400, KipConfigValue_g_volt_e_806400,
"GPU Voltage (806.4MHz)", "GPU Voltage (806.4MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_844800, KipConfigValue_g_volt_e_844800,
"GPU Voltage (844.8MHz)", "GPU Voltage (844.8MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_883200, KipConfigValue_g_volt_e_883200,
"GPU Voltage (883.2MHz)", "GPU Voltage (883.2MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_921600, KipConfigValue_g_volt_e_921600,
"GPU Voltage (921.6MHz)", "GPU Voltage (921.6MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_960000, KipConfigValue_g_volt_e_960000,
"GPU Voltage (960.0MHz)", "GPU Voltage (960.0MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_998400, KipConfigValue_g_volt_e_998400,
"GPU Voltage (998.4MHz)", "GPU Voltage (998.4MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_1036800, KipConfigValue_g_volt_e_1036800,
"GPU Voltage (1036.8MHz)", "GPU Voltage (1036.8MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
addConfigButton( addConfigButton(
KipConfigValue_g_volt_e_1075200, KipConfigValue_g_volt_e_1075200,
"GPU Voltage (1075.2MHz)", "GPU Voltage (1075.2MHz)",
ValueRange(700, 995, 5, "mV", 1), ValueRange(0, 0, 0, "0", 1),
"Voltage", "Voltage",
&EgpuVmaxThresholds, &EgpuVmaxThresholds,
{}, {},
{}, eGpuVolts,
false false
); );
} }

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

@@ -559,6 +559,7 @@ void ClockManager::SetKipData() {
CUST_WRITE_FIELD_BATCH(&table, marikoCpuLowVmin, this->config->GetConfigValue(KipConfigValue_marikoCpuLowVmin)); 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, marikoCpuHighVmin, this->config->GetConfigValue(KipConfigValue_marikoCpuHighVmin));
CUST_WRITE_FIELD_BATCH(&table, marikoCpuMaxVolt, this->config->GetConfigValue(KipConfigValue_marikoCpuMaxVolt)); CUST_WRITE_FIELD_BATCH(&table, marikoCpuMaxVolt, this->config->GetConfigValue(KipConfigValue_marikoCpuMaxVolt));
CUST_WRITE_FIELD_BATCH(&table, marikoCpuMaxClock, this->config->GetConfigValue(KipConfigValue_marikoCpuMaxClock) * 1000);
CUST_WRITE_FIELD_BATCH(&table, eristaCpuBoostClock, this->config->GetConfigValue(KipConfigValue_eristaCpuBoostClock) * 1000); CUST_WRITE_FIELD_BATCH(&table, eristaCpuBoostClock, this->config->GetConfigValue(KipConfigValue_eristaCpuBoostClock) * 1000);
CUST_WRITE_FIELD_BATCH(&table, marikoCpuBoostClock, this->config->GetConfigValue(KipConfigValue_marikoCpuBoostClock) * 1000); CUST_WRITE_FIELD_BATCH(&table, marikoCpuBoostClock, this->config->GetConfigValue(KipConfigValue_marikoCpuBoostClock) * 1000);
@@ -631,6 +632,7 @@ void ClockManager::GetKipData() {
configValues.values[KipConfigValue_marikoCpuLowVmin] = cust_get_mariko_cpu_low_vmin(&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_marikoCpuHighVmin] = cust_get_mariko_cpu_high_vmin(&table);
configValues.values[KipConfigValue_marikoCpuMaxVolt] = cust_get_mariko_cpu_max_volt(&table); configValues.values[KipConfigValue_marikoCpuMaxVolt] = cust_get_mariko_cpu_max_volt(&table);
configValues.values[KipConfigValue_marikoCpuMaxClock] = cust_get_marikoCpuMaxClock(&table) / 1000;
configValues.values[KipConfigValue_eristaCpuBoostClock] = cust_get_erista_cpu_boost(&table) / 1000; configValues.values[KipConfigValue_eristaCpuBoostClock] = cust_get_erista_cpu_boost(&table) / 1000;
configValues.values[KipConfigValue_marikoCpuBoostClock] = cust_get_mariko_cpu_boost(&table) / 1000; configValues.values[KipConfigValue_marikoCpuBoostClock] = cust_get_mariko_cpu_boost(&table) / 1000;

11
Source/sys-clk/sysmodule/src/kip.h
View File

@@ -8,7 +8,7 @@
#pragma pack(push, 1) #pragma pack(push, 1)
typedef struct { typedef struct {
u8 cust[4]; u8 cust[16];
u32 custRev; u32 custRev;
u32 mtcConf; u32 mtcConf;
u32 hpMode; u32 hpMode;
@@ -35,6 +35,7 @@ typedef struct {
u32 marikoCpuLowVmin; u32 marikoCpuLowVmin;
u32 marikoCpuHighVmin; u32 marikoCpuHighVmin;
u32 marikoCpuMaxVolt; u32 marikoCpuMaxVolt;
u32 marikoCpuMaxClock;
u32 eristaCpuBoostClock; u32 eristaCpuBoostClock;
u32 marikoCpuBoostClock; u32 marikoCpuBoostClock;
u32 eristaGpuUV; u32 eristaGpuUV;
@@ -51,8 +52,8 @@ typedef struct {
#pragma pack(pop) #pragma pack(pop)
#define CUST_MAGIC "CUST" #define CUST_MAGIC "HOCKIPCUST\0\0\0\0"
#define CUST_MAGIC_LEN 4 #define CUST_MAGIC_LEN 16
typedef struct { typedef struct {
FILE* file; FILE* file;
@@ -104,7 +105,7 @@ static inline bool cust_read_table(const char* path, CustomizeTable* out) {
bool ok = fread(out, 1, sizeof(CustomizeTable), f) == sizeof(CustomizeTable); bool ok = fread(out, 1, sizeof(CustomizeTable), f) == sizeof(CustomizeTable);
fclose(f); fclose(f);
return ok && memcmp(out->cust, CUST_MAGIC, 4) == 0; return ok && memcmp(out->cust, CUST_MAGIC, CUST_MAGIC_LEN) == 0;
} }
static inline bool cust_write_table(const char* path, const CustomizeTable* in) { static inline bool cust_write_table(const char* path, const CustomizeTable* in) {
@@ -190,6 +191,7 @@ static inline bool cust_set_mariko_gpu_vmax(const char* p, u32 v) { CUST_WRITE_F
static inline bool cust_set_common_gpu_offset(const char* p, u32 v) { CUST_WRITE_FIELD(p, commonGpuVoltOffset, 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_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); } static inline bool cust_set_mariko_gpu_unlock(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoGpuFullUnlock, v); }
static inline bool cust_set_marikoCpuMaxClock(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoCpuMaxClock, v); }
/* GPU VOLT ARRAY HELPERS */ /* GPU VOLT ARRAY HELPERS */
static inline bool cust_set_erista_gpu_volt(const char* p, int idx, u32 v) { static inline bool cust_set_erista_gpu_volt(const char* p, int idx, u32 v) {
@@ -255,6 +257,7 @@ static inline u32 cust_get_mariko_gpu_vmax(const CustomizeTable* t) { return CUS
static inline u32 cust_get_common_gpu_offset(const CustomizeTable* t) { return CUST_GET_FIELD(t, commonGpuVoltOffset); } 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_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_mariko_gpu_unlock(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoGpuFullUnlock); }
static inline u32 cust_get_marikoCpuMaxClock(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoCpuMaxClock); }
static inline u32 cust_get_erista_gpu_volt(const CustomizeTable* t, int idx) { static inline u32 cust_get_erista_gpu_volt(const CustomizeTable* t, int idx) {
if (!t || idx < 0 || idx >= 27) return 0; if (!t || idx < 0 || idx >= 27) return 0;

10
dist/README.md vendored
View File

@@ -83,11 +83,13 @@ Refer to COMPILATION.md
## Credits ## Credits
* **Lightos** – RAM timings * **Lightos** – loader patches development
* **ScriesM** - Atmosphere CFW * **SciresM** - Atmosphere CFW
* **KazushiMe** – Switch OC Suite * **KazushiMe** – Switch OC Suite
* **B3711** - UV Tables * **Meha** – Switch OC Suite, EOS, sys-clk-eos
* **Naga** – OC-kernel
* **B3711** – EOS
* **sys-clk team** – sys-clk * **sys-clk team** – sys-clk
* **b0rd2death** – Ultrahand sys-clk fork * **b0rd2death** – Ultrahand sys-clk fork
* **MasaGratoR and ZachyCatGames** - General help * **MasaGratoR and ZachyCatGames** - General help
* **Lightos, Dom, Samybigio, Dom, Arcdelta, Miki, Algie, Happy, Flopsider, Winnerboi77, Blaise, Alvise, TRRR and Xenshen** - Testing * **Dom, Samybigio, Arcdelta, Miki, Algie, Happy, Flopsider, Winnerboi77, Blaise, Alvise, TDRR, agjeococh and Xenshen** - Testing

BIN
dist/atmosphere/contents/00FF0000636C6BFF/exefs.nsp vendored
View File

Binary file not shown.