revert erista mrf changes

2026-05-24 21:30:05 +02:00
parent 65927cffce
commit 749fd385ce
18 changed files with 311 additions and 402 deletions
--- a/Source/hoc-clk/common/include/hocclk/config.h
+++ b/Source/hoc-clk/common/include/hocclk/config.h
@@ -82,6 +82,8 @@ typedef enum {

    KipConfigValue_commonEmcMemVolt,
    KipConfigValue_eristaEmcMaxClock,
+    KipConfigValue_eristaEmcMaxClock1,
+    KipConfigValue_eristaEmcMaxClock2,

    KipConfigValue_stepMode,
    KipConfigValue_marikoEmcMaxClock,
@@ -114,6 +116,9 @@ typedef enum {
    KipConfigValue_write_latency_1866,
    KipConfigValue_write_latency_2133,

+    KipConfigValue_mem_burst_read_latency,
+    KipConfigValue_mem_burst_write_latency,
+
    KipConfigValue_eristaCpuUV,
    KipConfigValue_eristaCpuVmin,
    KipConfigValue_eristaCpuMaxVolt,
@@ -138,6 +143,7 @@ typedef enum {
    KipConfigValue_marikoGpuVmax,

    KipConfigValue_commonGpuVoltOffset,
+    KipConfigValue_gpuSpeedo,

    KipConfigValue_g_volt_76800,
    KipConfigValue_g_volt_153600,
@@ -302,7 +308,11 @@ static inline const char* hocclkFormatConfigValue(HocClkConfigValue val, bool pr
        case KipConfigValue_commonEmcMemVolt:
            return pretty ? "Common EMC/MEM Voltage" : "common_emc_mem_volt";
        case KipConfigValue_eristaEmcMaxClock:
-            return pretty ? "Erista EMC Max Clock" : "erista_emc_max_clock2";
+            return pretty ? "Erista EMC Max Clock 1" : "erista_emc_max_clock";
+        case KipConfigValue_eristaEmcMaxClock1:
+            return pretty ? "Erista EMC Max Clock 2" : "erista_emc_max_clock1";
+        case KipConfigValue_eristaEmcMaxClock2:
+            return pretty ? "Erista EMC Max Clock 3" : "erista_emc_max_clock2";
        case KipConfigValue_stepMode:
            return pretty ? "Step Mode:" : "step_mode";
        case KipConfigValue_marikoEmcMaxClock:
@@ -359,6 +369,11 @@ static inline const char* hocclkFormatConfigValue(HocClkConfigValue val, bool pr
        case KipConfigValue_write_latency_2133:
            return pretty ? "2133 Write Latency" : "write_latency_2133";

+        case KipConfigValue_mem_burst_read_latency:
+            return pretty ? "Memory Burst Read Latency" : "mem_burst_read_latency";
+        case KipConfigValue_mem_burst_write_latency:
+            return pretty ? "Memory Burst Write Latency" : "mem_burst_write_latency";
+
        // CPU – Erista
        case KipConfigValue_eristaCpuUV:
            return pretty ? "Erista CPU Undervolt" : "erista_cpu_uv";
@@ -409,6 +424,8 @@ static inline const char* hocclkFormatConfigValue(HocClkConfigValue val, bool pr

        case KipConfigValue_commonGpuVoltOffset:
            return pretty ? "Common GPU Voltage Offset" : "common_gpu_volt_offset";
+        case KipConfigValue_gpuSpeedo:
+            return pretty ? "GPU Speedo" : "gpu_speedo";

        // Mariko GPU voltages (24)
        case KipConfigValue_g_volt_76800: return pretty ? "Mariko GPU Volt 76 MHz" : "g_volt_76800";
@@ -561,6 +578,8 @@ static inline uint64_t hocclkValidConfigValue(HocClkConfigValue val, uint64_t in
        case KipConfigValue_hpMode:
        case KipConfigValue_commonEmcMemVolt:
        case KipConfigValue_eristaEmcMaxClock:
+        case KipConfigValue_eristaEmcMaxClock1:
+        case KipConfigValue_eristaEmcMaxClock2:
        case KipConfigValue_stepMode:
        case KipConfigValue_marikoEmcMaxClock:
        case KipConfigValue_marikoEmcVddqVolt:
@@ -586,6 +605,8 @@ static inline uint64_t hocclkValidConfigValue(HocClkConfigValue val, uint64_t in
        case KipConfigValue_write_latency_1600:
        case KipConfigValue_write_latency_1866:
        case KipConfigValue_write_latency_2133:
+        case KipConfigValue_mem_burst_read_latency:
+        case KipConfigValue_mem_burst_write_latency:
        case KipConfigValue_eristaCpuUV:
        case KipConfigValue_eristaCpuMaxVolt:
        case KipConfigValue_marikoCpuUVLow:
@@ -604,6 +625,7 @@ static inline uint64_t hocclkValidConfigValue(HocClkConfigValue val, uint64_t in
        case KipConfigValue_marikoGpuBootVolt:
        case KipConfigValue_marikoGpuVmax:
        case KipConfigValue_commonGpuVoltOffset:
+        case KipConfigValue_gpuSpeedo:
        case KipConfigValue_g_volt_76800:
        case KipConfigValue_g_volt_153600:
        case KipConfigValue_g_volt_230400:
--- a/Source/hoc-clk/overlay/src/ui/gui/config_info_strings.cpp
+++ b/Source/hoc-clk/overlay/src/ui/gui/config_info_strings.cpp
@@ -98,8 +98,8 @@ std::vector<std::string> ConfigInfoStrings(HocClkConfigValue val, bool isMariko,
                "- Washed: Washed out colors.",
                "- Basic: Real natural profile.",
                "- Natural: Not actually natural.. Extra saturation.",
-                "- Vivid: Saturated.",
-                "Default: Do not override"
+                "- Vivid: Saturated.",      
+                "Default: Do not override"  
            };

        case HocClkConfigValue_CpuGovernorMinimumFreq:
@@ -227,7 +227,7 @@ std::vector<std::string> ConfigInfoStrings(HocClkConfigValue val, bool isMariko,
                "Default: 600 mV"
            };

-        case KipConfigValue_stepMode:
+        case KipConfigValue_stepMode:         
            return {
                "The step that RAM clocks take.",
                "Options (with examples):",
@@ -250,6 +250,8 @@ std::vector<std::string> ConfigInfoStrings(HocClkConfigValue val, bool isMariko,
            };

        case KipConfigValue_eristaEmcMaxClock:
+        case KipConfigValue_eristaEmcMaxClock1:
+        case KipConfigValue_eristaEmcMaxClock2:
            return {
                "The RAM frequency used in the particular slot. Higher frequencies may cause instability, so increase this gradually and test for stability.",
                "Default: Disabled (1600 MHz)"
@@ -361,6 +363,19 @@ std::vector<std::string> ConfigInfoStrings(HocClkConfigValue val, bool isMariko,
                "These properties apply for both write and read latencies, and you can mix-and-match the brackets if necessary",
                "Default: -"
            };
+
+        case KipConfigValue_mem_burst_read_latency:
+            return {
+                "The read latency for the ram",
+                "Default: 1600 RL"
+            };
+
+        case KipConfigValue_mem_burst_write_latency:
+            return {
+                "The write latency for the ram",
+                "Default: 1600 WL"
+            };
+
        case KipConfigValue_marikoCpuUVLow:
            return {
                "The CPU UV level used before tBreak",
--- a/Source/hoc-clk/overlay/src/ui/gui/misc_gui.cpp
+++ b/Source/hoc-clk/overlay/src/ui/gui/misc_gui.cpp
@@ -61,6 +61,7 @@ class RamLatenciesSubmenuGui;
 class CpuSubmenuGui;
 class GpuSubmenuGui;
 class GpuCustomTableSubmenuGui;
+class RamTableEditor;
 class ExperimentalSettingsSubMenuGui;

 MiscGui::MiscGui()
@@ -687,7 +688,7 @@ protected:
            false

        );
-
+        
        addConfigButton(
            HocClkConfigValue_PollingIntervalMs,
            "Polling Interval",
@@ -1012,7 +1013,7 @@ protected:


        this->listElement->addItem(new tsl::elm::CategoryHeader("RAM Settings"));
-
+        
        addMappedConfigTrackbar(KipConfigValue_emcDvbShift, "DVB Shift",
            {0xFFFFFFFCu, 0xFFFFFFFDu, 0xFFFFFFFEu, 0xFFFFFFFFu, 0u, 1u, 2u, 3u, 4u, 5u, 6u, 7u, 8u},
            {"-4", "-3", "-2", "-1", " 0", "1", "2", "3", "4", "5", "6", "7", "8"});
@@ -1054,7 +1055,7 @@ protected:
                true
            );
        }
-
+        
        addConfigToggle(KipConfigValue_hpMode, "HP Mode", true);

        std::map<uint32_t, std::string> emc_voltage_label = {
@@ -1105,51 +1106,20 @@ protected:
            addConfigButton(KipConfigValue_stepMode, "Step Mode", ValueRange(0, 0, 2, "", 0), "Step Mode", &thresholdsDisabled, {}, stepMode, false, true);
        }

-        std::vector<NamedValue> emcMaxClock = { };
-        RamDisplayUnit unit = (RamDisplayUnit)this->configList->values[HocClkConfigValue_RamDisplayUnit];
-
        if (IsErista()) {
-            emcMaxClock = {
-                NamedValue("Disabled", 1600000),
-                NamedValue("1633 MHz", 1633000),
-                NamedValue("1666 MHz", 1666000),
-                NamedValue("1700 MHz", 1700000),
-                NamedValue("1733 MHz", 1733000),
-                NamedValue("1766 MHz", 1766000),
-                NamedValue("1800 MHz", 1800000),
-                NamedValue("1833 MHz", 1833000),
-                NamedValue("1862 MHz", 1862400, "JEDEC."),
-                NamedValue("1881 MHz", 1881600),
-                NamedValue("1900 MHz", 1900800),
-                NamedValue("1920 MHz", 1920000),
-                NamedValue("1939 MHz", 1939200),
-                NamedValue("1958 MHz", 1958400),
-                NamedValue("1977 MHz", 1977600),
-                NamedValue("1996 MHz", 1996800, "JEDEC."),
-                NamedValue("2016 MHz", 2016000),
-                NamedValue("2035 MHz", 2035200),
-                NamedValue("2054 MHz", 2054400),
-                NamedValue("2073 MHz", 2073600),
-                NamedValue("2092 MHz", 2092800),
-                NamedValue("2112 MHz", 2112000),
-                NamedValue("2131 MHz", 2131200, "JEDEC."),
-                NamedValue("2150 MHz", 2150400),
-                NamedValue("2169 MHz", 2169600),
-                NamedValue("2188 MHz", 2188800),
-                NamedValue("2208 MHz", 2208000),
-                NamedValue("2227 MHz", 2227200),
-                NamedValue("2246 MHz", 2246400),
-                NamedValue("2265 MHz", 2265600),
-                NamedValue("2284 MHz", 2284800),
-                NamedValue("2304 MHz", 2304000),
-                NamedValue("2323 MHz", 2323200),
-                NamedValue("2342 MHz", 2342400),
-                NamedValue("2361 MHz", 2361600),
-                NamedValue("2380 MHz", 2380800),
-                NamedValue("2400 MHz", 2400000, "JEDEC."),
-            };
+            tsl::elm::ListItem* freqSubmenu = new tsl::elm::ListItem("RAM Frequency Editor");
+            freqSubmenu->setClickListener([](u64 keys) {
+                if (keys & HidNpadButton_A) {
+                    tsl::changeTo<RamTableEditor>();
+                    return true;
+                }
+                return false;
+            });
+            freqSubmenu->setValue(R_ARROW);
+            this->listElement->addItem(freqSubmenu);
        } else {
-            emcMaxClock = {
+            RamDisplayUnit unit = (RamDisplayUnit)this->configList->values[HocClkConfigValue_RamDisplayUnit];
+            std::vector<NamedValue> marikoMaxEmcClock = {
                NamedValue("1600 MHz", 1600000),
                NamedValue("1633 MHz", 1633000),
                NamedValue("1666 MHz", 1666000),
@@ -1203,20 +1173,19 @@ protected:
                NamedValue("3233 MHz", 3233000, "High speedo needed!"),
                NamedValue("3266 MHz", 3266000, "High speedo needed!"),
                NamedValue("3300 MHz", 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),
            };
-        }
-
-        for (auto& nv : emcMaxClock) {
-            if (nv.name != "Disabled") {
+            for (auto& nv : marikoMaxEmcClock)
                nv.name = formatMemClockKhzLabel(nv.value, unit);
-            }
+
+            addConfigButton(KipConfigValue_marikoEmcMaxClock, "Ram Max Clock", ValueRange(0, 1, 1, "", 1), "Ram Max Clock", &thresholdsDisabled, {}, marikoMaxEmcClock, false, true);
        }

-        if (IsMariko()) {
-            addConfigButton(KipConfigValue_marikoEmcMaxClock, "Ram Max Clock", ValueRange(0, 1, 1, "", 1), "Ram Max Clock", &thresholdsDisabled, {}, emcMaxClock, false, true);
-        } else {
-            addConfigButton(KipConfigValue_eristaEmcMaxClock, "Ram Max Clock", ValueRange(0, 1, 1, "", 1), "Ram Max Clock", &thresholdsDisabled, {}, emcMaxClock, false, true);
-        }

        tsl::elm::ListItem* latenciesSubmenu = new tsl::elm::ListItem("RAM Latency Editor");
        latenciesSubmenu->setClickListener([](u64 keys) {
@@ -1355,7 +1324,7 @@ public:
 protected:

    void normalizeLatencies(const HocClkConfigValue keysArr[4]) {
-        uint32_t maxClock = IsMariko() ? (uint32_t)this->configList->values[KipConfigValue_marikoEmcMaxClock] : (uint32_t)this->configList->values[KipConfigValue_eristaEmcMaxClock];
+        uint32_t maxClock = (uint32_t)this->configList->values[KipConfigValue_marikoEmcMaxClock];
        uint32_t vals[4];

        for (int i = 0; i < 4; i++) {
@@ -1390,37 +1359,35 @@ protected:

    void listUI() override {
        ValueThresholds thresholdsDisabled(0, 0);
+
+        if (IsErista()) {
+            std::vector<NamedValue> rlLabels = { NamedValue("1333 RL", 28), NamedValue("1600 RL", 32), NamedValue("1866 RL", 36), NamedValue("2133 RL", 40) };
+            std::vector<NamedValue> wlLabels = { NamedValue("1333 WL", 12), NamedValue("1600 WL", 14), NamedValue("1866 WL", 16), NamedValue("2133 WL", 18) };
+
+            addConfigButton(KipConfigValue_mem_burst_read_latency,  "Read Latency",  ValueRange(0, 6, 1, "", 0), "Read Latency",  &thresholdsDisabled, {}, rlLabels, false, true);
+            addConfigButton(KipConfigValue_mem_burst_write_latency, "Write Latency", ValueRange(0, 6, 1, "", 0), "Write Latency", &thresholdsDisabled, {}, wlLabels, false, true);
+            return;
+        }
+
        Result rc = hocclkIpcGetConfigValues(this->configList);
        if (R_FAILED(rc)) [[unlikely]] {
            FatalGui::openWithResultCode("hocclkIpcGetConfigValues", rc);
            return;
        }

-        uint32_t maxClock = IsMariko() ? (uint32_t)this->configList->values[KipConfigValue_marikoEmcMaxClock] : (uint32_t)this->configList->values[KipConfigValue_eristaEmcMaxClock];
+        uint32_t maxClock = (uint32_t)this->configList->values[KipConfigValue_marikoEmcMaxClock];
        RamDisplayUnit unit = (RamDisplayUnit)this->configList->values[HocClkConfigValue_RamDisplayUnit];

-        static std::vector<uint32_t> kFreqOptions = { };
-        if (IsMariko()) {
-            kFreqOptions = {
-                1633000, 1666000, 1700000, 1733000, 1766000, 1800000,
-                1833000, 1866000, 1900000, 1933000, 1966000, 1996800, 2000000,
-                2033000, 2066000, 2100000, 2133000, 2166000, 2200000, 2233000,
-                2266000, 2300000, 2333000, 2366000, 2400000, 2433000, 2466000,
-                2500000, 2533000, 2566000, 2600000, 2633000, 2666000, 2700000,
-                2733000, 2766000, 2800000, 2833000, 2866000, 2900000, 2933000,
-                2966000, 3000000, 3033000, 3066000, 3100000, 3133000, 3166000,
-                3200000, 3233000, 3266000, 3300000,
-            };
-        } else {
-            kFreqOptions = {
-                1633000, 1666000, 1700000, 1733000, 1800000,
-                1833000, 1862400, 1881600, 1900800, 1920000, 1939200,
-                1958400, 1977600, 1996800, 2016000, 2035200, 2054400,
-                2073600, 2092800, 2112000, 2131200, 2150400, 2169600,
-                2188800, 2208000, 2227200, 2246400, 2265600, 2284800,
-                2304000, 2323200, 2342400, 2361600, 2380800, 2400000,
-            };
-        }
+        static const std::vector<uint32_t> kFreqOptions = {
+            1633000, 1666000, 1700000, 1733000, 1766000, 1800000,
+            1833000, 1866000, 1900000, 1933000, 1966000, 1996800, 2000000,
+            2033000, 2066000, 2100000, 2133000, 2166000, 2200000, 2233000,
+            2266000, 2300000, 2333000, 2366000, 2400000, 2433000, 2466000,
+            2500000, 2533000, 2566000, 2600000, 2633000, 2666000, 2700000,
+            2733000, 2766000, 2800000, 2833000, 2866000, 2900000, 2933000,
+            2966000, 3000000, 3033000, 3066000, 3100000, 3133000, 3166000,
+            3200000, 3233000, 3266000, 3300000,
+        };

        static const HocClkConfigValue kLatencyRKeys[4] = {
            KipConfigValue_read_latency_1333,
@@ -1480,7 +1447,7 @@ protected:
                for (int i = 0; i < 4; i++)
                    vals[i] = (uint32_t)this->configList->values[keysArr[i]];

-                uint32_t maxClock = IsMariko() ? (uint32_t)this->configList->values[KipConfigValue_marikoEmcMaxClock] : (uint32_t)this->configList->values[KipConfigValue_eristaEmcMaxClock];
+                uint32_t maxClock = (uint32_t)this->configList->values[KipConfigValue_marikoEmcMaxClock];
                RamDisplayUnit unit = (RamDisplayUnit)this->configList->values[HocClkConfigValue_RamDisplayUnit];

                auto resolveVal = [maxClock](uint32_t v) -> uint32_t {
@@ -1688,7 +1655,7 @@ protected:
                true
            );

-
+            
            std::vector<NamedValue> maxClkOptions = {
                NamedValue("1963 MHz", 1963500),
                NamedValue("2091 MHz", 2091000),
@@ -1810,6 +1777,78 @@ protected:
    }
 };

+class RamTableEditor : public MiscGui {
+public:
+    RamTableEditor() { }
+
+protected:
+    void listUI() override {
+        Result rc = hocclkIpcGetConfigValues(this->configList);
+        if (R_FAILED(rc)) [[unlikely]] { FatalGui::openWithResultCode("hocclkIpcGetConfigValues", rc); return; }
+        this->listElement->addItem(new tsl::elm::CategoryHeader("RAM Frequency Editor"));
+
+        ValueThresholds thresholdsDisabled(0, 0);
+        // 1600000, 1331200, 1065600, 800000, 665600, 408000, 204000
+        RamDisplayUnit unit = (RamDisplayUnit)this->configList->values[HocClkConfigValue_RamDisplayUnit];
+
+        this->listElement->addItem(new tsl::elm::ListItem(formatMemClockKhzLabel(665600, unit)));
+        this->listElement->addItem(new tsl::elm::ListItem(formatMemClockKhzLabel(800000, unit)));
+        this->listElement->addItem(new tsl::elm::ListItem(formatMemClockKhzLabel(1065600, unit)));
+        this->listElement->addItem(new tsl::elm::ListItem(formatMemClockKhzLabel(1331200, unit)));
+        this->listElement->addItem(new tsl::elm::ListItem(formatMemClockKhzLabel(1600000, unit)));
+
+        ValueThresholds eristaRamThresholds(2208000, 2304000);
+
+        std::vector<NamedValue> eristaMaxEmcClock = {
+            NamedValue("Disabled", 1600000),
+            NamedValue("1633 MHz", 1633000),
+            NamedValue("1666 MHz", 1666000),
+            NamedValue("1700 MHz", 1700000),
+            NamedValue("1733 MHz", 1733000),
+            NamedValue("1766 MHz", 1766000),
+            NamedValue("1800 MHz", 1800000),
+            NamedValue("1833 MHz", 1833000),
+            NamedValue("1862 MHz", 1862400, "JEDEC."),
+            NamedValue("1881 MHz", 1881600),
+            NamedValue("1900 MHz", 1900800),
+            NamedValue("1920 MHz", 1920000),
+            NamedValue("1939 MHz", 1939200),
+            NamedValue("1958 MHz", 1958400),
+            NamedValue("1977 MHz", 1977600),
+            NamedValue("1996 MHz", 1996800, "JEDEC."),
+            NamedValue("2016 MHz", 2016000),
+            NamedValue("2035 MHz", 2035200),
+            NamedValue("2054 MHz", 2054400),
+            NamedValue("2073 MHz", 2073600),
+            NamedValue("2092 MHz", 2092800),
+            NamedValue("2112 MHz", 2112000),
+            NamedValue("2131 MHz", 2131200, "JEDEC."),
+            NamedValue("2150 MHz", 2150400),
+            NamedValue("2169 MHz", 2169600),
+            NamedValue("2188 MHz", 2188800),
+            NamedValue("2208 MHz", 2208000),
+            NamedValue("2227 MHz", 2227200),
+            NamedValue("2246 MHz", 2246400),
+            NamedValue("2265 MHz", 2265600),
+            NamedValue("2284 MHz", 2284800),
+            NamedValue("2304 MHz", 2304000),
+            NamedValue("2323 MHz", 2323200),
+            NamedValue("2342 MHz", 2342400),
+            NamedValue("2361 MHz", 2361600),
+            NamedValue("2380 MHz", 2380800),
+            NamedValue("2400 MHz", 2400000, "JEDEC."),
+        };
+
+        for (auto& nv : eristaMaxEmcClock)
+            if (nv.name != "Disabled")
+                nv.name = formatMemClockKhzLabel(nv.value, unit);
+
+        addConfigButtonS(KipConfigValue_eristaEmcMaxClock, "", ValueRange(0, 1, 1, "", 1), "", &eristaRamThresholds, {}, eristaMaxEmcClock, false, A_BTN, true);
+        addConfigButtonS(KipConfigValue_eristaEmcMaxClock1, "", ValueRange(0, 1, 1, "", 1), "", &eristaRamThresholds, {}, eristaMaxEmcClock, false, A_BTN, true);
+        addConfigButtonS(KipConfigValue_eristaEmcMaxClock2, "", ValueRange(0, 1, 1, "", 1), "", &eristaRamThresholds, {}, eristaMaxEmcClock, false, A_BTN, true);
+    };
+};
+
 class GpuSubmenuGui : public MiscGui {
 public:
    GpuSubmenuGui() { }
@@ -2293,6 +2332,8 @@ void MiscGui::refresh() {
        constexpr HocClkConfigValue emcKeys[] = {
            KipConfigValue_marikoEmcMaxClock,
            KipConfigValue_eristaEmcMaxClock,
+            KipConfigValue_eristaEmcMaxClock1,
+            KipConfigValue_eristaEmcMaxClock2,
        };
        for (auto key : emcKeys) {
            auto it = this->configNamedValues.find(key);
--- a/Source/hoc-clk/sysmodule/src/file/kip.cpp
+++ b/Source/hoc-clk/sysmodule/src/file/kip.cpp
@@ -71,6 +71,8 @@ namespace kip {

        CUST_WRITE_FIELD_BATCH(&table, commonEmcMemVolt, config::GetConfigValue(KipConfigValue_commonEmcMemVolt));
        CUST_WRITE_FIELD_BATCH(&table, eristaEmcMaxClock, config::GetConfigValue(KipConfigValue_eristaEmcMaxClock));
+        CUST_WRITE_FIELD_BATCH(&table, eristaEmcMaxClock1, config::GetConfigValue(KipConfigValue_eristaEmcMaxClock1));
+        CUST_WRITE_FIELD_BATCH(&table, eristaEmcMaxClock2, config::GetConfigValue(KipConfigValue_eristaEmcMaxClock2));
        CUST_WRITE_FIELD_BATCH(&table, marikoEmcMaxClock, config::GetConfigValue(KipConfigValue_marikoEmcMaxClock));
        CUST_WRITE_FIELD_BATCH(&table, marikoEmcVddqVolt, config::GetConfigValue(KipConfigValue_marikoEmcVddqVolt));
        CUST_WRITE_FIELD_BATCH(&table, emcDvbShift, config::GetConfigValue(KipConfigValue_emcDvbShift));
@@ -101,6 +103,8 @@ namespace kip {
        CUST_WRITE_FIELD_BATCH(&table, writeLatency1866, config::GetConfigValue(KipConfigValue_write_latency_1866));
        CUST_WRITE_FIELD_BATCH(&table, writeLatency2133, config::GetConfigValue(KipConfigValue_write_latency_2133));

+        CUST_WRITE_FIELD_BATCH(&table, mem_burst_read_latency, config::GetConfigValue(KipConfigValue_mem_burst_read_latency));
+        CUST_WRITE_FIELD_BATCH(&table, mem_burst_write_latency, config::GetConfigValue(KipConfigValue_mem_burst_write_latency));
        CUST_WRITE_FIELD_BATCH(&table, eristaCpuUV, config::GetConfigValue(KipConfigValue_eristaCpuUV));
        CUST_WRITE_FIELD_BATCH(&table, eristaCpuVmin, config::GetConfigValue(KipConfigValue_eristaCpuVmin));
        CUST_WRITE_FIELD_BATCH(&table, eristaCpuMaxVolt, config::GetConfigValue(KipConfigValue_eristaCpuMaxVolt));
@@ -126,6 +130,7 @@ namespace kip {
        CUST_WRITE_FIELD_BATCH(&table, marikoGpuVmax, config::GetConfigValue(KipConfigValue_marikoGpuVmax));

        CUST_WRITE_FIELD_BATCH(&table, commonGpuVoltOffset, config::GetConfigValue(KipConfigValue_commonGpuVoltOffset));
+        CUST_WRITE_FIELD_BATCH(&table, gpuSpeedo, config::GetConfigValue(KipConfigValue_gpuSpeedo));

        for (int i = 0; i < 24; i++) {
            table.marikoGpuVoltArray[i] = config::GetConfigValue((HocClkConfigValue)(KipConfigValue_g_volt_76800 + i));
@@ -226,6 +231,8 @@ namespace kip {

        configValues.values[KipConfigValue_commonEmcMemVolt] = cust_get_common_emc_volt(&table);
        configValues.values[KipConfigValue_eristaEmcMaxClock] = cust_get_erista_emc_max(&table);
+        configValues.values[KipConfigValue_eristaEmcMaxClock1] = cust_get_erista_emc_max1(&table);
+        configValues.values[KipConfigValue_eristaEmcMaxClock2] = cust_get_erista_emc_max2(&table);
        configValues.values[KipConfigValue_marikoEmcMaxClock] = cust_get_mariko_emc_max(&table);
        configValues.values[KipConfigValue_marikoEmcVddqVolt] = cust_get_mariko_emc_vddq(&table);
        configValues.values[KipConfigValue_emcDvbShift] = cust_get_emc_dvb_shift(&table);
@@ -256,6 +263,9 @@ namespace kip {
        configValues.values[KipConfigValue_write_latency_1866] = cust_get_write_latency_1866(&table);
        configValues.values[KipConfigValue_write_latency_2133] = cust_get_write_latency_2133(&table);

+        configValues.values[KipConfigValue_mem_burst_read_latency] = cust_get_burst_read_lat(&table);
+        configValues.values[KipConfigValue_mem_burst_write_latency] = cust_get_burst_write_lat(&table);
+
        configValues.values[KipConfigValue_eristaCpuUV] = cust_get_erista_cpu_uv(&table);
        configValues.values[KipConfigValue_eristaCpuVmin] = cust_get_eristaCpuVmin(&table);
        configValues.values[KipConfigValue_eristaCpuMaxVolt] = cust_get_erista_cpu_max_volt(&table);
@@ -278,6 +288,7 @@ namespace kip {
        configValues.values[KipConfigValue_marikoGpuBootVolt] = cust_get_mariko_gpu_boot_volt(&table);
        configValues.values[KipConfigValue_marikoGpuVmax] = cust_get_mariko_gpu_vmax(&table);
        configValues.values[KipConfigValue_commonGpuVoltOffset] = cust_get_common_gpu_offset(&table);
+        configValues.values[KipConfigValue_gpuSpeedo] = board::GetFuseData()->gpuSpeedo; // cust_get_gpu_speedo(&table);

        for (int i = 0; i < 24; i++) {
            configValues.values[KipConfigValue_g_volt_76800 + i] = cust_get_mariko_gpu_volt(&table, i);
--- a/Source/hoc-clk/sysmodule/src/file/kip.hpp
+++ b/Source/hoc-clk/sysmodule/src/file/kip.hpp
@@ -36,6 +36,8 @@ namespace kip {
        u32 hpMode;
        u32 commonEmcMemVolt;
        u32 eristaEmcMaxClock;
+        u32 eristaEmcMaxClock1;
+        u32 eristaEmcMaxClock2;
        u32 stepMode;
        u32 marikoEmcMaxClock;
        u32 marikoEmcVddqVolt;
@@ -62,6 +64,9 @@ namespace kip {
        u32 readLatency1333, readLatency1600, readLatency1866, readLatency2133;
        u32 writeLatency1333, writeLatency1600, writeLatency1866, writeLatency2133;

+        u32 mem_burst_read_latency;
+        u32 mem_burst_write_latency;
+
        u32 eristaCpuUV;
        u32 eristaCpuVmin;
        u32 eristaCpuMaxVolt;
@@ -88,6 +93,8 @@ namespace kip {

        u32 commonGpuVoltOffset;

+        u32 gpuSpeedo;
+
        u32 eristaGpuVoltArray[27];
        u32 marikoGpuVoltArray[24];

@@ -202,6 +209,8 @@ namespace kip {

    static inline bool cust_set_common_emc_volt(const char* p, u32 v) { CUST_WRITE_FIELD(p, commonEmcMemVolt, v); }
    static inline bool cust_set_erista_emc_max(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaEmcMaxClock, v); }
+    static inline bool cust_set_erista_emc_max1(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaEmcMaxClock1, v); }
+    static inline bool cust_set_erista_emc_max2(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaEmcMaxClock2, v); }
    static inline bool cust_set_step_mode(const char* p, u32 v) { CUST_WRITE_FIELD(p, stepMode, v); }
    static inline bool cust_set_mariko_emc_max(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoEmcMaxClock, v); }
    static inline bool cust_set_mariko_emc_vddq(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoEmcVddqVolt, v); }
@@ -232,6 +241,9 @@ namespace kip {
    static inline bool cust_set_write_latency_1866(const char* p, u32 v) { CUST_WRITE_FIELD(p, writeLatency1866, v); }
    static inline bool cust_set_write_latency_2133(const char* p, u32 v) { CUST_WRITE_FIELD(p, writeLatency2133, v); }

+    static inline bool cust_set_burst_read_lat(const char* p, u32 v) { CUST_WRITE_FIELD(p, mem_burst_read_latency, v); }
+    static inline bool cust_set_burst_write_lat(const char* p, u32 v) { CUST_WRITE_FIELD(p, mem_burst_write_latency, v); }
+
    static inline bool cust_set_erista_cpu_uv(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaCpuUV, v); }
    static inline bool cust_set_eristaCpuVmin(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaCpuVmin, v); }
    static inline bool cust_set_erista_cpu_max_volt(const char* p, u32 v) { CUST_WRITE_FIELD(p, eristaCpuMaxVolt, v); }
@@ -252,6 +264,7 @@ namespace kip {
    static inline bool cust_set_mariko_gpu_boot_volt(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoGpuBootVolt, v); }
    static inline bool cust_set_mariko_gpu_vmax(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoGpuVmax, v); }
    static inline bool cust_set_common_gpu_offset(const char* p, u32 v) { CUST_WRITE_FIELD(p, commonGpuVoltOffset, v); }
+    static inline bool cust_set_gpu_speedo(const char* p, u32 v) { CUST_WRITE_FIELD(p, gpuSpeedo, v); }
    static inline bool cust_set_marikoCpuMaxClock(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoCpuMaxClock, v); }
    static inline bool cust_set_marikoSocVmax(const char* p, u32 v) { CUST_WRITE_FIELD(p, marikoSocVmax, v); }

@@ -286,6 +299,8 @@ namespace kip {

    static inline u32 cust_get_common_emc_volt(const CustomizeTable* t) { return CUST_GET_FIELD(t, commonEmcMemVolt); }
    static inline u32 cust_get_erista_emc_max(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaEmcMaxClock); }
+    static inline u32 cust_get_erista_emc_max1(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaEmcMaxClock1); }
+    static inline u32 cust_get_erista_emc_max2(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaEmcMaxClock2); }
    static inline u32 cust_get_step_mode(const CustomizeTable* t) { return CUST_GET_FIELD(t, stepMode); }
    static inline u32 cust_get_mariko_emc_max(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoEmcMaxClock); }
    static inline u32 cust_get_mariko_emc_vddq(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoEmcVddqVolt); }
@@ -316,6 +331,9 @@ namespace kip {
    static inline u32 cust_get_write_latency_1866(const CustomizeTable* t) { return CUST_GET_FIELD(t, writeLatency1866); }
    static inline u32 cust_get_write_latency_2133(const CustomizeTable* t) { return CUST_GET_FIELD(t, writeLatency2133); }

+    static inline u32 cust_get_burst_read_lat(const CustomizeTable* t) { return CUST_GET_FIELD(t, mem_burst_read_latency); }
+    static inline u32 cust_get_burst_write_lat(const CustomizeTable* t) { return CUST_GET_FIELD(t, mem_burst_write_latency); }
+
    static inline u32 cust_get_erista_cpu_uv(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaCpuUV); }
    static inline u32 cust_get_eristaCpuVmin(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaCpuVmin); }
    static inline u32 cust_get_erista_cpu_max_volt(const CustomizeTable* t) { return CUST_GET_FIELD(t, eristaCpuMaxVolt); }
@@ -337,6 +355,7 @@ namespace kip {
    static inline u32 cust_get_mariko_gpu_boot_volt(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoGpuBootVolt); }
    static inline u32 cust_get_mariko_gpu_vmax(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoGpuVmax); }
    static inline u32 cust_get_common_gpu_offset(const CustomizeTable* t) { return CUST_GET_FIELD(t, commonGpuVoltOffset); }
+    static inline u32 cust_get_gpu_speedo(const CustomizeTable* t) { return CUST_GET_FIELD(t, gpuSpeedo); }
    static inline u32 cust_get_marikoCpuMaxClock(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoCpuMaxClock); }
    static inline u32 cust_get_marikoSocVmax(const CustomizeTable* t) { return CUST_GET_FIELD(t, marikoSocVmax); }