From 00f70e7c5e900860e744e89f615044331a1c4e4f Mon Sep 17 00:00:00 2001 From: souldbminersmwc Date: Mon, 23 Feb 2026 16:25:27 -0500 Subject: [PATCH] samymode2 --- .../loader/source/oc/customize.cpp | 146 +++--- .../loader/source/oc/customize.hpp | 4 +- .../stratosphere/loader/source/oc/pcv/pcv.cpp | 20 +- Source/sys-clk/common/include/sysclk/config.h | 116 ++--- .../sys-clk/overlay/src/ui/gui/misc_gui.cpp | 478 +++++++++++------- .../sys-clk/sysmodule/src/clock_manager.cpp | 9 +- Source/sys-clk/sysmodule/src/kip.h | 121 +++-- dist/atmosphere/kips/hoc.kip | Bin 281324 -> 281276 bytes 8 files changed, 491 insertions(+), 403 deletions(-) diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/customize.cpp b/Source/Atmosphere/stratosphere/loader/source/oc/customize.cpp index 64cc695a..42a3344f 100644 --- a/Source/Atmosphere/stratosphere/loader/source/oc/customize.cpp +++ b/Source/Atmosphere/stratosphere/loader/source/oc/customize.cpp @@ -26,7 +26,7 @@ #define DISABLED 0 #define DEACTIVATED_GPU_FREQ 2000 #define GPU_MIN_MIN_VOLT 480000 -#define CPU_MAX_MAX_VOLT 1235000 +#define CPU_MAX_MAX_VOLT 1395000 namespace ams::ldr::hoc { @@ -122,32 +122,28 @@ volatile CustomizeTable C = { .eristaGpuVoltArray = { AUTO /* 76 */, - AUTO /* 115 */, AUTO /* 153 */, - AUTO /* 192 */, AUTO /* 230 */, - AUTO /* 269 */, AUTO /* 307 */, - AUTO /* 346 */, AUTO /* 384 */, - AUTO /* 422 */, AUTO /* 460 */, - AUTO /* 499 */, AUTO /* 537 */, - AUTO /* 576 */, AUTO /* 614 */, - AUTO /* 652 */, AUTO /* 691 */, - AUTO /* 729 */, AUTO /* 768 */, - AUTO /* 806 */, AUTO /* 844 */, - AUTO /* 883 */, AUTO /* 921 */, - DEACTIVATED_GPU_FREQ /* 960 (Disabled by default) */, DEACTIVATED_GPU_FREQ /* 998 (Disabled by default) */, - DEACTIVATED_GPU_FREQ /* 1036 (Disabled by default) */, DEACTIVATED_GPU_FREQ /* 1075 (Disabled by default) */, + DEACTIVATED_GPU_FREQ /* 1152 (SLT / HiOPT Only!) */, + DEACTIVATED_GPU_FREQ /* 1228 (HiOPT Only!) */, + DEACTIVATED_GPU_FREQ /* 1305 (Disabled by default) */, + DEACTIVATED_GPU_FREQ /* 1344 (Disabled by default) */, + DEACTIVATED_GPU_FREQ /* 1382 (Disabled by default) */, + DEACTIVATED_GPU_FREQ /* 1420 (Disabled by default) */, + DEACTIVATED_GPU_FREQ /* 1459 (Disabled by default) */, + DEACTIVATED_GPU_FREQ /* 1497 (Disabled by default) */, + DEACTIVATED_GPU_FREQ /* 1536 (Disabled by default) */, }, .marikoGpuVoltArray = { @@ -167,7 +163,6 @@ volatile CustomizeTable C = { AUTO /* 1075 */, AUTO /* 1152 (SLT / HiOPT Only!) */, AUTO /* 1228 (HiOPT Only!) */, - DEACTIVATED_GPU_FREQ /* 1267 (Disabled by default) */, DEACTIVATED_GPU_FREQ /* 1305 (Disabled by default) */, DEACTIVATED_GPU_FREQ /* 1344 (Disabled by default) */, DEACTIVATED_GPU_FREQ /* 1382 (Disabled by default) */, @@ -175,6 +170,14 @@ volatile CustomizeTable C = { DEACTIVATED_GPU_FREQ /* 1459 (Disabled by default) */, DEACTIVATED_GPU_FREQ /* 1497 (Disabled by default) */, DEACTIVATED_GPU_FREQ /* 1536 (Disabled by default) */, + DEACTIVATED_GPU_FREQ /* 1574 (Disabled by default) */, + DEACTIVATED_GPU_FREQ /* 1612 (Disabled by default) */, + DEACTIVATED_GPU_FREQ /* 1651 (Disabled by default) */, + DEACTIVATED_GPU_FREQ /* 1689 (Disabled by default) */, + DEACTIVATED_GPU_FREQ /* 1728 (Disabled by default) */, + DEACTIVATED_GPU_FREQ /* 1766 (Disabled by default) */, + DEACTIVATED_GPU_FREQ /* 1804 (Disabled by default) */, + }, /* Advanced. */ @@ -199,9 +202,9 @@ volatile CustomizeTable C = { { 1581000, { 1130000, }, { 2889664, -122173, 1834, } }, { 1683000, { 1168000, }, { 5100873, -279186, 4747, } }, { 1785000, { 1225000, }, { 5100873, -279186, 4747, } }, - // { 1887000, { 1225000, }, { 5100873, -279186, 4747, } }, - // { 1989000, { 1227500, }, { 5100873, -279186, 4747, } }, - // { 2091000, { 1256250, }, { 5100873, -279186, 4747, } }, + { 1887000, { 1225000, }, { 5100873, -279186, 4747, } }, + { 1989000, { 1227500, }, { 5100873, -279186, 4747, } }, + { 2091000, { 1256250, }, { 5100873, -279186, 4747, } }, }, .eristaCpuDvfsTableSLT = { @@ -223,9 +226,13 @@ volatile CustomizeTable C = { { 1785000, { 1225000, }, { 5100873, -279186, 4747, } }, { 1887000, { 1225000, }, { 5100873, -279186, 4747, } }, { 1989000, { 1227500, }, { 5100873, -279186, 4747, } }, - { 2091000, { 1256250, }, { 5100873, -279186, 4747, } }, - { 2193000, { 1256250, }, { 5100873, -279186, 4747, } }, - { 2295000, { 1256250, }, { 5100873, -279186, 4747, } }, + { 2091000, { 1227500, }, { 5100873, -279186, 4747, } }, + { 2193000, { 1227500, }, { 5100873, -279186, 4747, } }, + { 2295000, { 1227500, }, { 5100873, -279186, 4747, } }, + { 2397000, { 1395000, }, { 5100873, -279186, 4747, } }, + { 2499000, { 1395000, }, { 6000000, -179186, 4747, } }, + { 2601000, { 1395000, }, { 6000000, -179186, 4747, } }, + { 2703000, { 1395000, }, { 6000000, -179186, 4747, } }, }, .marikoCpuDvfsTable = { @@ -247,17 +254,13 @@ volatile CustomizeTable C = { { 1785000, { 1527196, -36015, 27, }, { 1120000, } }, { 1887000, { 1609246, -37515, 27, }, { 1120000, } }, { 1963500, { 1675751, -38635, 27, }, { 1120000, } }, - // { 2091000, { 1716501, -39395, 27, }, { CPU_MAX_MAX_VOLT, } }, - // { 2193000, { 1775132, -40505, 27, }, { CPU_MAX_MAX_VOLT, } }, - // { 2295000, { 1866287, -42005, 27, }, { CPU_MAX_MAX_VOLT, } }, - // { 2397000, { 1961107, -43506, 27, }, { CPU_MAX_MAX_VOLT, } }, + { 2091000, { 1716501, -39395, 27, }, { CPU_MAX_MAX_VOLT, } }, + { 2193000, { 1775132, -40505, 27, }, { CPU_MAX_MAX_VOLT, } }, + { 2295000, { 1866287, -42005, 27, }, { CPU_MAX_MAX_VOLT, } }, + { 2397000, { 1961107, -43506, 27, }, { CPU_MAX_MAX_VOLT, } }, }, .marikoCpuDvfsTableSLT = { - { 204000, { 732856, -17335, 113, }, { } }, - { 306000, { 760024, -18195, 113, }, { } }, - { 408000, { 789258, -19055, 113, }, { } }, - { 510000, { 789258, -19055, 113, }, { } }, { 612000, { 789258, -19055, 113, }, { } }, { 714000, { 789258, -19055, 113, }, { } }, { 816000, { 789258, -19055, 113, }, { } }, @@ -279,13 +282,12 @@ volatile CustomizeTable C = { { 2499000, { 1580725, -35815, 113, }, { CPU_MAX_MAX_VOLT, } }, { 2601000, { 1702903, -36675, 113, }, { CPU_MAX_MAX_VOLT, } }, { 2703000, { 1770375, -37515, 113, }, { CPU_MAX_MAX_VOLT, } }, + { 2805000, { 1908891, -37707, 113 }, { CPU_MAX_MAX_VOLT, } }, + { 2907000, { 1960388, -38395, 113 }, { CPU_MAX_MAX_VOLT ,} }, + { 3009000, { 2011885, -39083, 113 }, { CPU_MAX_MAX_VOLT ,} }, }, .marikoCpuDvfsTable1581Tbreak { - { 204000, { 732856, -17335, 113, }, { } }, - { 306000, { 760024, -18195, 113, }, { } }, - { 408000, { 789258, -19055, 113, }, { } }, - { 510000, { 789258, -19055, 113, }, { } }, { 612000, { 853926, -20775, 113, }, { } }, { 714000, { 889361, -21625, 113, }, { } }, { 816000, { 926862, -22485, 113, }, { } }, @@ -307,13 +309,12 @@ volatile CustomizeTable C = { { 2499000, { 1736856, -35286, 113, }, { CPU_MAX_MAX_VOLT, } }, { 2601000, { 1787838, -35967, 113, }, { CPU_MAX_MAX_VOLT, } }, { 2703000, { 1838820, -36648, 113, }, { CPU_MAX_MAX_VOLT, } }, + { 2805000, { 1908891, -37707, 113 }, { CPU_MAX_MAX_VOLT, } }, + { 2907000, { 1960388, -38395, 113 }, { CPU_MAX_MAX_VOLT ,} }, + { 3009000, { 2011885, -39083, 113 }, { CPU_MAX_MAX_VOLT ,} }, }, .marikoCpuDvfsTable1683Tbreak { - { 204000, { 732856, -17335, 113, }, { } }, - { 306000, { 760024, -18195, 113, }, { } }, - { 408000, { 789258, -19055, 113, }, { } }, - { 510000, { 789258, -19055, 113, }, { } }, { 612000, { 853926, -20775, 113, }, { } }, { 714000, { 889361, -21625, 113, }, { } }, { 816000, { 926862, -22485, 113, }, { } }, @@ -335,13 +336,12 @@ volatile CustomizeTable C = { { 2499000, { 1736856, -35286, 113, }, { CPU_MAX_MAX_VOLT, } }, { 2601000, { 1787838, -35967, 113, }, { CPU_MAX_MAX_VOLT, } }, { 2703000, { 1838820, -36648, 113, }, { CPU_MAX_MAX_VOLT, } }, + { 2805000, { 1908891, -37707, 113 }, { CPU_MAX_MAX_VOLT, } }, + { 2907000, { 1960388, -38395, 113 }, { CPU_MAX_MAX_VOLT ,} }, + { 3009000, { 2011885, -39083, 113 }, { CPU_MAX_MAX_VOLT ,} }, }, .marikoCpuDvfsTableExtreme { - { 204000, { 732856, -17335, 113, }, { } }, - { 306000, { 760024, -18195, 113, }, { } }, - { 408000, { 789258, -19055, 113, }, { } }, - { 510000, { 789258, -19915, 113, }, { } }, { 612000, { 789258, -19055, 113, }, { } }, { 714000, { 820558, -19915, 113, }, { } }, { 816000, { 853926, -20775, 113, }, { } }, @@ -363,91 +363,66 @@ volatile CustomizeTable C = { { 2499000, { 1580725, -35815, 113, }, { CPU_MAX_MAX_VOLT, } }, { 2601000, { 1702903, -36675, 113, }, { CPU_MAX_MAX_VOLT, } }, { 2703000, { 1775375, -37515, 113, }, { CPU_MAX_MAX_VOLT, } }, + { 2805000, { 1908891, -37707, 113 }, { CPU_MAX_MAX_VOLT, } }, + { 2907000, { 1960388, -38395, 113 }, { CPU_MAX_MAX_VOLT ,} }, + { 3009000, { 2011885, -39083, 113 }, { CPU_MAX_MAX_VOLT ,} }, }, .eristaGpuDvfsTable = { { 76800, { }, { 814294, 8144, -940, 808, -21583, 226, } }, - { 115200, { }, { 856185, 8144, -940, 808, -21583, 226, } }, { 153600, { }, { 856185, 8144, -940, 808, -21583, 226, } }, - { 192000, { }, { 898077, 8144, -940, 808, -21583, 226, } }, { 230400, { }, { 898077, 8144, -940, 808, -21583, 226, } }, - { 268800, { }, { 939968, 8144, -940, 808, -21583, 226, } }, { 307200, { }, { 939968, 8144, -940, 808, -21583, 226, } }, - { 345600, { }, { 981860, 8144, -940, 808, -21583, 226, } }, { 384000, { }, { 981860, 8144, -940, 808, -21583, 226, } }, - { 422400, { }, { 1023751, 8144, -940, 808, -21583, 226, } }, { 460800, { }, { 1023751, 8144, -940, 808, -21583, 226, } }, - { 499200, { }, { 1065642, 8144, -940, 808, -21583, 226, } }, { 537600, { }, { 1065642, 8144, -940, 808, -21583, 226, } }, - { 576000, { }, { 1107534, 8144, -940, 808, -21583, 226, } }, { 614400, { }, { 1107534, 8144, -940, 808, -21583, 226, } }, - { 652800, { }, { 1149425, 8144, -940, 808, -21583, 226, } }, { 691200, { }, { 1149425, 8144, -940, 808, -21583, 226, } }, - { 729600, { }, { 1191317, 8144, -940, 808, -21583, 226, } }, { 768000, { }, { 1191317, 8144, -940, 808, -21583, 226, } }, - { 806400, { }, { 1233208, 8144, -940, 808, -21583, 226, } }, { 844800, { }, { 1233208, 8144, -940, 808, -21583, 226, } }, - { 883200, { }, { 1275100, 8144, -940, 808, -21583, 226, } }, { 921600, { }, { 1275100, 8144, -940, 808, -21583, 226, } }, // { 998400, { }, { 1316991, 8144, -940, 808, -21583, 226, } }, }, .eristaGpuDvfsTableSLT = { { 76800, { }, { 814294, 8144, -940, 0, 0, 226, } }, - { 115200, { }, { 856185, 8144, -940, 0, 0, 226, } }, { 153600, { }, { 856185, 8144, -940, 0, 0, 226, } }, - { 192000, { }, { 908077, 8144, -940, 0, 0, 226, } }, { 230400, { }, { 908077, 8144, -940, 0, 0, 226, } }, - { 268800, { }, { 934968, 8144, -940, 0, 0, 226, } }, { 307200, { }, { 934968, 8144, -940, 0, 0, 226, } }, - { 345600, { }, { 952860, 8144, -940, 0, 0, 226, } }, { 384000, { }, { 952860, 8144, -940, 0, 0, 226, } }, - { 422400, { }, { 978751, 8144, -940, 0, 0, 226, } }, { 460800, { }, { 978751, 8144, -940, 0, 0, 226, } }, - { 499200, { }, { 990642, 8144, -940, 0, 0, 226, } }, { 537600, { }, { 990642, 8144, -940, 0, 0, 226, } }, - { 576000, { }, { 1017534, 8144, -940, 0, 0, 226, } }, { 614400, { }, { 1017534, 8144, -940, 0, 0, 226, } }, - { 652800, { }, { 1042425, 8144, -940, 0, 0, 226, } }, { 691200, { }, { 1042425, 8144, -940, 0, 0, 226, } }, - { 729600, { }, { 1066317, 8144, -940, 0, 0, 226, } }, { 768000, { }, { 1066317, 8144, -940, 0, 0, 226, } }, - { 806400, { }, { 1093208, 8144, -940, 0, 0, 226, } }, { 844800, { }, { 1093208, 8144, -940, 0, 0, 226, } }, - { 883200, { }, { 1118100, 8144, -940, 0, 0, 226, } }, { 921600, { }, { 1118100, 8144, -940, 0, 0, 226, } }, - { 960000, { }, { 1156991, 8144, -940, 0, 0, 226, } }, }, .eristaGpuDvfsTableHiOPT = { { 76800, { }, { 814294, 8144, -940, 0, 0, 226, } }, - { 115200, { }, { 856185, 8144, -940, 0, 0, 226, } }, { 153600, { }, { 856185, 8144, -940, 0, 0, 226, } }, - { 192000, { }, { 908077, 8144, -940, 0, 0, 226, } }, { 230400, { }, { 908077, 8144, -940, 0, 0, 226, } }, - { 268800, { }, { 934968, 8144, -940, 0, 0, 226, } }, { 307200, { }, { 934968, 8144, -940, 0, 0, 226, } }, - { 345600, { }, { 952860, 8144, -940, 0, 0, 226, } }, { 384000, { }, { 952860, 8144, -940, 0, 0, 226, } }, - { 422400, { }, { 978751, 8144, -940, 0, 0, 226, } }, { 460800, { }, { 978751, 8144, -940, 0, 0, 226, } }, - { 499200, { }, { 990642, 8144, -940, 0, 0, 226, } }, { 537600, { }, { 990642, 8144, -940, 0, 0, 226, } }, - { 576000, { }, { 1017534, 8144, -940, 0, 0, 226, } }, { 614400, { }, { 1017534, 8144, -940, 0, 0, 226, } }, - { 652800, { }, { 1042425, 8144, -940, 0, 0, 226, } }, { 691200, { }, { 1042425, 8144, -940, 0, 0, 226, } }, - { 729600, { }, { 1066317, 8144, -940, 0, 0, 226, } }, { 768000, { }, { 1066317, 8144, -940, 0, 0, 226, } }, - { 806400, { }, { 1093208, 8144, -940, 0, 0, 226, } }, { 844800, { }, { 1093208, 8144, -940, 0, 0, 226, } }, - { 883200, { }, { 1118100, 8144, -940, 0, 0, 226, } }, { 921600, { }, { 1118100, 8144, -940, 0, 0, 226, } }, - { 960000, { }, { 1156991, 8144, -940, 0, 0, 226, } }, { 998400, { }, { 1156991, 8144, -940, 0, 0, 226, } }, - { 1036800, { }, { } }, { 1075200, { }, { } }, - // { 1152000, { }, { } }, + { 1152000, { }, { } }, + { 1228800, { }, { 0, 0, 0, 0, 0, 0 } }, + { 1267200, { }, { 0, 0, 0, 0, 0, 0 } }, + { 1344000, { }, { 0, 0, 0, 0, 0, 0 } }, + { 1382400, { }, { 0, 0, 0, 0, 0, 0 } }, + { 1420800, { }, { 0, 0, 0, 0, 0, 0 } }, + { 1459200, { }, { 0, 0, 0, 0, 0, 0 } }, + { 1497600, { }, { 0, 0, 0, 0, 0, 0 } }, + { 1536000, { }, { 0, 0, 0, 0, 0, 0 } }, }, .marikoGpuDvfsTable = { @@ -465,9 +440,9 @@ volatile CustomizeTable C = { { 921600, { }, { 970060,-10108, -614,-179, 1508, -13 } }, { 998400, { }, { 1065665,-16075, -497,-179, 3213, 9 } }, { 1075200, { }, { 1132576,-16093, -648, 0, 1077, 40 } }, -// { 1152000, { }, { 1180029,-14534, -830, 0, 1469, 110 } }, -// { 1228800, { }, { 1248293,-16383, -859, 0, 3722, 313 } }, -// { 1267200, { }, { 1286399,-17475, -867, 0, 3681, 559 } }, + { 1152000, { }, { 1180029,-14534, -830, 0, 1469, 110 } }, + { 1228800, { }, { 1248293,-16383, -859, 0, 3722, 313 } }, + { 1267200, { }, { 1286399,-17475, -867, 0, 3681, 559 } }, }, .marikoGpuDvfsTableSLT = { @@ -487,7 +462,7 @@ volatile CustomizeTable C = { { 1075200, { }, { 1132576, -16093, -648, 0, 1077, 40 } }, { 1152000, { }, { 1180029, -14534, -830, 0, 1469, 110 } }, { 1228800, { }, { 1238293, -16383, -859, 0, 3722, 313 } }, -// { 1267200, { }, { 1276399, -17475, -867, 0, 3681, 559 } }, + { 1267200, { }, { 1276399, -17475, -867, 0, 3681, 559 } }, }, .marikoGpuDvfsTableHiOPT = { @@ -515,6 +490,13 @@ volatile CustomizeTable C = { { 1459200, { }, { 0, 0, 0, 0, 0, 0 } }, { 1497600, { }, { 0, 0, 0, 0, 0, 0 } }, { 1536000, { }, { 0, 0, 0, 0, 0, 0 } }, + { 1574400, { }, { 0, 0, 0, 0, 0, 0 } }, + { 1612800, { }, { 0, 0, 0, 0, 0, 0 } }, + { 1651200, { }, { 0, 0, 0, 0, 0, 0 } }, + { 1689600, { }, { 0, 0, 0, 0, 0, 0 } }, + { 1728000, { }, { 0, 0, 0, 0, 0, 0 } }, + { 1766400, { }, { 0, 0, 0, 0, 0, 0 } }, + { 1804800, { }, { 0, 0, 0, 0, 0, 0 } }, }, }; diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/customize.hpp b/Source/Atmosphere/stratosphere/loader/source/oc/customize.hpp index fbbd51d4..96b6503b 100644 --- a/Source/Atmosphere/stratosphere/loader/source/oc/customize.hpp +++ b/Source/Atmosphere/stratosphere/loader/source/oc/customize.hpp @@ -125,8 +125,8 @@ typedef struct CustomizeTable { u32 gpuSpeedo; - u32 eristaGpuVoltArray[27]; - u32 marikoGpuVoltArray[24]; + u32 eristaGpuVoltArray[24]; + u32 marikoGpuVoltArray[31]; u32 fineTune_t6_tRTW; u32 fineTune_t7_tWTR; diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.cpp b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.cpp index d4551292..796d01bd 100644 --- a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.cpp +++ b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.cpp @@ -140,17 +140,17 @@ void SafetyCheck() { using namespace ams::ldr::hoc::pcv; sValidator validators[] = { - { C.eristaCpuBoostClock, 1020'000, 2295'000, true }, - { C.marikoCpuBoostClock, 1020'000, 2703'000, true }, - { C.commonEmcMemVolt, 912'500, 1350'000 }, // Official burst vmax for the RAMs is 1500mV - { C.eristaCpuMaxVolt, 1000, 1257 }, - { GET_MAX_OF_ARR(erista::maxEmcClocks), 1600'000, 2600'000 }, - { C.marikoCpuMaxVolt, 1000, 1235 }, + { C.eristaCpuBoostClock, 1020'000, 3009'000, true }, + { C.marikoCpuBoostClock, 1020'000, 3009'000, true }, + { C.commonEmcMemVolt, 912'500, 1500'000 }, // Official burst vmax for the RAMs is 1500mV + { C.eristaCpuMaxVolt, 1000, 1500 }, + { GET_MAX_OF_ARR(erista::maxEmcClocks), 1600'000, 2700'000 }, + { C.marikoCpuMaxVolt, 1000, 1500 }, { C.marikoEmcMaxClock, 1600'000, 3500'000 }, - { C.marikoEmcVddqVolt, 250'000, 700'000 }, - { eristaCpuDvfsMaxFreq, 1785'000, 2295'000 }, - { marikoCpuDvfsMaxFreq, 1785'000, 2703'000 }, - { eristaGpuDvfsMaxFreq, 768'000, 1152'000 }, + { C.marikoEmcVddqVolt, 250'000, 1500'000 }, + { eristaCpuDvfsMaxFreq, 1785'000, 3009'000 }, + { marikoCpuDvfsMaxFreq, 1785'000, 3009'000 }, + { eristaGpuDvfsMaxFreq, 768'000, 1536'000 }, { marikoGpuDvfsMaxFreq, 768'000, 1536'000 }, }; diff --git a/Source/sys-clk/common/include/sysclk/config.h b/Source/sys-clk/common/include/sysclk/config.h index 3351df41..f9751dcc 100644 --- a/Source/sys-clk/common/include/sysclk/config.h +++ b/Source/sys-clk/common/include/sysclk/config.h @@ -135,34 +135,38 @@ typedef enum { KipConfigValue_g_volt_1459200, KipConfigValue_g_volt_1497600, KipConfigValue_g_volt_1536000, + KipConfigValue_g_volt_1574400, + KipConfigValue_g_volt_1612800, + KipConfigValue_g_volt_1651200, + KipConfigValue_g_volt_1689600, + KipConfigValue_g_volt_1728000, + KipConfigValue_g_volt_1766400, + KipConfigValue_g_volt_1804800, KipConfigValue_g_volt_e_76800, - KipConfigValue_g_volt_e_115200, KipConfigValue_g_volt_e_153600, - KipConfigValue_g_volt_e_192000, KipConfigValue_g_volt_e_230400, - KipConfigValue_g_volt_e_268800, KipConfigValue_g_volt_e_307200, - KipConfigValue_g_volt_e_345600, KipConfigValue_g_volt_e_384000, - KipConfigValue_g_volt_e_422400, KipConfigValue_g_volt_e_460800, - KipConfigValue_g_volt_e_499200, KipConfigValue_g_volt_e_537600, - KipConfigValue_g_volt_e_576000, KipConfigValue_g_volt_e_614400, - KipConfigValue_g_volt_e_652800, KipConfigValue_g_volt_e_691200, - KipConfigValue_g_volt_e_729600, KipConfigValue_g_volt_e_768000, - KipConfigValue_g_volt_e_806400, KipConfigValue_g_volt_e_844800, - KipConfigValue_g_volt_e_883200, KipConfigValue_g_volt_e_921600, - KipConfigValue_g_volt_e_960000, KipConfigValue_g_volt_e_998400, - KipConfigValue_g_volt_e_1036800, KipConfigValue_g_volt_e_1075200, + KipConfigValue_g_volt_e_1152000, + KipConfigValue_g_volt_e_1228800, + KipConfigValue_g_volt_e_1267200, + KipConfigValue_g_volt_e_1305600, + KipConfigValue_g_volt_e_1344000, + KipConfigValue_g_volt_e_1382400, + KipConfigValue_g_volt_e_1420800, + KipConfigValue_g_volt_e_1459200, + KipConfigValue_g_volt_e_1497600, + KipConfigValue_g_volt_e_1536000, KipConfigValue_t6_tRTW_fine_tune, KipConfigValue_t7_tWTR_fine_tune, @@ -366,35 +370,41 @@ static inline const char* sysclkFormatConfigValue(SysClkConfigValue val, bool pr case KipConfigValue_g_volt_1459200: return pretty ? "Mariko GPU Volt 1459 MHz" : "g_volt_1459200"; 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"; + case KipConfigValue_g_volt_1574400: return pretty ? "Mariko GPU Volt 1574 MHz" : "g_volt_1574400"; + case KipConfigValue_g_volt_1612800: return pretty ? "Mariko GPU Volt 1612 MHz" : "g_volt_1612800"; + case KipConfigValue_g_volt_1651200: return pretty ? "Mariko GPU Volt 1651 MHz" : "g_volt_1651200"; + case KipConfigValue_g_volt_1689600: return pretty ? "Mariko GPU Volt 1689 MHz" : "g_volt_1689600"; + case KipConfigValue_g_volt_1728000: return pretty ? "Mariko GPU Volt 1728 MHz" : "g_volt_1728000"; + case KipConfigValue_g_volt_1766400: return pretty ? "Mariko GPU Volt 1766 MHz" : "g_volt_1766400"; + case KipConfigValue_g_volt_1804800: return pretty ? "Mariko GPU Volt 1804 MHz" : "g_volt_1804800"; + // 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"; - case KipConfigValue_g_volt_e_192000: return pretty ? "Erista GPU Volt 192 MHz" : "g_volt_e_192000"; case KipConfigValue_g_volt_e_230400: return pretty ? "Erista GPU Volt 230 MHz" : "g_volt_e_230400"; - case KipConfigValue_g_volt_e_268800: return pretty ? "Erista GPU Volt 268 MHz" : "g_volt_e_268800"; case KipConfigValue_g_volt_e_307200: return pretty ? "Erista GPU Volt 307 MHz" : "g_volt_e_307200"; - case KipConfigValue_g_volt_e_345600: return pretty ? "Erista GPU Volt 345 MHz" : "g_volt_e_345600"; case KipConfigValue_g_volt_e_384000: return pretty ? "Erista GPU Volt 384 MHz" : "g_volt_e_384000"; - case KipConfigValue_g_volt_e_422400: return pretty ? "Erista GPU Volt 422 MHz" : "g_volt_e_422400"; case KipConfigValue_g_volt_e_460800: return pretty ? "Erista GPU Volt 460 MHz" : "g_volt_e_460800"; - case KipConfigValue_g_volt_e_499200: return pretty ? "Erista GPU Volt 499 MHz" : "g_volt_e_499200"; case KipConfigValue_g_volt_e_537600: return pretty ? "Erista GPU Volt 537 MHz" : "g_volt_e_537600"; - case KipConfigValue_g_volt_e_576000: return pretty ? "Erista GPU Volt 576 MHz" : "g_volt_e_576000"; case KipConfigValue_g_volt_e_614400: return pretty ? "Erista GPU Volt 614 MHz" : "g_volt_e_614400"; - case KipConfigValue_g_volt_e_652800: return pretty ? "Erista GPU Volt 652 MHz" : "g_volt_e_652800"; case KipConfigValue_g_volt_e_691200: return pretty ? "Erista GPU Volt 691 MHz" : "g_volt_e_691200"; - case KipConfigValue_g_volt_e_729600: return pretty ? "Erista GPU Volt 729 MHz" : "g_volt_e_729600"; case KipConfigValue_g_volt_e_768000: return pretty ? "Erista GPU Volt 768 MHz" : "g_volt_e_768000"; - case KipConfigValue_g_volt_e_806400: return pretty ? "Erista GPU Volt 806 MHz" : "g_volt_e_806400"; case KipConfigValue_g_volt_e_844800: return pretty ? "Erista GPU Volt 844 MHz" : "g_volt_e_844800"; - case KipConfigValue_g_volt_e_883200: return pretty ? "Erista GPU Volt 883 MHz" : "g_volt_e_883200"; case KipConfigValue_g_volt_e_921600: return pretty ? "Erista GPU Volt 921 MHz" : "g_volt_e_921600"; - case KipConfigValue_g_volt_e_960000: return pretty ? "Erista GPU Volt 960 MHz" : "g_volt_e_960000"; case KipConfigValue_g_volt_e_998400: return pretty ? "Erista GPU Volt 998 MHz" : "g_volt_e_998400"; - case KipConfigValue_g_volt_e_1036800: return pretty ? "Erista GPU Volt 1036 MHz" : "g_volt_e_1036800"; case KipConfigValue_g_volt_e_1075200: return pretty ? "Erista GPU Volt 1075 MHz" : "g_volt_e_1075200"; + case KipConfigValue_g_volt_e_1152000: return pretty ? "Erista GPU Volt 1152 MHz" : "g_volt_e_1152000"; + case KipConfigValue_g_volt_e_1228800: return pretty ? "Erista GPU Volt 1228 MHz" : "g_volt_e_1228800"; + case KipConfigValue_g_volt_e_1267200: return pretty ? "Erista GPU Volt 1267 MHz" : "g_volt_e_1267200"; + case KipConfigValue_g_volt_e_1305600: return pretty ? "Erista GPU Volt 1305 MHz" : "g_volt_e_1305600"; + case KipConfigValue_g_volt_e_1344000: return pretty ? "Erista GPU Volt 1344 MHz" : "g_volt_e_1344000"; + case KipConfigValue_g_volt_e_1382400: return pretty ? "Erista GPU Volt 1382 MHz" : "g_volt_e_1382400"; + case KipConfigValue_g_volt_e_1420800: return pretty ? "Erista GPU Volt 1420 MHz" : "g_volt_e_1420800"; + case KipConfigValue_g_volt_e_1459200: return pretty ? "Erista GPU Volt 1459 MHz" : "g_volt_e_1459200"; + case KipConfigValue_g_volt_e_1497600: return pretty ? "Erista GPU Volt 1497 MHz" : "g_volt_e_1497600"; + case KipConfigValue_g_volt_e_1536000: return pretty ? "Erista GPU Volt 1536 MHz" : "g_volt_e_1536000"; + case KipConfigValue_t6_tRTW_fine_tune: return pretty ? "t6 - tRTW Fine Tune" : "t6_tRTW_fine_fune"; case KipConfigValue_t7_tWTR_fine_tune: return pretty ? "t7 - tWTR Fine Tune" : "t7_tWTR_fine_tune"; case KipCrc32: @@ -435,6 +445,7 @@ static inline uint64_t sysclkDefaultConfigValue(SysClkConfigValue val) case HocClkConfigValue_HandheldTDP: case HocClkConfigValue_IsFirstLoad: case HorizonOCConfigValue_DVFSMode: + case HorizonOCConfigValue_EnableExperimentalSettings: return 1ULL; case HocClkConfigValue_ThermalThrottleThreshold: return 70ULL; @@ -513,57 +524,6 @@ static inline uint64_t sysclkValidConfigValue(SysClkConfigValue val, uint64_t in case KipConfigValue_marikoGpuVmax: case KipConfigValue_commonGpuVoltOffset: case KipConfigValue_gpuSpeedo: - case KipConfigValue_g_volt_76800: - case KipConfigValue_g_volt_153600: - case KipConfigValue_g_volt_230400: - case KipConfigValue_g_volt_307200: - case KipConfigValue_g_volt_384000: - case KipConfigValue_g_volt_460800: - case KipConfigValue_g_volt_537600: - case KipConfigValue_g_volt_614400: - case KipConfigValue_g_volt_691200: - case KipConfigValue_g_volt_768000: - case KipConfigValue_g_volt_844800: - case KipConfigValue_g_volt_921600: - case KipConfigValue_g_volt_998400: - case KipConfigValue_g_volt_1075200: - case KipConfigValue_g_volt_1152000: - case KipConfigValue_g_volt_1228800: - case KipConfigValue_g_volt_1267200: - case KipConfigValue_g_volt_1305600: - case KipConfigValue_g_volt_1344000: - case KipConfigValue_g_volt_1382400: - case KipConfigValue_g_volt_1420800: - case KipConfigValue_g_volt_1459200: - case KipConfigValue_g_volt_1497600: - case KipConfigValue_g_volt_1536000: - case KipConfigValue_g_volt_e_76800: - case KipConfigValue_g_volt_e_115200: - case KipConfigValue_g_volt_e_153600: - case KipConfigValue_g_volt_e_192000: - case KipConfigValue_g_volt_e_230400: - case KipConfigValue_g_volt_e_268800: - case KipConfigValue_g_volt_e_307200: - case KipConfigValue_g_volt_e_345600: - case KipConfigValue_g_volt_e_384000: - case KipConfigValue_g_volt_e_422400: - case KipConfigValue_g_volt_e_460800: - case KipConfigValue_g_volt_e_499200: - case KipConfigValue_g_volt_e_537600: - case KipConfigValue_g_volt_e_576000: - case KipConfigValue_g_volt_e_614400: - case KipConfigValue_g_volt_e_652800: - case KipConfigValue_g_volt_e_691200: - case KipConfigValue_g_volt_e_729600: - case KipConfigValue_g_volt_e_768000: - case KipConfigValue_g_volt_e_806400: - case KipConfigValue_g_volt_e_844800: - case KipConfigValue_g_volt_e_883200: - case KipConfigValue_g_volt_e_921600: - case KipConfigValue_g_volt_e_960000: - case KipConfigValue_g_volt_e_998400: - case KipConfigValue_g_volt_e_1036800: - case KipConfigValue_g_volt_e_1075200: case KipConfigValue_eristaCpuVmin: case KipConfigValue_eristaCpuUnlock: case KipConfigValue_t6_tRTW_fine_tune: @@ -576,6 +536,6 @@ static inline uint64_t sysclkValidConfigValue(SysClkConfigValue val, uint64_t in case HorizonOCConfigValue_BatteryChargeCurrent: return ((input >= 1024) && (input <= 3072)) || !input; default: - return false; + return true; } } \ 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 44746447..a654d96d 100644 --- a/Source/sys-clk/overlay/src/ui/gui/misc_gui.cpp +++ b/Source/sys-clk/overlay/src/ui/gui/misc_gui.cpp @@ -396,14 +396,6 @@ void MiscGui::listUI() if(!IsHoag()) { this->listElement->addItem(new tsl::elm::CategoryHeader("Display")); addConfigToggle(HorizonOCConfigValue_OverwriteRefreshRate, nullptr); - tsl::elm::CustomDrawer* warningText = new tsl::elm::CustomDrawer([](tsl::gfx::Renderer *renderer, s32 x, s32 y, s32 w, s32 h) { - renderer->drawString("\uE150 Enabling unsafe display", false, x + 20, y + 30, 18, tsl::style::color::ColorText); - renderer->drawString("refresh rates may cause stress", false, x + 20, y + 50, 18, tsl::style::color::ColorText); - renderer->drawString("or damage to your display! ", false, x + 20, y + 70, 18, tsl::style::color::ColorText); - renderer->drawString("Proceed at your own risk!", false, x + 20, y + 90, 18, tsl::style::color::ColorText); - }); - warningText->setBoundaries(0, 0, tsl::cfg::FramebufferWidth, 110); - this->listElement->addItem(warningText); addConfigToggle(HorizonOCConfigValue_EnableUnsafeDisplayFreqs, nullptr); } #if IS_MINIMAL == 0 @@ -437,67 +429,37 @@ void MiscGui::listUI() gpuSchedMethodValues, false ); - tsl::elm::CustomDrawer* chargeWarningText = new tsl::elm::CustomDrawer([](tsl::gfx::Renderer *renderer, s32 x, s32 y, s32 w, s32 h) { - renderer->drawString("\uE150 Overriding the charge current", false, x + 20, y + 30, 18, tsl::style::color::ColorText); - renderer->drawString("can be dangerous and may cause", false, x + 20, y + 50, 18, tsl::style::color::ColorText); - renderer->drawString("damage to your battery or charger!", false, x + 20, y + 70, 18, tsl::style::color::ColorText); - }); - chargeWarningText->setBoundaries(0, 0, tsl::cfg::FramebufferWidth, 90); - this->listElement->addItem(chargeWarningText); - if(!IsHoag()) { - std::vector chargerCurrents = { - NamedValue("Disabled", 0), - NamedValue("1024mA", 1024), - NamedValue("1280mA", 1280), - NamedValue("1536mA", 1536), - NamedValue("1792mA", 1792), - NamedValue("2048mA", 2048), - NamedValue("2304mA", 2304), - NamedValue("2560mA", 2560), - NamedValue("2816mA", 2816), - NamedValue("3072mA", 3072), - }; + std::vector chargerCurrents = { + NamedValue("Disabled", 0), + NamedValue("1024mA", 1024), + NamedValue("1280mA", 1280), + NamedValue("1536mA", 1536), + NamedValue("1792mA", 1792), + NamedValue("2048mA", 2048), + NamedValue("2304mA", 2304), + NamedValue("2560mA", 2560), + NamedValue("2816mA", 2816), + NamedValue("3072mA", 3072), + NamedValue("3328mA", 3328), + NamedValue("3840mA", 3840), + NamedValue("4096mA", 4096), + NamedValue("4352mA", 4352), + NamedValue("4608mA", 4608), + }; - ValueThresholds chargerThresholds(2048, 2049); + ValueThresholds chargerThresholds(2048, 2049); - addConfigButton( - HorizonOCConfigValue_BatteryChargeCurrent, - "Charge Current Override", - ValueRange(0, 0, 1, "", 0), - "Charge Current Override", - &chargerThresholds, - {}, - chargerCurrents, - false - ); - } - else { - std::vector chargerCurrents = { - NamedValue("Disabled", 0), - NamedValue("1024mA", 1024), - NamedValue("1280mA", 1280), - NamedValue("1536mA", 1536), - NamedValue("1792mA", 1792), - NamedValue("2048mA", 2048), - NamedValue("2304mA", 2304), - NamedValue("2560mA", 2560), - }; - - ValueThresholds chargerThresholds(1792, 1793); - - addConfigButton( - HorizonOCConfigValue_BatteryChargeCurrent, - "Charge Current Override", - ValueRange(0, 0, 1, "", 0), - "Charge Current Override", - &chargerThresholds, - {}, - chargerCurrents, - false - ); - - } + addConfigButton( + HorizonOCConfigValue_BatteryChargeCurrent, + "Charge Current Override", + ValueRange(0, 0, 1, "", 0), + "Charge Current Override", + &chargerThresholds, + {}, + chargerCurrents, + false + ); } #endif } @@ -572,12 +534,12 @@ protected: NamedValue("3233MHz", 3233000, "High speedo needed!"), NamedValue("3266MHz", 3266000, "High speedo needed!"), NamedValue("3300MHz", 3300000, "High speedo needed!"), - // NamedValue("3333MHz (Needs extreme Speedo/PLL)", 3333000), - // NamedValue("3366MHz (Needs extreme Speedo/PLL)", 3366000), - // NamedValue("3400MHz (Needs extreme Speedo/PLL)", 3400000), - // NamedValue("3433MHz (Needs ridiculous Speedo/PLL)", 3433000), - // NamedValue("3466MHz (Needs ridiculous Speedo/PLL)", 3466000), - // NamedValue("3500MHz (Needs ridiculous Speedo/PLL)", 3500000), + NamedValue("3333MHz", 3333000, "High speedo needed!"), + NamedValue("3366MHz", 3366000, "High speedo needed!"), + NamedValue("3400MHz", 3400000, "High speedo needed!"), + NamedValue("3433MHz", 3433000, "High speedo needed!"), + NamedValue("3466MHz", 3466000, "High speedo needed!"), + NamedValue("3500MHz", 3500000, "High speedo needed!"), }; std::vector eristaMaxEmcClock = { @@ -618,6 +580,21 @@ protected: NamedValue("2361MHz", 2361600), NamedValue("2380MHz", 2380800), NamedValue("2400MHz", 2400000, "JEDEC."), + NamedValue("2423MHz", 2423200), + NamedValue("2442MHz", 2442400), + NamedValue("2461MHz", 2461600), + NamedValue("2480MHz", 2480800), + NamedValue("2500MHz", 2500000), + NamedValue("2523MHz", 2523200), + NamedValue("2542MHz", 2542400), + NamedValue("2561MHz", 2561600), + NamedValue("2580MHz", 2580800), + NamedValue("2600MHz", 2600000), + NamedValue("2623MHz", 2623200), + NamedValue("2642MHz", 2642400), + NamedValue("2661MHz", 2661600), + NamedValue("2680MHz", 2680800), + NamedValue("2700MHz", 2700000), }; if(IsErista()) { @@ -650,7 +627,7 @@ protected: addConfigButton( KipConfigValue_commonEmcMemVolt, "RAM VDD2 Voltage", - ValueRange(912500, 1350000, 12500, "mV", 1000, 1), + ValueRange(912500, 1500000, 12500, "mV", 1000, 1), "Voltage", &vdd2Thresholds, emc_voltage_label, @@ -662,7 +639,7 @@ protected: addConfigButton( KipConfigValue_marikoEmcVddqVolt, "RAM VDDQ Voltage", - ValueRange(400000, 700000, 5000, "mV", 1000), + ValueRange(400000, 1500000, 5000, "mV", 1000), "RAM VDDQ Voltage", &thresholdsDisabled, {}, @@ -834,6 +811,10 @@ protected: NamedValue("2091 MHz", 2091000), NamedValue("2193 MHz", 2193000), NamedValue("2295 MHz", 2295000), + NamedValue("2397 MHz", 2797000), + NamedValue("2499 MHz", 2499000), + NamedValue("2601 MHz", 2601000), + NamedValue("2703 MHz", 2703000), }; ValueThresholds eCpuClockThresholds(1785000, 2091000); addConfigButton( @@ -873,7 +854,7 @@ protected: addConfigButton( KipConfigValue_eristaCpuMaxVolt, "CPU Max Voltage", - ValueRange(1120, 1235, 5, "mV", 1), + ValueRange(1120, 1525, 5, "mV", 1), "CPU Max Voltage", &thresholdsDisabled, {}, @@ -931,6 +912,9 @@ protected: NamedValue("2499 MHz", 2499000), NamedValue("2601 MHz", 2601000), NamedValue("2703 MHz", 2703000), + NamedValue("2805 MHz", 2805000), + NamedValue("2907 MHz", 2907000), + NamedValue("3009 MHz", 3009000), }; ValueThresholds mCpuMaxClockThresholds(1963000, 2397000); addConfigButton( @@ -970,7 +954,7 @@ protected: addConfigButton( KipConfigValue_marikoCpuMaxVolt, "CPU Max Voltage", - ValueRange(1000, 1235, 5, "mV", 1), + ValueRange(1000, 1525, 5, "mV", 1), "CPU Max Voltage", &mCpuVoltThresholds, {}, @@ -1075,7 +1059,7 @@ protected: addConfigButton( KipConfigValue_marikoGpuVmax, "GPU Maximum Voltage", - ValueRange(750, 960, 5, "mV", 1), + ValueRange(750, 1525, 5, "mV", 1), "GPU Maximum Voltage", &MgpuVmaxThresholds, {}, @@ -1160,32 +1144,119 @@ protected: 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("960mV", 960), NamedValue("965mV", 965), NamedValue("970mV", 970), + NamedValue("975mV", 975), NamedValue("980mV", 980), NamedValue("985mV", 985), + NamedValue("990mV", 990), NamedValue("995mV", 995), NamedValue("1000mV", 1000), + NamedValue("1005mV", 1005), NamedValue("1010mV", 1010), NamedValue("1015mV", 1015), + NamedValue("1020mV", 1020), NamedValue("1025mV", 1025), NamedValue("1030mV", 1030), + NamedValue("1035mV", 1035), NamedValue("1040mV", 1040), NamedValue("1045mV", 1045), + NamedValue("1050mV", 1050), NamedValue("1055mV", 1055), NamedValue("1060mV", 1060), + NamedValue("1065mV", 1065), NamedValue("1070mV", 1070), NamedValue("1075mV", 1075), + NamedValue("1080mV", 1080), NamedValue("1085mV", 1085), NamedValue("1090mV", 1090), + NamedValue("1095mV", 1095), NamedValue("1100mV", 1100), NamedValue("1105mV", 1105), + NamedValue("1110mV", 1110), NamedValue("1115mV", 1115), NamedValue("1120mV", 1120), + NamedValue("1125mV", 1125), NamedValue("1130mV", 1130), NamedValue("1135mV", 1135), + NamedValue("1140mV", 1140), NamedValue("1145mV", 1145), NamedValue("1150mV", 1150), + NamedValue("1155mV", 1155), NamedValue("1160mV", 1160), NamedValue("1165mV", 1165), + NamedValue("1170mV", 1170), NamedValue("1175mV", 1175), NamedValue("1180mV", 1180), + NamedValue("1185mV", 1185), NamedValue("1190mV", 1190), NamedValue("1195mV", 1195), + NamedValue("1200mV", 1200), NamedValue("1205mV", 1205), NamedValue("1210mV", 1210), + NamedValue("1215mV", 1215), NamedValue("1220mV", 1220), NamedValue("1225mV", 1225), + NamedValue("1230mV", 1230), NamedValue("1235mV", 1235), NamedValue("1240mV", 1240), + NamedValue("1245mV", 1245), NamedValue("1250mV", 1250), NamedValue("1255mV", 1255), + NamedValue("1260mV", 1260), NamedValue("1265mV", 1265), NamedValue("1270mV", 1270), + NamedValue("1275mV", 1275), NamedValue("1280mV", 1280), NamedValue("1285mV", 1285), + NamedValue("1290mV", 1290), NamedValue("1295mV", 1295), NamedValue("1300mV", 1300), + NamedValue("1305mV", 1305), NamedValue("1310mV", 1310), NamedValue("1315mV", 1315), + NamedValue("1320mV", 1320), NamedValue("1325mV", 1325), NamedValue("1330mV", 1330), + NamedValue("1335mV", 1335), NamedValue("1340mV", 1340), NamedValue("1345mV", 1345), + NamedValue("1350mV", 1350), NamedValue("1355mV", 1355), NamedValue("1360mV", 1360), + NamedValue("1365mV", 1365), NamedValue("1370mV", 1370), NamedValue("1375mV", 1375), + NamedValue("1380mV", 1380), NamedValue("1385mV", 1385), NamedValue("1390mV", 1390), + NamedValue("1395mV", 1395), NamedValue("1400mV", 1400), NamedValue("1405mV", 1405), + NamedValue("1410mV", 1410), NamedValue("1415mV", 1415), NamedValue("1420mV", 1420), + NamedValue("1425mV", 1425), NamedValue("1430mV", 1430), NamedValue("1435mV", 1435), + NamedValue("1440mV", 1440), NamedValue("1445mV", 1445), NamedValue("1450mV", 1450), + NamedValue("1455mV", 1455), NamedValue("1460mV", 1460), NamedValue("1465mV", 1465), + NamedValue("1470mV", 1470), NamedValue("1475mV", 1475), NamedValue("1480mV", 1480), + NamedValue("1485mV", 1485), NamedValue("1490mV", 1490), NamedValue("1495mV", 1495), + NamedValue("1500mV", 1500), NamedValue("1505mV", 1505), NamedValue("1510mV", 1510), + NamedValue("1515mV", 1515), NamedValue("1520mV", 1520), NamedValue("1525mV", 1525), }; std::vector 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), + 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), NamedValue("965mV", 965), NamedValue("970mV", 970), + NamedValue("975mV", 975), NamedValue("980mV", 980), NamedValue("985mV", 985), + NamedValue("990mV", 990), NamedValue("995mV", 995), NamedValue("1000mV", 1000), + NamedValue("1005mV", 1005), NamedValue("1010mV", 1010), NamedValue("1015mV", 1015), + NamedValue("1020mV", 1020), NamedValue("1025mV", 1025), NamedValue("1030mV", 1030), + NamedValue("1035mV", 1035), NamedValue("1040mV", 1040), NamedValue("1045mV", 1045), + NamedValue("1050mV", 1050), NamedValue("1055mV", 1055), NamedValue("1060mV", 1060), + NamedValue("1065mV", 1065), NamedValue("1070mV", 1070), NamedValue("1075mV", 1075), + NamedValue("1080mV", 1080), NamedValue("1085mV", 1085), NamedValue("1090mV", 1090), + NamedValue("1095mV", 1095), NamedValue("1100mV", 1100), NamedValue("1105mV", 1105), + NamedValue("1110mV", 1110), NamedValue("1115mV", 1115), NamedValue("1120mV", 1120), + NamedValue("1125mV", 1125), NamedValue("1130mV", 1130), NamedValue("1135mV", 1135), + NamedValue("1140mV", 1140), NamedValue("1145mV", 1145), NamedValue("1150mV", 1150), + NamedValue("1155mV", 1155), NamedValue("1160mV", 1160), NamedValue("1165mV", 1165), + NamedValue("1170mV", 1170), NamedValue("1175mV", 1175), NamedValue("1180mV", 1180), + NamedValue("1185mV", 1185), NamedValue("1190mV", 1190), NamedValue("1195mV", 1195), + NamedValue("1200mV", 1200), NamedValue("1205mV", 1205), NamedValue("1210mV", 1210), + NamedValue("1215mV", 1215), NamedValue("1220mV", 1220), NamedValue("1225mV", 1225), + NamedValue("1230mV", 1230), NamedValue("1235mV", 1235), NamedValue("1240mV", 1240), + NamedValue("1245mV", 1245), NamedValue("1250mV", 1250), NamedValue("1255mV", 1255), + NamedValue("1260mV", 1260), NamedValue("1265mV", 1265), NamedValue("1270mV", 1270), + NamedValue("1275mV", 1275), NamedValue("1280mV", 1280), NamedValue("1285mV", 1285), + NamedValue("1290mV", 1290), NamedValue("1295mV", 1295), NamedValue("1300mV", 1300), + NamedValue("1305mV", 1305), NamedValue("1310mV", 1310), NamedValue("1315mV", 1315), + NamedValue("1320mV", 1320), NamedValue("1325mV", 1325), NamedValue("1330mV", 1330), + NamedValue("1335mV", 1335), NamedValue("1340mV", 1340), NamedValue("1345mV", 1345), + NamedValue("1350mV", 1350), NamedValue("1355mV", 1355), NamedValue("1360mV", 1360), + NamedValue("1365mV", 1365), NamedValue("1370mV", 1370), NamedValue("1375mV", 1375), + NamedValue("1380mV", 1380), NamedValue("1385mV", 1385), NamedValue("1390mV", 1390), + NamedValue("1395mV", 1395), NamedValue("1400mV", 1400), NamedValue("1405mV", 1405), + NamedValue("1410mV", 1410), NamedValue("1415mV", 1415), NamedValue("1420mV", 1420), + NamedValue("1425mV", 1425), NamedValue("1430mV", 1430), NamedValue("1435mV", 1435), + NamedValue("1440mV", 1440), NamedValue("1445mV", 1445), NamedValue("1450mV", 1450), + NamedValue("1455mV", 1455), NamedValue("1460mV", 1460), NamedValue("1465mV", 1465), + NamedValue("1470mV", 1470), NamedValue("1475mV", 1475), NamedValue("1480mV", 1480), + NamedValue("1485mV", 1485), NamedValue("1490mV", 1490), NamedValue("1495mV", 1495), + NamedValue("1500mV", 1500), NamedValue("1505mV", 1505), NamedValue("1510mV", 1510), + NamedValue("1515mV", 1515), NamedValue("1520mV", 1520), NamedValue("1525mV", 1525), }; std::vector mGpuVolts_noAuto = { @@ -1222,45 +1293,121 @@ protected: 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("960mV", 960), NamedValue("965mV", 965), NamedValue("970mV", 970), + NamedValue("975mV", 975), NamedValue("980mV", 980), NamedValue("985mV", 985), + NamedValue("990mV", 990), NamedValue("995mV", 995), NamedValue("1000mV", 1000), + NamedValue("1005mV", 1005), NamedValue("1010mV", 1010), NamedValue("1015mV", 1015), + NamedValue("1020mV", 1020), NamedValue("1025mV", 1025), NamedValue("1030mV", 1030), + NamedValue("1035mV", 1035), NamedValue("1040mV", 1040), NamedValue("1045mV", 1045), + NamedValue("1050mV", 1050), NamedValue("1055mV", 1055), NamedValue("1060mV", 1060), + NamedValue("1065mV", 1065), NamedValue("1070mV", 1070), NamedValue("1075mV", 1075), + NamedValue("1080mV", 1080), NamedValue("1085mV", 1085), NamedValue("1090mV", 1090), + NamedValue("1095mV", 1095), NamedValue("1100mV", 1100), NamedValue("1105mV", 1105), + NamedValue("1110mV", 1110), NamedValue("1115mV", 1115), NamedValue("1120mV", 1120), + NamedValue("1125mV", 1125), NamedValue("1130mV", 1130), NamedValue("1135mV", 1135), + NamedValue("1140mV", 1140), NamedValue("1145mV", 1145), NamedValue("1150mV", 1150), + NamedValue("1155mV", 1155), NamedValue("1160mV", 1160), NamedValue("1165mV", 1165), + NamedValue("1170mV", 1170), NamedValue("1175mV", 1175), NamedValue("1180mV", 1180), + NamedValue("1185mV", 1185), NamedValue("1190mV", 1190), NamedValue("1195mV", 1195), + NamedValue("1200mV", 1200), NamedValue("1205mV", 1205), NamedValue("1210mV", 1210), + NamedValue("1215mV", 1215), NamedValue("1220mV", 1220), NamedValue("1225mV", 1225), + NamedValue("1230mV", 1230), NamedValue("1235mV", 1235), NamedValue("1240mV", 1240), + NamedValue("1245mV", 1245), NamedValue("1250mV", 1250), NamedValue("1255mV", 1255), + NamedValue("1260mV", 1260), NamedValue("1265mV", 1265), NamedValue("1270mV", 1270), + NamedValue("1275mV", 1275), NamedValue("1280mV", 1280), NamedValue("1285mV", 1285), + NamedValue("1290mV", 1290), NamedValue("1295mV", 1295), NamedValue("1300mV", 1300), + NamedValue("1305mV", 1305), NamedValue("1310mV", 1310), NamedValue("1315mV", 1315), + NamedValue("1320mV", 1320), NamedValue("1325mV", 1325), NamedValue("1330mV", 1330), + NamedValue("1335mV", 1335), NamedValue("1340mV", 1340), NamedValue("1345mV", 1345), + NamedValue("1350mV", 1350), NamedValue("1355mV", 1355), NamedValue("1360mV", 1360), + NamedValue("1365mV", 1365), NamedValue("1370mV", 1370), NamedValue("1375mV", 1375), + NamedValue("1380mV", 1380), NamedValue("1385mV", 1385), NamedValue("1390mV", 1390), + NamedValue("1395mV", 1395), NamedValue("1400mV", 1400), NamedValue("1405mV", 1405), + NamedValue("1410mV", 1410), NamedValue("1415mV", 1415), NamedValue("1420mV", 1420), + NamedValue("1425mV", 1425), NamedValue("1430mV", 1430), NamedValue("1435mV", 1435), + NamedValue("1440mV", 1440), NamedValue("1445mV", 1445), NamedValue("1450mV", 1450), + NamedValue("1455mV", 1455), NamedValue("1460mV", 1460), NamedValue("1465mV", 1465), + NamedValue("1470mV", 1470), NamedValue("1475mV", 1475), NamedValue("1480mV", 1480), + NamedValue("1485mV", 1485), NamedValue("1490mV", 1490), NamedValue("1495mV", 1495), + NamedValue("1500mV", 1500), NamedValue("1505mV", 1505), NamedValue("1510mV", 1510), + NamedValue("1515mV", 1515), NamedValue("1520mV", 1520), NamedValue("1525mV", 1525), }; std::vector eGpuVolts_noAuto = { NamedValue("Disabled", 2000), - 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), + 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), NamedValue("965mV", 965), NamedValue("970mV", 970), + NamedValue("975mV", 975), NamedValue("980mV", 980), NamedValue("985mV", 985), + NamedValue("990mV", 990), NamedValue("995mV", 995), NamedValue("1000mV", 1000), + NamedValue("1005mV", 1005), NamedValue("1010mV", 1010), NamedValue("1015mV", 1015), + NamedValue("1020mV", 1020), NamedValue("1025mV", 1025), NamedValue("1030mV", 1030), + NamedValue("1035mV", 1035), NamedValue("1040mV", 1040), NamedValue("1045mV", 1045), + NamedValue("1050mV", 1050), NamedValue("1055mV", 1055), NamedValue("1060mV", 1060), + NamedValue("1065mV", 1065), NamedValue("1070mV", 1070), NamedValue("1075mV", 1075), + NamedValue("1080mV", 1080), NamedValue("1085mV", 1085), NamedValue("1090mV", 1090), + NamedValue("1095mV", 1095), NamedValue("1100mV", 1100), NamedValue("1105mV", 1105), + NamedValue("1110mV", 1110), NamedValue("1115mV", 1115), NamedValue("1120mV", 1120), + NamedValue("1125mV", 1125), NamedValue("1130mV", 1130), NamedValue("1135mV", 1135), + NamedValue("1140mV", 1140), NamedValue("1145mV", 1145), NamedValue("1150mV", 1150), + NamedValue("1155mV", 1155), NamedValue("1160mV", 1160), NamedValue("1165mV", 1165), + NamedValue("1170mV", 1170), NamedValue("1175mV", 1175), NamedValue("1180mV", 1180), + NamedValue("1185mV", 1185), NamedValue("1190mV", 1190), NamedValue("1195mV", 1195), + NamedValue("1200mV", 1200), NamedValue("1205mV", 1205), NamedValue("1210mV", 1210), + NamedValue("1215mV", 1215), NamedValue("1220mV", 1220), NamedValue("1225mV", 1225), + NamedValue("1230mV", 1230), NamedValue("1235mV", 1235), NamedValue("1240mV", 1240), + NamedValue("1245mV", 1245), NamedValue("1250mV", 1250), NamedValue("1255mV", 1255), + NamedValue("1260mV", 1260), NamedValue("1265mV", 1265), NamedValue("1270mV", 1270), + NamedValue("1275mV", 1275), NamedValue("1280mV", 1280), NamedValue("1285mV", 1285), + NamedValue("1290mV", 1290), NamedValue("1295mV", 1295), NamedValue("1300mV", 1300), + NamedValue("1305mV", 1305), NamedValue("1310mV", 1310), NamedValue("1315mV", 1315), + NamedValue("1320mV", 1320), NamedValue("1325mV", 1325), NamedValue("1330mV", 1330), + NamedValue("1335mV", 1335), NamedValue("1340mV", 1340), NamedValue("1345mV", 1345), + NamedValue("1350mV", 1350), NamedValue("1355mV", 1355), NamedValue("1360mV", 1360), + NamedValue("1365mV", 1365), NamedValue("1370mV", 1370), NamedValue("1375mV", 1375), + NamedValue("1380mV", 1380), NamedValue("1385mV", 1385), NamedValue("1390mV", 1390), + NamedValue("1395mV", 1395), NamedValue("1400mV", 1400), NamedValue("1405mV", 1405), + NamedValue("1410mV", 1410), NamedValue("1415mV", 1415), NamedValue("1420mV", 1420), + NamedValue("1425mV", 1425), NamedValue("1430mV", 1430), NamedValue("1435mV", 1435), + NamedValue("1440mV", 1440), NamedValue("1445mV", 1445), NamedValue("1450mV", 1450), + NamedValue("1455mV", 1455), NamedValue("1460mV", 1460), NamedValue("1465mV", 1465), + NamedValue("1470mV", 1470), NamedValue("1475mV", 1475), NamedValue("1480mV", 1480), + NamedValue("1485mV", 1485), NamedValue("1490mV", 1490), NamedValue("1495mV", 1495), + NamedValue("1500mV", 1500), NamedValue("1505mV", 1505), NamedValue("1510mV", 1510), + NamedValue("1515mV", 1515), NamedValue("1520mV", 1520), NamedValue("1525mV", 1525), }; if (IsMariko()) { - - tsl::elm::CustomDrawer* warningText = new tsl::elm::CustomDrawer([](tsl::gfx::Renderer *renderer, s32 x, s32 y, s32 w, s32 h) { - renderer->drawString("\uE150 Setting GPU Clocks past", false, x + 20, y + 30, 18, tsl::style::color::ColorText); - renderer->drawString("1075MHz without UV, 1152MHz on SLT", false, x + 20, y + 50, 18, tsl::style::color::ColorText); - renderer->drawString("or 1228MHz on HiOPT can cause ", false, x + 20, y + 70, 18, tsl::style::color::ColorText); - renderer->drawString("permanent damage to your Switch!", false, x + 20, y + 90, 18, tsl::style::color::ColorText); - renderer->drawString("Proceed at your own risk!", false, x + 20, y + 110, 18, tsl::style::color::ColorText); - }); - warningText->setBoundaries(0, 0, tsl::cfg::FramebufferWidth, 130); - this->listElement->addItem(warningText); - addConfigButton(KipConfigValue_g_volt_76800, "76.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); addConfigButton(KipConfigValue_g_volt_153600, "153.6MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); addConfigButton(KipConfigValue_g_volt_230400, "230.4MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); @@ -1275,62 +1422,49 @@ protected: addConfigButton(KipConfigValue_g_volt_921600, "921.6MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); addConfigButton(KipConfigValue_g_volt_998400, "998.4MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); addConfigButton(KipConfigValue_g_volt_1075200, "1075.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); - if(this->configList->values[KipConfigValue_marikoGpuUV] >= GPUUVLevel_SLT) - addConfigButton(KipConfigValue_g_volt_1152000, "1152.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); - if(this->configList->values[KipConfigValue_marikoGpuUV] >= GPUUVLevel_HiOPT) { - addConfigButton(KipConfigValue_g_volt_1228800, "1228.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); - addConfigButton(KipConfigValue_g_volt_1267200, "1267.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); - addConfigButton(KipConfigValue_g_volt_1305600, "1305.6MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); - addConfigButton(KipConfigValue_g_volt_1344000, "1344.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); - addConfigButton(KipConfigValue_g_volt_1382400, "1382.4MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); - addConfigButton(KipConfigValue_g_volt_1420800, "1420.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); - addConfigButton(KipConfigValue_g_volt_1459200, "1459.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); - addConfigButton(KipConfigValue_g_volt_1497600, "1497.6MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); - addConfigButton(KipConfigValue_g_volt_1536000, "1536.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); - } + addConfigButton(KipConfigValue_g_volt_1152000, "1152.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); + addConfigButton(KipConfigValue_g_volt_1228800, "1228.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); + addConfigButton(KipConfigValue_g_volt_1267200, "1267.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); + addConfigButton(KipConfigValue_g_volt_1305600, "1305.6MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); + addConfigButton(KipConfigValue_g_volt_1344000, "1344.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_1382400, "1382.4MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_1420800, "1420.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_1459200, "1459.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_1497600, "1497.6MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_1536000, "1536.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_1574400, "1574.4MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_1612800, "1612.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_1651200, "1651.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_1689600, "1689.6MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_1728000, "1728.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_1766400, "1766.4MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_1804800, "1804.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); } else { - - tsl::elm::CustomDrawer* warningText = new tsl::elm::CustomDrawer([](tsl::gfx::Renderer *renderer, s32 x, s32 y, s32 w, s32 h) { - renderer->drawString("\uE150 Setting GPU Clocks past", false, x + 20, y + 30, 18, tsl::style::color::ColorText); - renderer->drawString("921MHz without UV and 960MHz on", false, x + 20, y + 50, 18, tsl::style::color::ColorText); - renderer->drawString("SLT or HiOPT can cause ", false, x + 20, y + 70, 18, tsl::style::color::ColorText); - renderer->drawString("permanent damage to your Switch!", false, x + 20, y + 90, 18, tsl::style::color::ColorText); - renderer->drawString("Proceed at your own risk!", false, x + 20, y + 110, 18, tsl::style::color::ColorText); - }); - warningText->setBoundaries(0, 0, tsl::cfg::FramebufferWidth, 130); - this->listElement->addItem(warningText); - addConfigButton(KipConfigValue_g_volt_e_76800, "76.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); - addConfigButton(KipConfigValue_g_volt_e_115200, "115.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); addConfigButton(KipConfigValue_g_volt_e_153600, "153.6MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); - addConfigButton(KipConfigValue_g_volt_e_192000, "192.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); addConfigButton(KipConfigValue_g_volt_e_230400, "230.4MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); - addConfigButton(KipConfigValue_g_volt_e_268800, "268.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); addConfigButton(KipConfigValue_g_volt_e_307200, "307.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); - addConfigButton(KipConfigValue_g_volt_e_345600, "345.6MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); addConfigButton(KipConfigValue_g_volt_e_384000, "384.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); - addConfigButton(KipConfigValue_g_volt_e_422400, "422.4MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); addConfigButton(KipConfigValue_g_volt_e_460800, "460.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); - addConfigButton(KipConfigValue_g_volt_e_499200, "499.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); addConfigButton(KipConfigValue_g_volt_e_537600, "537.6MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); - addConfigButton(KipConfigValue_g_volt_e_576000, "576.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); addConfigButton(KipConfigValue_g_volt_e_614400, "614.4MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); - addConfigButton(KipConfigValue_g_volt_e_652800, "652.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); addConfigButton(KipConfigValue_g_volt_e_691200, "691.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); - addConfigButton(KipConfigValue_g_volt_e_729600, "729.6MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); addConfigButton(KipConfigValue_g_volt_e_768000, "768.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); - addConfigButton(KipConfigValue_g_volt_e_806400, "806.4MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); addConfigButton(KipConfigValue_g_volt_e_844800, "844.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); - addConfigButton(KipConfigValue_g_volt_e_883200, "883.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); addConfigButton(KipConfigValue_g_volt_e_921600, "921.6MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); - if(this->configList->values[KipConfigValue_eristaGpuUV] >= GPUUVLevel_SLT) - addConfigButton(KipConfigValue_g_volt_e_960000, "960.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); - if(this->configList->values[KipConfigValue_eristaGpuUV] >= GPUUVLevel_HiOPT) { - addConfigButton(KipConfigValue_g_volt_e_998400, "998.4MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); - addConfigButton(KipConfigValue_g_volt_e_1036800, "1036.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts_noAuto, false); - addConfigButton(KipConfigValue_g_volt_e_1075200, "1075.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts_noAuto, false); - } + addConfigButton(KipConfigValue_g_volt_e_998400, "998.4MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false); + addConfigButton(KipConfigValue_g_volt_e_1075200, "1075.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_e_1152000, "1152.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); + addConfigButton(KipConfigValue_g_volt_e_1228800, "1228.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); + addConfigButton(KipConfigValue_g_volt_e_1267200, "1267.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); + addConfigButton(KipConfigValue_g_volt_e_1305600, "1305.6MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false); + addConfigButton(KipConfigValue_g_volt_e_1344000, "1344.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_e_1382400, "1382.4MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_e_1420800, "1420.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_e_1459200, "1459.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_e_1497600, "1497.6MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); + addConfigButton(KipConfigValue_g_volt_e_1536000, "1536.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts_noAuto, false); } } }; diff --git a/Source/sys-clk/sysmodule/src/clock_manager.cpp b/Source/sys-clk/sysmodule/src/clock_manager.cpp index 434a039e..113f4ed6 100644 --- a/Source/sys-clk/sysmodule/src/clock_manager.cpp +++ b/Source/sys-clk/sysmodule/src/clock_manager.cpp @@ -40,6 +40,7 @@ #include #include + #define HOSPPC_HAS_BOOST (hosversionAtLeast(7,0,0)) bool isGpuGovernorEnabled = false; bool isCpuGovernorEnabled = false; @@ -1125,11 +1126,11 @@ void ClockManager::SetKipData() { CUST_WRITE_FIELD_BATCH(&table, commonGpuVoltOffset, this->config->GetConfigValue(KipConfigValue_commonGpuVoltOffset)); CUST_WRITE_FIELD_BATCH(&table, gpuSpeedo, this->config->GetConfigValue(KipConfigValue_gpuSpeedo)); - for (int i = 0; i < 24; i++) { + for (int i = 0; i < 31; i++) { table.marikoGpuVoltArray[i] = this->config->GetConfigValue((SysClkConfigValue)(KipConfigValue_g_volt_76800 + i)); } - for (int i = 0; i < 27; i++) { + for (int i = 0; i < 24; i++) { table.eristaGpuVoltArray[i] = this->config->GetConfigValue((SysClkConfigValue)(KipConfigValue_g_volt_e_76800 + i)); } @@ -1297,12 +1298,12 @@ void ClockManager::GetKipData() { configValues.values[KipConfigValue_commonGpuVoltOffset] = cust_get_common_gpu_offset(&table); configValues.values[KipConfigValue_gpuSpeedo] = Board::getSpeedo(HorizonOCSpeedo_GPU); // cust_get_gpu_speedo(&table); - for (int i = 0; i < 24; i++) { + for (int i = 0; i < 31; i++) { configValues.values[KipConfigValue_g_volt_76800 + i] = cust_get_mariko_gpu_volt(&table, i); initialConfigValues[KipConfigValue_g_volt_76800 + i] = cust_get_mariko_gpu_volt(&table, i); } - for (int i = 0; i < 27; i++) { + for (int i = 0; i < 24; i++) { configValues.values[KipConfigValue_g_volt_e_76800 + i] = cust_get_erista_gpu_volt(&table, i); initialConfigValues[KipConfigValue_g_volt_e_76800 + i] = cust_get_erista_gpu_volt(&table, i); } diff --git a/Source/sys-clk/sysmodule/src/kip.h b/Source/sys-clk/sysmodule/src/kip.h index 818b4937..20ba23ac 100644 --- a/Source/sys-clk/sysmodule/src/kip.h +++ b/Source/sys-clk/sysmodule/src/kip.h @@ -77,8 +77,8 @@ typedef struct { u32 gpuSpeedo; - u32 eristaGpuVoltArray[27]; - u32 marikoGpuVoltArray[24]; + u32 eristaGpuVoltArray[24]; + u32 marikoGpuVoltArray[31]; u32 t6_tRTW_fine_tune; u32 t7_tWTR_fine_tune; @@ -330,32 +330,30 @@ static inline bool cust_set_mariko_gpu_volt_##freq( \ } 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_ERISTA_GPU_VOLT_HELPER(153600, 1) +DECL_ERISTA_GPU_VOLT_HELPER(230400, 2) +DECL_ERISTA_GPU_VOLT_HELPER(307200, 3) +DECL_ERISTA_GPU_VOLT_HELPER(384000, 4) +DECL_ERISTA_GPU_VOLT_HELPER(460800, 5) +DECL_ERISTA_GPU_VOLT_HELPER(537600, 6) +DECL_ERISTA_GPU_VOLT_HELPER(614400, 7) +DECL_ERISTA_GPU_VOLT_HELPER(691200, 8) +DECL_ERISTA_GPU_VOLT_HELPER(768000, 9) +DECL_ERISTA_GPU_VOLT_HELPER(844800, 10) +DECL_ERISTA_GPU_VOLT_HELPER(921600, 11) +DECL_ERISTA_GPU_VOLT_HELPER(998400, 12) +DECL_ERISTA_GPU_VOLT_HELPER(1075200, 13) +DECL_ERISTA_GPU_VOLT_HELPER(1152000, 14) +DECL_ERISTA_GPU_VOLT_HELPER(1228800, 15) +DECL_ERISTA_GPU_VOLT_HELPER(1267200, 16) +DECL_ERISTA_GPU_VOLT_HELPER(1305600, 17) +DECL_ERISTA_GPU_VOLT_HELPER(1344000, 18) +DECL_ERISTA_GPU_VOLT_HELPER(1382400, 19) +DECL_ERISTA_GPU_VOLT_HELPER(1420800, 20) +DECL_ERISTA_GPU_VOLT_HELPER(1459200, 21) +DECL_ERISTA_GPU_VOLT_HELPER(1497600, 22) +DECL_ERISTA_GPU_VOLT_HELPER(1536000, 23) + DECL_MARIKO_GPU_VOLT_HELPER(76800, 0) DECL_MARIKO_GPU_VOLT_HELPER(153600, 1) @@ -381,6 +379,13 @@ 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) +DECL_MARIKO_GPU_VOLT_HELPER(1574400, 24) +DECL_MARIKO_GPU_VOLT_HELPER(1612800, 25) +DECL_MARIKO_GPU_VOLT_HELPER(1651200, 26) +DECL_MARIKO_GPU_VOLT_HELPER(1689600, 27) +DECL_MARIKO_GPU_VOLT_HELPER(1728000, 28) +DECL_MARIKO_GPU_VOLT_HELPER(1766400, 29) +DECL_MARIKO_GPU_VOLT_HELPER(1804800, 30) #define DECL_ERISTA_GPU_VOLT_GET(freq, idx) \ @@ -396,33 +401,32 @@ static inline u32 cust_get_mariko_gpu_volt_##freq##_val(const char* p) { \ 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_ERISTA_GPU_VOLT_GET(153600, 1) +DECL_ERISTA_GPU_VOLT_GET(230400, 2) +DECL_ERISTA_GPU_VOLT_GET(307200, 3) +DECL_ERISTA_GPU_VOLT_GET(384000, 4) +DECL_ERISTA_GPU_VOLT_GET(460800, 5) +DECL_ERISTA_GPU_VOLT_GET(537600, 6) +DECL_ERISTA_GPU_VOLT_GET(614400, 7) +DECL_ERISTA_GPU_VOLT_GET(691200, 8) +DECL_ERISTA_GPU_VOLT_GET(768000, 9) +DECL_ERISTA_GPU_VOLT_GET(844800, 10) +DECL_ERISTA_GPU_VOLT_GET(921600, 11) +DECL_ERISTA_GPU_VOLT_GET(998400, 12) +DECL_ERISTA_GPU_VOLT_GET(1075200, 13) +DECL_ERISTA_GPU_VOLT_GET(1152000, 14) +DECL_ERISTA_GPU_VOLT_GET(1228800, 15) +DECL_ERISTA_GPU_VOLT_GET(1267200, 16) +DECL_ERISTA_GPU_VOLT_GET(1305600, 17) +DECL_ERISTA_GPU_VOLT_GET(1344000, 18) +DECL_ERISTA_GPU_VOLT_GET(1382400, 19) +DECL_ERISTA_GPU_VOLT_GET(1420800, 20) +DECL_ERISTA_GPU_VOLT_GET(1459200, 21) +DECL_ERISTA_GPU_VOLT_GET(1497600, 22) +DECL_ERISTA_GPU_VOLT_GET(1536000, 23) + DECL_MARIKO_GPU_VOLT_GET(76800, 0) DECL_MARIKO_GPU_VOLT_GET(153600, 1) @@ -447,4 +451,11 @@ 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 +DECL_MARIKO_GPU_VOLT_GET(1536000, 23) +DECL_MARIKO_GPU_VOLT_GET(1574400, 24) +DECL_MARIKO_GPU_VOLT_GET(1612800, 25) +DECL_MARIKO_GPU_VOLT_GET(1651200, 26) +DECL_MARIKO_GPU_VOLT_GET(1689600, 27) +DECL_MARIKO_GPU_VOLT_GET(1728000, 28) +DECL_MARIKO_GPU_VOLT_GET(1766400, 29) +DECL_MARIKO_GPU_VOLT_GET(1804800, 30) \ No newline at end of file diff --git a/dist/atmosphere/kips/hoc.kip b/dist/atmosphere/kips/hoc.kip index 1f74ae4363f0aa3474243aacca72de968d64425f..8eadfe61c993725a58a784a54bfcf644976dd30d 100644 GIT binary patch delta 31946 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 a0$aBVnMPFU@Qum?3L6m-^JxSZ#=zoNi{@_o_ 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