From aa95f526b877a1477943d2f842aa0c40965ed556 Mon Sep 17 00:00:00 2001 From: Lightos1 <124387232+Lightos1@users.noreply.github.com> Date: Sat, 18 Apr 2026 12:19:55 +0200 Subject: [PATCH] add mrf latency stuff to configs --- Source/hoc-clk/common/include/hocclk/config.h | 35 +++++++++++++++++++ Source/hoc-clk/sysmodule/src/kip.cpp | 28 +++++++++++++-- Source/hoc-clk/sysmodule/src/kip.hpp | 31 +++++++++++++++- 3 files changed, 91 insertions(+), 3 deletions(-) diff --git a/Source/hoc-clk/common/include/hocclk/config.h b/Source/hoc-clk/common/include/hocclk/config.h index 8b3700d6..5b8020f1 100644 --- a/Source/hoc-clk/common/include/hocclk/config.h +++ b/Source/hoc-clk/common/include/hocclk/config.h @@ -79,6 +79,8 @@ typedef enum { KipConfigValue_eristaEmcMaxClock, KipConfigValue_eristaEmcMaxClock1, KipConfigValue_eristaEmcMaxClock2, + + KipConfigValue_stepMode, KipConfigValue_marikoEmcMaxClock, KipConfigValue_marikoEmcVddqVolt, KipConfigValue_emcDvbShift, @@ -91,6 +93,17 @@ typedef enum { KipConfigValue_t6_tRTW, KipConfigValue_t7_tWTR, KipConfigValue_t8_tREFI, + + KipConfigValue_read_latency_1333, + KipConfigValue_read_latency_1600, + KipConfigValue_read_latency_1866, + KipConfigValue_read_latency_2133, + + KipConfigValue_write_latency_1333, + KipConfigValue_write_latency_1600, + KipConfigValue_write_latency_1866, + KipConfigValue_write_latency_2133, + KipConfigValue_mem_burst_read_latency, KipConfigValue_mem_burst_write_latency, @@ -283,6 +296,8 @@ static inline const char* hocclkFormatConfigValue(HocClkConfigValue val, bool pr 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: return pretty ? "Mariko EMC Max Clock" : "mariko_emc_max_clock"; case KipConfigValue_marikoEmcVddqVolt: @@ -307,6 +322,25 @@ static inline const char* hocclkFormatConfigValue(HocClkConfigValue val, bool pr return pretty ? "t7 - tWTR" : "t7_twtr"; case KipConfigValue_t8_tREFI: return pretty ? "t8 - tREFI" : "t8_trefi"; + + case KipConfigValue_read_latency_1333: + return pretty ? "1333 Read Latency" : "read_latency_1333"; + case KipConfigValue_read_latency_1600: + return pretty ? "1600 Read Latency" : "read_latency_1600"; + case KipConfigValue_read_latency_1866: + return pretty ? "1866 Read Latency" : "read_latency_1866"; + case KipConfigValue_read_latency_2133: + return pretty ? "2133 Read Latency" : "read_latency_2133"; + + case KipConfigValue_write_latency_1333: + return pretty ? "1333 Write Latency" : "write_latency_1333"; + case KipConfigValue_write_latency_1600: + return pretty ? "1600 Write Latency" : "write_latency_1600"; + case KipConfigValue_write_latency_1866: + return pretty ? "1866 Write Latency" : "write_latency_1866"; + 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: @@ -512,6 +546,7 @@ static inline uint64_t hocclkValidConfigValue(HocClkConfigValue val, uint64_t in case KipConfigValue_eristaEmcMaxClock: case KipConfigValue_eristaEmcMaxClock1: case KipConfigValue_eristaEmcMaxClock2: + case KipConfigValue_stepMode: case KipConfigValue_marikoEmcMaxClock: case KipConfigValue_marikoEmcVddqVolt: case KipConfigValue_emcDvbShift: diff --git a/Source/hoc-clk/sysmodule/src/kip.cpp b/Source/hoc-clk/sysmodule/src/kip.cpp index b1faabc2..c11c06c6 100644 --- a/Source/hoc-clk/sysmodule/src/kip.cpp +++ b/Source/hoc-clk/sysmodule/src/kip.cpp @@ -21,7 +21,7 @@ namespace kip { bool kipAvailable = false; - + void SetKipData() { // TODO: figure out if this REALLY causes issues (i doubt it) @@ -70,6 +70,18 @@ namespace kip { CUST_WRITE_FIELD_BATCH(&table, t6_tRTW, config::GetConfigValue(KipConfigValue_t6_tRTW)); CUST_WRITE_FIELD_BATCH(&table, t7_tWTR, config::GetConfigValue(KipConfigValue_t7_tWTR)); CUST_WRITE_FIELD_BATCH(&table, t8_tREFI, config::GetConfigValue(KipConfigValue_t8_tREFI)); + CUST_WRITE_FIELD_BATCH(&table, stepMode, config::GetConfigValue(KipConfigValue_stepMode)); + + CUST_WRITE_FIELD_BATCH(&table, readLatency1333, config::GetConfigValue(KipConfigValue_read_latency_1333)); + CUST_WRITE_FIELD_BATCH(&table, readLatency1600, config::GetConfigValue(KipConfigValue_read_latency_1600)); + CUST_WRITE_FIELD_BATCH(&table, readLatency1866, config::GetConfigValue(KipConfigValue_read_latency_1866)); + CUST_WRITE_FIELD_BATCH(&table, readLatency2133, config::GetConfigValue(KipConfigValue_read_latency_2133)); + + CUST_WRITE_FIELD_BATCH(&table, writeLatency1333, config::GetConfigValue(KipConfigValue_write_latency_1333)); + CUST_WRITE_FIELD_BATCH(&table, writeLatency1600, config::GetConfigValue(KipConfigValue_write_latency_1600)); + 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)); @@ -166,7 +178,7 @@ namespace kip { configValues.values[HocClkConfigValue_IsFirstLoad] = (u64)false; notification::writeNotification("Horizon OC has been installed"); } - + configValues.values[KipCrc32] = (u64)crc32::checksum_file("sdmc:/atmosphere/kips/hoc.kip"); // write checksum // configValues.values[KipConfigValue_mtcConf] = cust_get_mtc_conf(&table); configValues.values[KipConfigValue_hpMode] = cust_get_hp_mode(&table); @@ -187,6 +199,18 @@ namespace kip { configValues.values[KipConfigValue_t6_tRTW] = cust_get_tRTW(&table); configValues.values[KipConfigValue_t7_tWTR] = cust_get_tWTR(&table); configValues.values[KipConfigValue_t8_tREFI] = cust_get_tREFI(&table); + configValues.values[KipConfigValue_stepMode] = cust_get_step_mode(&table); + + configValues.values[KipConfigValue_read_latency_1333] = cust_get_read_latency_1333(&table); + configValues.values[KipConfigValue_read_latency_1600] = cust_get_read_latency_1600(&table); + configValues.values[KipConfigValue_read_latency_1866] = cust_get_read_latency_1866(&table); + configValues.values[KipConfigValue_read_latency_2133] = cust_get_read_latency_2133(&table); + + configValues.values[KipConfigValue_write_latency_1333] = cust_get_write_latency_1333(&table); + configValues.values[KipConfigValue_write_latency_1600] = cust_get_write_latency_1600(&table); + 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); diff --git a/Source/hoc-clk/sysmodule/src/kip.hpp b/Source/hoc-clk/sysmodule/src/kip.hpp index 26729fdc..8cb27f17 100644 --- a/Source/hoc-clk/sysmodule/src/kip.hpp +++ b/Source/hoc-clk/sysmodule/src/kip.hpp @@ -30,7 +30,7 @@ namespace kip { extern bool kipAvailable; - + typedef struct { u8 cust[4]; u32 custRev; @@ -40,6 +40,7 @@ namespace kip { u32 eristaEmcMaxClock; u32 eristaEmcMaxClock1; u32 eristaEmcMaxClock2; + u32 stepMode; u32 marikoEmcMaxClock; u32 marikoEmcVddqVolt; u32 emcDvbShift; @@ -53,6 +54,10 @@ namespace kip { u32 t7_tWTR; u32 t8_tREFI; + /* These latencies are arrays in loader, but it's easier to handle it this way in the configurator. */ + u32 readLatency1333, readLatency1600, readLatency1866, readLatency2133; + u32 writeLatency1333, writeLatency1600, writeLatency1866, writeLatency2133; + u32 mem_burst_read_latency; u32 mem_burst_write_latency; @@ -201,6 +206,7 @@ namespace kip { 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); } static inline bool cust_set_emc_dvb_shift(const char* p, u32 v) { CUST_WRITE_FIELD(p, emcDvbShift, v); } @@ -215,6 +221,17 @@ namespace kip { static inline bool cust_set_tREFI(const char* p, u32 v) { CUST_WRITE_FIELD(p, t8_tREFI, v); } static inline bool cust_set_tRTW_fine_tune(const char* p, u32 v) { CUST_WRITE_FIELD(p, t6_tRTW_fine_tune, v); } static inline bool cust_set_tWTR_fine_tune(const char* p, u32 v) { CUST_WRITE_FIELD(p, t7_tWTR_fine_tune, v); } + + static inline bool cust_set_read_latency_1333(const char* p, u32 v) { CUST_WRITE_FIELD(p, readLatency1333, v); } + static inline bool cust_set_read_latency_1600(const char* p, u32 v) { CUST_WRITE_FIELD(p, readLatency1600, v); } + static inline bool cust_set_read_latency_1866(const char* p, u32 v) { CUST_WRITE_FIELD(p, readLatency1866, v); } + static inline bool cust_set_read_latency_2133(const char* p, u32 v) { CUST_WRITE_FIELD(p, readLatency2133, v); } + + static inline bool cust_set_write_latency_1333(const char* p, u32 v) { CUST_WRITE_FIELD(p, writeLatency1333, v); } + static inline bool cust_set_write_latency_1600(const char* p, u32 v) { CUST_WRITE_FIELD(p, writeLatency1600, v); } + 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); } @@ -272,6 +289,7 @@ namespace kip { 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); } static inline u32 cust_get_emc_dvb_shift(const CustomizeTable* t) { return CUST_GET_FIELD(t, emcDvbShift); } @@ -286,6 +304,17 @@ namespace kip { static inline u32 cust_get_tREFI(const CustomizeTable* t) { return CUST_GET_FIELD(t, t8_tREFI); } static inline u32 cust_get_tRTW_fine_tune(const CustomizeTable* t) { return CUST_GET_FIELD(t, t6_tRTW_fine_tune); } static inline u32 cust_get_tWTR_fine_tune(const CustomizeTable* t) { return CUST_GET_FIELD(t, t7_tWTR_fine_tune); } + + static inline u32 cust_get_read_latency_1333(const CustomizeTable* t) { return CUST_GET_FIELD(t, readLatency1333); } + static inline u32 cust_get_read_latency_1600(const CustomizeTable* t) { return CUST_GET_FIELD(t, readLatency1600); } + static inline u32 cust_get_read_latency_1866(const CustomizeTable* t) { return CUST_GET_FIELD(t, readLatency1866); } + static inline u32 cust_get_read_latency_2133(const CustomizeTable* t) { return CUST_GET_FIELD(t, readLatency2133); } + + static inline u32 cust_get_write_latency_1333(const CustomizeTable* t) { return CUST_GET_FIELD(t, writeLatency1333); } + static inline u32 cust_get_write_latency_1600(const CustomizeTable* t) { return CUST_GET_FIELD(t, writeLatency1600); } + 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); }