sysclk: refactor misc gui

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

@@ -1,7 +1,4 @@
 /*
- * Copyright (C) Switch-OC-Suite
- *
- * Copyright (c) 2023 hanai3Bi
  *
  * Copyright (c) Souldbminer and Horizon OC Contributors
  *
@@ -27,6 +24,13 @@
 #include <cstring>
 #include <vector>
 
+class RamSubmenuGui;
+class RamTimingsSubmenuGui;
+class RamLatenciesSubmenuGui;
+class CpuSubmenuGui;
+class GpuSubmenuGui;
+class GpuCustomTableSubmenuGui;
+
 MiscGui::MiscGui()
 {
     this->configList = new SysClkConfigValueList {};
@@ -71,9 +75,19 @@ void MiscGui::addConfigButton(SysClkConfigValue configVal,
 
     uint64_t currentValue = this->configList->values[configVal];
     char valueText[32];
-    if (currentValue == 0) {
+    if (currentValue == 0 && showDefaultValue) {
         snprintf(valueText, sizeof(valueText), "%s", VALUE_DEFAULT_TEXT);
     } else {
+        bool foundNamedValue = false;
+        for (const auto& namedValue : namedValues) {
+            if (currentValue == namedValue.value) {
+                snprintf(valueText, sizeof(valueText), "%s", namedValue.name.c_str());
+                foundNamedValue = true;
+                break;
+            }
+        }
+        
+        if (!foundNamedValue) {
             uint64_t displayValue = currentValue / range.divisor;
             if (!range.suffix.empty()) {
                 snprintf(valueText, sizeof(valueText), "%lu %s", displayValue, range.suffix.c_str());
@@ -81,6 +95,7 @@ void MiscGui::addConfigButton(SysClkConfigValue configVal,
                 snprintf(valueText, sizeof(valueText), "%lu", displayValue);
             }
         }
+    }
     listItem->setValue(valueText);
 
     ValueThresholds thresholdsCopy = (thresholds ? *thresholds : ValueThresholds{});
@@ -242,8 +257,7 @@ void MiscGui::listUI()
         {2295000000, "Absolute Max"},
     };
     
-    // ========== MISC CATEGORY (TOP) ==========
+    this->listElement->addItem(new tsl::elm::CategoryHeader("Settings"));
-    this->listElement->addItem(new tsl::elm::CategoryHeader("Misc Settings"));
     
     addConfigToggle(HocClkConfigValue_UncappedClocks, nullptr);
     addConfigToggle(HocClkConfigValue_OverwriteBoostMode, nullptr);
@@ -275,7 +289,7 @@ void MiscGui::listUI()
         ValueRange(4000, 8000, 100, "mW", 1),
         "Power",
         &tdpThresholdsLite,
-        labels_pwr_r
+        labels_pwr_l
     );
 
     ValueThresholds throttleThresholds(70, 80);
@@ -328,81 +342,81 @@ void MiscGui::listUI()
     });
     this->listElement->addItem(saveBtn);
 
-    this->listElement->addItem(new tsl::elm::CategoryHeader("RAM/Memory Settings"));
+    tsl::elm::ListItem* ramSubmenu = new tsl::elm::ListItem("RAM Settings");
+    ramSubmenu->setClickListener([](u64 keys) {
+        if (keys & HidNpadButton_A) {
+            tsl::changeTo<RamSubmenuGui>();
+            return true;
+        }
+        return false;
+    });
+    this->listElement->addItem(ramSubmenu);
+
+    tsl::elm::ListItem* cpuSubmenu = new tsl::elm::ListItem("CPU Settings");
+    cpuSubmenu->setClickListener([](u64 keys) {
+        if (keys & HidNpadButton_A) {
+            tsl::changeTo<CpuSubmenuGui>();
+            return true;
+        }
+        return false;
+    });
+    this->listElement->addItem(cpuSubmenu);
+
+    tsl::elm::ListItem* gpuSubmenu = new tsl::elm::ListItem("GPU Settings");
+    gpuSubmenu->setClickListener([](u64 keys) {
+        if (keys & HidNpadButton_A) {
+            tsl::changeTo<GpuSubmenuGui>();
+            return true;
+        }
+        return false;
+    });
+    this->listElement->addItem(gpuSubmenu);
+
+    this->listElement->addItem(new tsl::elm::CategoryHeader("Experimental"));
+    
+    std::vector<NamedValue> 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),
+    };
+    
+    ValueThresholds chargerThresholds(2048, 2560);
     
     addConfigButton(
-        KipConfigValue_emcDvbShift,
+        HorizonOCConfigValue_BatteryChargeCurrent,
-        "DVB Shift",
+        "Charge Current Override",
-        ValueRange(0, 10, 1, "", 1),
+        ValueRange(0, 0, 1, "", 0),
-        "DVB Shift",
+        "Charge Current Override",
-        &thresholdsDisabled,
+        &chargerThresholds,
-        {},
         {},
+        chargerCurrents,
         false
     );
 
-    std::map<uint32_t, std::string> emc_freq_label_e = {
+    addConfigToggle(HocClkConfigValue_HandheldGovernor, nullptr);
-        {133120000, "Handheld"},
+}
-        {160000000, "Docked & Safe Max"},
-        {213100000, "JEDEC Max"},
-        {236000000, "Absolute Max"},
-    };
 
-    std::map<uint32_t, std::string> emc_freq_label_m = {
-        {133120000, "Handheld"},
-        {160000000, "Docked"},
-        {186600000, "Safe Max (3733MT/s)"},
-        {213300000, "Safe Max (4266MT/s)"},
-        {320000000, "Unsafe Max"},
-        {350000000, "Absolute Max"},
-    };
 
-    // Uncomment these if you want max memory clock options
+class RamSubmenuGui : public MiscGui {
-    // if(IsMariko()) {
+public:
-    //     addFreqButton(HocClkConfigValue_MarikoMaxMemClock, nullptr, SysClkModule_MEM, emc_freq_label_m);
+    RamSubmenuGui() { }
-    // } else {
-    //     addFreqButton(HocClkConfigValue_EristaMaxMemClock, nullptr, SysClkModule_MEM, emc_freq_label_e);
-    // }
     
-    // std::vector<NamedValue> autoAdjOptions = {
+protected:
-    //     NamedValue("AUTO_ADJ", 0),
+    void listUI() override {
-    //     NamedValue("AUTO_ADJ_BL", 1)
+        ValueThresholds thresholdsDisabled(0, 0);
-    // };
+        std::vector<NamedValue> noNamedValues = {};
         
-    // addConfigButton(
+        this->listElement->addItem(new tsl::elm::CategoryHeader("RAM Settings"));
-    //     KipConfigValue_mtcConf,
-    //     "MTC Configuration",
-    //     ValueRange(0, 1, 1, "", 1),
-    //     "MTC Configuration",
-    //     &thresholdsDisabled,
-    //     {},
-    //     autoAdjOptions,
-    //     false
-    // );
         
         addConfigToggle(KipConfigValue_hpMode, "HP Mode");
         
-    std::map<uint32_t, std::string> emc_voltage_label = {
-        {1100000, "Default (Mariko)"},
-        {1125000, "Default (Erista)"},
-        {1175000, "Rating"},
-        {1212500, "Safe Max (Mariko)"},
-        {1237500, "Safe Max (Erista)"},
-        {1250000, "Unsafe Max"},
-    };
-
-    ValueThresholds vdd2Thresholds(1212500, 1250000);
-    addConfigButton(
-        KipConfigValue_commonEmcMemVolt,
-        "EMC VDD2 Voltage",
-        ValueRange(912500, 1350000, 12500, "mV", 1000, 1),
-        "Voltage",
-        &vdd2Thresholds,
-        emc_voltage_label,
-        noNamedValues,
-        false
-    );
-
         std::vector<NamedValue> marikoMaxEmcClock = {
             NamedValue("1600MHz", 1600000),
             NamedValue("1633MHz", 1633000),
@@ -516,6 +530,30 @@ void MiscGui::listUI()
                 marikoMaxEmcClock,
                 false
             );
+        }
+        
+        std::map<uint32_t, std::string> emc_voltage_label = {
+            {1100000, "Default (Mariko)"},
+            {1125000, "Default (Erista)"},
+            {1175000, "Rating"},
+            {1212500, "Safe Max (Mariko)"},
+            {1237500, "Safe Max (Erista)"},
+            {1250000, "Unsafe Max"},
+        };
+
+        ValueThresholds vdd2Thresholds(1212500, 1250000);
+        addConfigButton(
+            KipConfigValue_commonEmcMemVolt,
+            "EMC VDD2 Voltage",
+            ValueRange(912500, 1350000, 12500, "mV", 1000, 1),
+            "Voltage",
+            &vdd2Thresholds,
+            emc_voltage_label,
+            noNamedValues,
+            false
+        );
+        
+        if(IsMariko()) {
             addConfigButton(
                 KipConfigValue_marikoEmcVddqVolt,
                 "EMC VDDQ Voltage",
@@ -528,7 +566,49 @@ void MiscGui::listUI()
             );
         }
         
-    // Memory Timings
+        addConfigButton(
+            KipConfigValue_emcDvbShift,
+            "DVB Shift",
+            ValueRange(0, 10, 1, "", 1),
+            "DVB Shift",
+            &thresholdsDisabled,
+            {},
+            {},
+            false
+        );
+        
+        tsl::elm::ListItem* timingsSubmenu = new tsl::elm::ListItem("Memory Timings");
+        timingsSubmenu->setClickListener([](u64 keys) {
+            if (keys & HidNpadButton_A) {
+                tsl::changeTo<RamTimingsSubmenuGui>();
+                return true;
+            }
+            return false;
+        });
+        this->listElement->addItem(timingsSubmenu);
+        
+        tsl::elm::ListItem* latenciesSubmenu = new tsl::elm::ListItem("Memory Latencies");
+        latenciesSubmenu->setClickListener([](u64 keys) {
+            if (keys & HidNpadButton_A) {
+                tsl::changeTo<RamLatenciesSubmenuGui>();
+                return true;
+            }
+            return false;
+        });
+        this->listElement->addItem(latenciesSubmenu);
+    }
+};
+
+class RamTimingsSubmenuGui : public MiscGui {
+public:
+    RamTimingsSubmenuGui() { }
+    
+protected:
+    void listUI() override {
+        ValueThresholds thresholdsDisabled(0, 0);
+        
+        this->listElement->addItem(new tsl::elm::CategoryHeader("Memory Timings"));
+        
         addConfigButton(KipConfigValue_t1_tRCD, "t1 tRCD", ValueRange(0, 8, 1, "", 1), "tRCD", &thresholdsDisabled, {}, {}, false);
         addConfigButton(KipConfigValue_t2_tRP, "t2 tRP", ValueRange(0, 8, 1, "", 1), "tRP", &thresholdsDisabled, {}, {}, false);
         addConfigButton(KipConfigValue_t3_tRAS, "t3 tRAS", ValueRange(0, 10, 1, "", 1), "tRAS", &thresholdsDisabled, {}, {}, false);
@@ -537,6 +617,18 @@ void MiscGui::listUI()
         addConfigButton(KipConfigValue_t6_tRTW, "t6 tRTW", ValueRange(0, 10, 1, "", 1), "tRTW", &thresholdsDisabled, {}, {}, false);
         addConfigButton(KipConfigValue_t7_tWTR, "t7 tWTR", ValueRange(0, 10, 1, "", 1), "tWTR", &thresholdsDisabled, {}, {}, false);
         addConfigButton(KipConfigValue_t8_tREFI, "t8 tREFI", ValueRange(0, 6, 1, "", 1), "tREFI", &thresholdsDisabled, {}, {}, false);
+    }
+};
+
+class RamLatenciesSubmenuGui : public MiscGui {
+public:
+    RamLatenciesSubmenuGui() { }
+    
+protected:
+    void listUI() override {
+        ValueThresholds thresholdsDisabled(0, 0);
+        
+        this->listElement->addItem(new tsl::elm::CategoryHeader("Memory Latencies"));
         
         std::vector<NamedValue> rlLabels = {
             NamedValue("1600BL", 0),
@@ -571,13 +663,19 @@ void MiscGui::listUI()
             wlLabels,
             false
         );
+    }
+};
 
+class CpuSubmenuGui : public MiscGui {
+public:
+    CpuSubmenuGui() { }
     
+protected:
+    void listUI() override {
+        ValueThresholds thresholdsDisabled(0, 0);
         
         this->listElement->addItem(new tsl::elm::CategoryHeader("CPU Settings"));
 
-    ValueThresholds mCpuVoltThresholds(1160, 1180);
-
         if(IsErista()) {
             addConfigButton(
                 KipConfigValue_eristaCpuUV,
@@ -589,16 +687,7 @@ void MiscGui::listUI()
                 {},
                 true
             );
-        addConfigButton(
+            addConfigToggle(KipConfigValue_eristaCpuUnlock, "CPU Unlock");
-            KipConfigValue_eristaCpuMaxVolt,
-            "CPU Max Voltage",
-            ValueRange(1120, 1235, 5, "mV", 1),
-            "CPU Max Voltage",
-            &thresholdsDisabled,
-            {},
-            {},
-            false
-        );
             addConfigButton(
                 KipConfigValue_eristaCpuVmin,
                 "CPU VMIN",
@@ -609,7 +698,16 @@ void MiscGui::listUI()
                 {},
                 false
             );
-        addConfigToggle(KipConfigValue_eristaCpuUnlock, "CPU Unlock");
+            addConfigButton(
+                KipConfigValue_eristaCpuMaxVolt,
+                "CPU Max Voltage",
+                ValueRange(1120, 1235, 5, "mV", 1),
+                "CPU Max Voltage",
+                &thresholdsDisabled,
+                {},
+                {},
+                false
+            );
         } else {
             std::vector<NamedValue> marikoTableConf = {
                 NamedValue("Auto", 0),
@@ -649,16 +747,6 @@ void MiscGui::listUI()
                 {},
                 false
             );
-        addConfigButton(
-            KipConfigValue_marikoCpuMaxVolt,
-            "CPU Max Voltage",
-            ValueRange(1000, 1235, 5, "mV", 1),
-            "CPU Max Voltage",
-            &mCpuVoltThresholds,
-            {},
-            {},
-            false
-        );
             
             std::vector<NamedValue> maxClkOptions = {
                 NamedValue("1963MHz", 1963000),
@@ -672,7 +760,7 @@ void MiscGui::listUI()
                 KipConfigValue_marikoCpuMaxClock,
                 "CPU Max Clock",
                 ValueRange(0, 0, 1, "", 1),
-            "CPU Max Voltage",
+                "CPU Max Clock",
                 &thresholdsDisabled,
                 {},
                 maxClkOptions,
@@ -700,51 +788,39 @@ void MiscGui::listUI()
                 {},
                 false
             );
+            
+            ValueThresholds mCpuVoltThresholds(1160, 1180);
+            addConfigButton(
+                KipConfigValue_marikoCpuMaxVolt,
+                "CPU Max Voltage",
+                ValueRange(1000, 1235, 5, "mV", 1),
+                "CPU Max Voltage",
+                &mCpuVoltThresholds,
+                {},
+                {},
+                false
+            );
         }
+    }
+};
 
+class GpuSubmenuGui : public MiscGui {
+public:
+    GpuSubmenuGui() { }
+    
+protected:
+    void listUI() override {
+        ValueThresholds thresholdsDisabled(0, 0);
+        std::vector<NamedValue> noNamedValues = {};
         
-    // ========== GPU CATEGORY ==========
         this->listElement->addItem(new tsl::elm::CategoryHeader("GPU Settings"));
 
-    std::map<uint32_t, std::string> gpu_freq_label_e = {
-        {76800000, "Boost Mode"},
-        {307200000, "Handheld"},
-        {384000000, "Handheld"},
-        {460800000, "Handheld Safe Max"},
-        {768000000, "Docked"},
-        {844000000, "Safe Max"},
-        {998400000, "Unsafe Max"},
-        {1075200000, "Absolute Max"},
-    };
-
-    std::map<uint32_t, std::string> gpu_freq_label_m = {
-        {76800000, "Boost Mode"},
-        {307200000, "Handheld"},
-        {384000000, "Handheld"},
-        {460800000, "Handheld"},
-        {614400000, "Handheld Safe Max"},
-        {768000000, "Docked"},
-        {1075200000, "Safe Max"},
-        {1305600000, "Unsafe Max"},
-        {1536000000, "Absolute Max"},
-    };
-
-    // Uncomment these if you want max GPU clock options
-    // if(IsMariko()) {
-    //     addFreqButton(HocClkConfigValue_MarikoMaxGpuClock, nullptr, SysClkModule_GPU, gpu_freq_label_m);
-    // } else {
-    //     addFreqButton(HocClkConfigValue_EristaMaxGpuClock, nullptr, SysClkModule_GPU, gpu_freq_label_e);
-    // }
-
         std::vector<NamedValue> gpuUvConf = {
             NamedValue("No UV", 0),
             NamedValue("SLT Table", 1),
             NamedValue("HiOPT Table", 2),
         };
 
-    ValueThresholds MgpuVmaxThresholds(800, 850);
-    ValueThresholds EgpuVmaxThresholds(950, 975);
-
         if(IsErista()) {
             addConfigButton(
                 KipConfigValue_eristaGpuUV,
@@ -789,6 +865,7 @@ void MiscGui::listUI()
                 false
             );
 
+            ValueThresholds MgpuVmaxThresholds(800, 850);
             addConfigButton(
                 KipConfigValue_marikoGpuVmax,
                 "GPU VMAX",
@@ -812,265 +889,159 @@ void MiscGui::listUI()
             false
         );
         
-    if(IsMariko())
+        tsl::elm::ListItem* customTableSubmenu = new tsl::elm::ListItem("GPU Custom Table");
-        addConfigToggle(KipConfigValue_marikoGpuFullUnlock, "GPU Full Unlock");
+        customTableSubmenu->setClickListener([](u64 keys) {
+            if (keys & HidNpadButton_A) {
+                tsl::changeTo<GpuCustomTableSubmenuGui>();
+                return true;
+            }
+            return false;
+        });
+        this->listElement->addItem(customTableSubmenu);
         
-    // GPU Custom Table
+        addConfigToggle(KipConfigValue_marikoGpuFullUnlock, "GPU Full Unlock");
-    this->listElement->addItem(new tsl::elm::CategoryHeader("GPU Custom Table"));
+        tsl::elm::CustomDrawer* warningText = new tsl::elm::CustomDrawer([](tsl::gfx::Renderer *renderer, s32 x, s32 y, s32 w, s32 h) {
+            renderer->drawString("\uE150 GPU Full Unlock can cause", false, x + 20, y + 30, 18, tsl::style::color::ColorText);
+            renderer->drawString("PERMANANT damage to your Switch!", false, x + 20, y + 50, 18, tsl::style::color::ColorText);
+            renderer->drawString("Only enable if you know what", false, x + 20, y + 80, 16, tsl::style::color::ColorText);
+            renderer->drawString("you're doing. Proceed at your", false, x + 20, y + 100, 16, tsl::style::color::ColorText);
+            renderer->drawString("own risk!", false, x + 20, y + 120, 16, tsl::style::color::ColorText);
+        });
+        warningText->setBoundaries(0, 0, tsl::cfg::FramebufferWidth, 150);
+        this->listElement->addItem(warningText);
+    }
+};
+
+class GpuCustomTableSubmenuGui : public MiscGui {
+public:
+    GpuCustomTableSubmenuGui() { }
+    
+protected:
+    void listUI() override {
+        this->listElement->addItem(new tsl::elm::CategoryHeader("GPU Custom Table (mV)"));
+        
+        ValueThresholds MgpuVmaxThresholds(800, 850);
+        ValueThresholds EgpuVmaxThresholds(950, 975);
         
         std::vector<NamedValue> mGpuVolts = {
             NamedValue("Disabled", 2000),
             NamedValue("Auto", 0),
-        NamedValue("480mV", 480),
+            NamedValue("480mV", 480), NamedValue("485mV", 485), NamedValue("490mV", 490),
-        NamedValue("485mV", 485),
+            NamedValue("495mV", 495), NamedValue("500mV", 500), NamedValue("505mV", 505),
-        NamedValue("490mV", 490),
+            NamedValue("510mV", 510), NamedValue("515mV", 515), NamedValue("520mV", 520),
-        NamedValue("495mV", 495),
+            NamedValue("525mV", 525), NamedValue("530mV", 530), NamedValue("535mV", 535),
-        NamedValue("500mV", 500),
+            NamedValue("540mV", 540), NamedValue("545mV", 545), NamedValue("550mV", 550),
-        NamedValue("505mV", 505),
+            NamedValue("555mV", 555), NamedValue("560mV", 560), NamedValue("565mV", 565),
-        NamedValue("510mV", 510),
+            NamedValue("570mV", 570), NamedValue("575mV", 575), NamedValue("580mV", 580),
-        NamedValue("515mV", 515),
+            NamedValue("585mV", 585), NamedValue("590mV", 590), NamedValue("595mV", 595),
-        NamedValue("520mV", 520),
+            NamedValue("600mV", 600), NamedValue("605mV", 605), NamedValue("610mV", 610),
-        NamedValue("525mV", 525),
+            NamedValue("615mV", 615), NamedValue("620mV", 620), NamedValue("625mV", 625),
-        NamedValue("530mV", 530),
+            NamedValue("630mV", 630), NamedValue("635mV", 635), NamedValue("640mV", 640),
-        NamedValue("535mV", 535),
+            NamedValue("645mV", 645), NamedValue("650mV", 650), NamedValue("655mV", 655),
-        NamedValue("540mV", 540),
+            NamedValue("660mV", 660), NamedValue("665mV", 665), NamedValue("670mV", 670),
-        NamedValue("545mV", 545),
+            NamedValue("675mV", 675), NamedValue("680mV", 680), NamedValue("685mV", 685),
-        NamedValue("550mV", 550),
+            NamedValue("690mV", 690), NamedValue("695mV", 695), NamedValue("700mV", 700),
-        NamedValue("555mV", 555),
+            NamedValue("705mV", 705), NamedValue("710mV", 710), NamedValue("715mV", 715),
-        NamedValue("560mV", 560),
+            NamedValue("720mV", 720), NamedValue("725mV", 725), NamedValue("730mV", 730),
-        NamedValue("565mV", 565),
+            NamedValue("735mV", 735), NamedValue("740mV", 740), NamedValue("745mV", 745),
-        NamedValue("570mV", 570),
+            NamedValue("750mV", 750), NamedValue("755mV", 755), NamedValue("760mV", 760),
-        NamedValue("575mV", 575),
+            NamedValue("765mV", 765), NamedValue("770mV", 770), NamedValue("775mV", 775),
-        NamedValue("580mV", 580),
+            NamedValue("780mV", 780), NamedValue("785mV", 785), NamedValue("790mV", 790),
-        NamedValue("585mV", 585),
+            NamedValue("795mV", 795), NamedValue("800mV", 800), NamedValue("805mV", 805),
-        NamedValue("590mV", 590),
+            NamedValue("810mV", 810), NamedValue("815mV", 815), NamedValue("820mV", 820),
-        NamedValue("595mV", 595),
+            NamedValue("825mV", 825), NamedValue("830mV", 830), NamedValue("835mV", 835),
-        NamedValue("600mV", 600),
+            NamedValue("840mV", 840), NamedValue("845mV", 845), NamedValue("850mV", 850),
-        NamedValue("605mV", 605),
+            NamedValue("855mV", 855), NamedValue("860mV", 860), NamedValue("865mV", 865),
-        NamedValue("610mV", 610),
+            NamedValue("870mV", 870), NamedValue("875mV", 875), NamedValue("880mV", 880),
-        NamedValue("615mV", 615),
+            NamedValue("885mV", 885), NamedValue("890mV", 890), NamedValue("895mV", 895),
-        NamedValue("620mV", 620),
+            NamedValue("900mV", 900), NamedValue("905mV", 905), NamedValue("910mV", 910),
-        NamedValue("625mV", 625),
+            NamedValue("915mV", 915), NamedValue("920mV", 920), NamedValue("925mV", 925),
-        NamedValue("630mV", 630),
+            NamedValue("930mV", 930), NamedValue("935mV", 935), NamedValue("940mV", 940),
-        NamedValue("635mV", 635),
+            NamedValue("945mV", 945), NamedValue("950mV", 950), NamedValue("955mV", 955),
-        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("700mV", 700), NamedValue("705mV", 705), NamedValue("710mV", 710),
-        NamedValue("705mV", 705),
+            NamedValue("715mV", 715), NamedValue("720mV", 720), NamedValue("725mV", 725),
-        NamedValue("710mV", 710),
+            NamedValue("730mV", 730), NamedValue("735mV", 735), NamedValue("740mV", 740),
-        NamedValue("715mV", 715),
+            NamedValue("745mV", 745), NamedValue("750mV", 750), NamedValue("755mV", 755),
-        NamedValue("720mV", 720),
+            NamedValue("760mV", 760), NamedValue("765mV", 765), NamedValue("770mV", 770),
-        NamedValue("725mV", 725),
+            NamedValue("775mV", 775), NamedValue("780mV", 780), NamedValue("785mV", 785),
-        NamedValue("730mV", 730),
+            NamedValue("790mV", 790), NamedValue("795mV", 795), NamedValue("800mV", 800),
-        NamedValue("735mV", 735),
+            NamedValue("805mV", 805), NamedValue("810mV", 810), NamedValue("815mV", 815),
-        NamedValue("740mV", 740),
+            NamedValue("820mV", 820), NamedValue("825mV", 825), NamedValue("830mV", 830),
-        NamedValue("745mV", 745),
+            NamedValue("835mV", 835), NamedValue("840mV", 840), NamedValue("845mV", 845),
-        NamedValue("750mV", 750),
+            NamedValue("850mV", 850), NamedValue("855mV", 855), NamedValue("860mV", 860),
-        NamedValue("755mV", 755),
+            NamedValue("865mV", 865), NamedValue("870mV", 870), NamedValue("875mV", 875),
-        NamedValue("760mV", 760),
+            NamedValue("880mV", 880), NamedValue("885mV", 885), NamedValue("890mV", 890),
-        NamedValue("765mV", 765),
+            NamedValue("895mV", 895), NamedValue("900mV", 900), NamedValue("905mV", 905),
-        NamedValue("770mV", 770),
+            NamedValue("910mV", 910), NamedValue("915mV", 915), NamedValue("920mV", 920),
-        NamedValue("775mV", 775),
+            NamedValue("925mV", 925), NamedValue("930mV", 930), NamedValue("935mV", 935),
-        NamedValue("780mV", 780),
+            NamedValue("940mV", 940), NamedValue("945mV", 945), NamedValue("950mV", 950),
-        NamedValue("785mV", 785),
+            NamedValue("955mV", 955), NamedValue("960mV", 960), NamedValue("965mV", 965),
-        NamedValue("790mV", 790),
+            NamedValue("970mV", 970), NamedValue("975mV", 975), NamedValue("980mV", 980),
-        NamedValue("795mV", 795),
+            NamedValue("985mV", 985), NamedValue("990mV", 990), NamedValue("995mV", 995),
-        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(KipConfigValue_g_volt_76800, "GPU Voltage (76.8MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_76800, "76.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_153600, "GPU Voltage (153.6MHz)", 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, "GPU Voltage (230.4MHz)", 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);
-        addConfigButton(KipConfigValue_g_volt_307200, "GPU Voltage (307.2MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_307200, "307.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_384000, "GPU Voltage (384.0MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_384000, "384.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_460800, "GPU Voltage (460.8MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_460800, "460.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_537600, "GPU Voltage (537.6MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_537600, "537.6MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_614400, "GPU Voltage (614.4MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_614400, "614.4MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_691200, "GPU Voltage (691.2MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_691200, "691.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_768000, "GPU Voltage (768.0MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_768000, "768.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_844800, "GPU Voltage (844.8MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_844800, "844.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_921600, "GPU Voltage (921.6MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_921600, "921.6MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_998400, "GPU Voltage (998.4MHz)", 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, "GPU Voltage (1075.2MHz)", 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);
-        addConfigButton(KipConfigValue_g_volt_1152000, "GPU Voltage (1152.0MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_1152000, "1152.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_1228800, "GPU Voltage (1228.8MHz)", 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, "GPU Voltage (1267.2MHz)", 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, "GPU Voltage (1305.6MHz)", 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, "GPU Voltage (1344.0MHz)", 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, false);
-        addConfigButton(KipConfigValue_g_volt_1382400, "GPU Voltage (1382.4MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_1382400, "1382.4MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_1420800, "GPU Voltage (1420.8MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_1420800, "1420.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_1459200, "GPU Voltage (1459.2MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_1459200, "1459.2MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_1497600, "GPU Voltage (1497.6MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_1497600, "1497.6MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_1536000, "GPU Voltage (1536.0MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_1536000, "1536.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &MgpuVmaxThresholds, {}, mGpuVolts, false);
         } else {
-        addConfigButton(KipConfigValue_g_volt_e_76800, "GPU Voltage (76.8MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_e_76800, "76.8MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_e_115200, "GPU Voltage (115.2MHz)", 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, "GPU Voltage (153.6MHz)", 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, "GPU Voltage (192.0MHz)", 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, "GPU Voltage (230.4MHz)", 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, "GPU Voltage (268.8MHz)", 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, "GPU Voltage (307.2MHz)", 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, "GPU Voltage (345.6MHz)", 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, "GPU Voltage (384.0MHz)", 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, "GPU Voltage (422.4MHz)", 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, "GPU Voltage (460.8MHz)", 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, "GPU Voltage (499.2MHz)", 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, "GPU Voltage (537.6MHz)", 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, "GPU Voltage (576.0MHz)", 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, "GPU Voltage (614.4MHz)", 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, "GPU Voltage (652.8MHz)", 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, "GPU Voltage (691.2MHz)", 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, "GPU Voltage (729.6MHz)", 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, "GPU Voltage (768.0MHz)", 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, "GPU Voltage (806.4MHz)", 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, "GPU Voltage (844.8MHz)", 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, "GPU Voltage (883.2MHz)", 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, "GPU Voltage (921.6MHz)", 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);
-        addConfigButton(KipConfigValue_g_volt_e_960000, "GPU Voltage (960.0MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_e_960000, "960.0MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_e_998400, "GPU Voltage (998.4MHz)", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false);
+            addConfigButton(KipConfigValue_g_volt_e_998400, "998.4MHz", ValueRange(0, 0, 0, "0", 1), "Voltage", &EgpuVmaxThresholds, {}, eGpuVolts, false);
-        addConfigButton(KipConfigValue_g_volt_e_1036800, "GPU Voltage (1036.8MHz)", 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, false);
-        addConfigButton(KipConfigValue_g_volt_e_1075200, "GPU Voltage (1075.2MHz)", 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, false);
         }
-
+    }
-    std::vector<NamedValue> 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),
-    };
-    
-    ValueThresholds chargerThresholds(2048, 2560);
-
-    // ========== EXPERIMENTAL CATEGORY (BOTTOM) ==========
-    this->listElement->addItem(new tsl::elm::CategoryHeader("Experimental"));
-    
-    addConfigButton(
-        HorizonOCConfigValue_BatteryChargeCurrent,
-        "Charge Current Override",
-        ValueRange(0, 0, 1, "", 0),
-        "Charge Current Override",
-        &chargerThresholds,
-        {},
-        chargerCurrents,
-        false
-    );
-
-    addConfigToggle(HocClkConfigValue_HandheldGovernor, nullptr);
-}
 
 
 static std::string getValueDisplayText(uint64_t currentValue, 

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

@@ -17,8 +17,8 @@ public:
     
 protected:
     std::map<SysClkConfigValue, tsl::elm::ListItem*> configButtons;
-    std::map<SysClkConfigValue, ValueRange> configRanges;  // Store ranges for refresh
+    std::map<SysClkConfigValue, ValueRange> configRanges;
-    std::map<SysClkConfigValue, std::vector<NamedValue>> configNamedValues;  // NEW — Store named values for refresh
+    std::map<SysClkConfigValue, std::vector<NamedValue>> configNamedValues;
     SysClkConfigValueList* configList;
     std::map<SysClkConfigValue, tsl::elm::ToggleListItem*> configToggles;
     std::map<SysClkConfigValue, std::tuple<tsl::elm::TrackBar*, tsl::elm::ListItem*, std::vector<uint64_t>>> configTrackbars;

Source/sys-clk/sysmodule/src/clock_manager.cpp

@@ -142,7 +142,7 @@ bool ClockManager::IsAssignableHz(SysClkModule module, std::uint32_t hz)
     case SysClkModule_CPU:
         return hz >= 400000000;
     case SysClkModule_MEM:
-        return hz == 204000000 || hz >= 665600000;
+        return hz >= 665600000;
     default:
         return true;
     }