diff --git a/Source/sys-clk/common/include/sysclk/config.h b/Source/sys-clk/common/include/sysclk/config.h
index 1b4109ce..2f20ab3f 100644
--- a/Source/sys-clk/common/include/sysclk/config.h
+++ b/Source/sys-clk/common/include/sysclk/config.h
@@ -60,6 +60,96 @@ typedef enum {
 
     HocClkConfigValue_EnforceBoardLimit,
 
+    KipConfigValue_MTCConf,
+    KipConfigValue_commonCpuBoostClock,
+    KipConfigValue_commonEmcMemVolt,
+    KipConfigValue_eristaCpuMaxVolt,
+    KipConfigValue_eristaEmcMaxClock,
+    KipConfigValue_marikoCpuMaxVolt,
+    KipConfigValue_marikoEmcMaxClock,
+    KipConfigValue_marikoEmcVddqVolt,
+    KipConfigValue_marikoCpuUV,
+    KipConfigValue_marikoGpuUV,
+    KipConfigValue_eristaCpuUV,
+    KipConfigValue_eristaGpuUV,
+    KipConfigValue_commonGpuVoltOffset,
+    KipConfigValue_marikoEmcDvbShift,
+    KipConfigValue_t1_tRCD,
+    KipConfigValue_t2_tRP,
+    KipConfigValue_t3_tRAS,
+    KipConfigValue_t4_tRRD,
+    KipConfigValue_t5_tRFC,
+    KipConfigValue_t6_tRTW,
+    KipConfigValue_t7_tWTR,
+    KipConfigValue_t8_tREFI,
+
+    KipConfigValue_mem_burst_read_latency,
+    KipConfigValue_mem_burst_write_latency,
+
+    KipConfigValue_marikoCpuHighVmin,
+    KipConfigValue_marikoCpuLowVmin,
+
+    KipConfigValue_eristaGpuVmin,
+    KipConfigValue_marikoGpuVmin,
+    KipConfigValue_marikoGpuVmax,
+
+    KipConfigValue_marikoGpuFullUnlock,
+
+    // Mariko GPU voltages
+    KipConfigValue_g_volt_76800,
+    KipConfigValue_g_volt_153600,
+    KipConfigValue_g_volt_230400,
+    KipConfigValue_g_volt_307200,
+    KipConfigValue_g_volt_384000,
+    KipConfigValue_g_volt_460800,
+    KipConfigValue_g_volt_537600,
+    KipConfigValue_g_volt_614400,
+    KipConfigValue_g_volt_691200,
+    KipConfigValue_g_volt_768000,
+    KipConfigValue_g_volt_844800,
+    KipConfigValue_g_volt_921600,
+    KipConfigValue_g_volt_998400,
+    KipConfigValue_g_volt_1075200,
+    KipConfigValue_g_volt_1152000,
+    KipConfigValue_g_volt_1228800,
+    KipConfigValue_g_volt_1267200,
+    KipConfigValue_g_volt_1305600,
+    KipConfigValue_g_volt_1344000,
+    KipConfigValue_g_volt_1382400,
+    KipConfigValue_g_volt_1420800,
+    KipConfigValue_g_volt_1459200,
+    KipConfigValue_g_volt_1497600,
+    KipConfigValue_g_volt_1536000,
+
+    // Erista GPU voltages
+    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,
+
     SysClkConfigValue_EnumMax,
 } SysClkConfigValue;
 
diff --git a/Source/sys-clk/common/include/sysclk/ipc.h b/Source/sys-clk/common/include/sysclk/ipc.h
index 5cf1ccd9..70b7571b 100644
--- a/Source/sys-clk/common/include/sysclk/ipc.h
+++ b/Source/sys-clk/common/include/sysclk/ipc.h
@@ -49,6 +49,7 @@ enum SysClkIpcCmd
     SysClkIpcCmd_SetConfigValues = 10,
     SysClkIpcCmd_GetFreqList = 11,
     SysClkIpcCmd_SetReverseNXRTMode = 12,
+    HocClkIpcCmd_SetKipData = 13,
 };
 
 
diff --git a/Source/sys-clk/sysmodule/src/clock_manager.cpp b/Source/sys-clk/sysmodule/src/clock_manager.cpp
index 86dd418c..ea664f59 100644
--- a/Source/sys-clk/sysmodule/src/clock_manager.cpp
+++ b/Source/sys-clk/sysmodule/src/clock_manager.cpp
@@ -84,6 +84,7 @@ ClockManager::~ClockManager()
 {
     delete this->config;
     delete this->context;
+    delete this->kip;
 }
 
 SysClkContext ClockManager::GetCurrentContext()
@@ -449,4 +450,217 @@ bool ClockManager::RefreshContext()
 void ClockManager::SetRNXRTMode(ReverseNXMode mode)
 {
     this->rnxSync->SetRTMode(mode);
+}
+
+void ClockManager::SetKipData() {
+    // ClockManager::GetInstance()->SetRNXRTMode(mode);
+    // General KIP values
+    this->kip->setMtcConf(this->config->GetConfigValue(KipConfigValue_MTCConf));
+    this->kip->setCommonCpuBoostClock(this->config->GetConfigValue(KipConfigValue_commonCpuBoostClock));
+    this->kip->setCommonEmcMemVolt(this->config->GetConfigValue(KipConfigValue_commonEmcMemVolt));
+
+    // Erista specific
+    this->kip->setEristaCpuMaxVolt(this->config->GetConfigValue(KipConfigValue_eristaCpuMaxVolt));
+    this->kip->setEristaEmcMaxClock(this->config->GetConfigValue(KipConfigValue_eristaEmcMaxClock));
+
+    // Mariko specific
+    this->kip->setMarikoCpuMaxVolt(this->config->GetConfigValue(KipConfigValue_marikoCpuMaxVolt));
+    this->kip->setMarikoEmcMaxClock(this->config->GetConfigValue(KipConfigValue_marikoEmcMaxClock));
+    this->kip->setMarikoEmcVddqVolt(this->config->GetConfigValue(KipConfigValue_marikoEmcVddqVolt));
+
+    // Undervolt / UV values
+    this->kip->setMarikoCpuUV(this->config->GetConfigValue(KipConfigValue_marikoCpuUV));
+    this->kip->setMarikoGpuUV(this->config->GetConfigValue(KipConfigValue_marikoGpuUV));
+    this->kip->setEristaCpuUV(this->config->GetConfigValue(KipConfigValue_eristaCpuUV));
+    this->kip->setEristaGpuUV(this->config->GetConfigValue(KipConfigValue_eristaGpuUV));
+
+    // GPU offset / EMC DVB
+    this->kip->setCommonGpuVoltOffset(this->config->GetConfigValue(KipConfigValue_commonGpuVoltOffset));
+    this->kip->setMarikoEmcDvbShift(this->config->GetConfigValue(KipConfigValue_marikoEmcDvbShift));
+
+    // Memory timing values
+    this->kip->setT1_tRCD(this->config->GetConfigValue(KipConfigValue_t1_tRCD));
+    this->kip->setT2_tRP(this->config->GetConfigValue(KipConfigValue_t2_tRP));
+    this->kip->setT3_tRAS(this->config->GetConfigValue(KipConfigValue_t3_tRAS));
+    this->kip->setT4_tRRD(this->config->GetConfigValue(KipConfigValue_t4_tRRD));
+    this->kip->setT5_tRFC(this->config->GetConfigValue(KipConfigValue_t5_tRFC));
+    this->kip->setT6_tRTW(this->config->GetConfigValue(KipConfigValue_t6_tRTW));
+    this->kip->setT7_tWTR(this->config->GetConfigValue(KipConfigValue_t7_tWTR));
+    this->kip->setT8_tREFI(this->config->GetConfigValue(KipConfigValue_t8_tREFI));
+
+    this->kip->setMemBurstReadLatency(this->config->GetConfigValue(KipConfigValue_mem_burst_read_latency));
+    this->kip->setMemBurstWriteLatency(this->config->GetConfigValue(KipConfigValue_mem_burst_write_latency));
+
+    // Additional voltages
+    this->kip->setMarikoCpuHighVmin(this->config->GetConfigValue(KipConfigValue_marikoCpuHighVmin));
+    this->kip->setMarikoCpuLowVmin(this->config->GetConfigValue(KipConfigValue_marikoCpuLowVmin));
+
+    this->kip->setEristaGpuVmin(this->config->GetConfigValue(KipConfigValue_eristaGpuVmin));
+    this->kip->setMarikoGpuVmin(this->config->GetConfigValue(KipConfigValue_marikoGpuVmin));
+    this->kip->setMarikoGpuVmax(this->config->GetConfigValue(KipConfigValue_marikoGpuVmax));
+
+    this->kip->setMarikoGpuFullUnlock(this->config->GetConfigValue(KipConfigValue_marikoGpuFullUnlock));
+
+    // Mariko GPU voltages
+    this->kip->setGVolt76800(this->config->GetConfigValue(KipConfigValue_g_volt_76800));
+    this->kip->setGVolt153600(this->config->GetConfigValue(KipConfigValue_g_volt_153600));
+    this->kip->setGVolt230400(this->config->GetConfigValue(KipConfigValue_g_volt_230400));
+    this->kip->setGVolt307200(this->config->GetConfigValue(KipConfigValue_g_volt_307200));
+    this->kip->setGVolt384000(this->config->GetConfigValue(KipConfigValue_g_volt_384000));
+    this->kip->setGVolt460800(this->config->GetConfigValue(KipConfigValue_g_volt_460800));
+    this->kip->setGVolt537600(this->config->GetConfigValue(KipConfigValue_g_volt_537600));
+    this->kip->setGVolt614400(this->config->GetConfigValue(KipConfigValue_g_volt_614400));
+    this->kip->setGVolt691200(this->config->GetConfigValue(KipConfigValue_g_volt_691200));
+    this->kip->setGVolt768000(this->config->GetConfigValue(KipConfigValue_g_volt_768000));
+    this->kip->setGVolt844800(this->config->GetConfigValue(KipConfigValue_g_volt_844800));
+    this->kip->setGVolt921600(this->config->GetConfigValue(KipConfigValue_g_volt_921600));
+    this->kip->setGVolt998400(this->config->GetConfigValue(KipConfigValue_g_volt_998400));
+    this->kip->setGVolt1075200(this->config->GetConfigValue(KipConfigValue_g_volt_1075200));
+    this->kip->setGVolt1152000(this->config->GetConfigValue(KipConfigValue_g_volt_1152000));
+    this->kip->setGVolt1228800(this->config->GetConfigValue(KipConfigValue_g_volt_1228800));
+    this->kip->setGVolt1267200(this->config->GetConfigValue(KipConfigValue_g_volt_1267200));
+    this->kip->setGVolt1305600(this->config->GetConfigValue(KipConfigValue_g_volt_1305600));
+    this->kip->setGVolt1344000(this->config->GetConfigValue(KipConfigValue_g_volt_1344000));
+    this->kip->setGVolt1382400(this->config->GetConfigValue(KipConfigValue_g_volt_1382400));
+    this->kip->setGVolt1420800(this->config->GetConfigValue(KipConfigValue_g_volt_1420800));
+    this->kip->setGVolt1459200(this->config->GetConfigValue(KipConfigValue_g_volt_1459200));
+    this->kip->setGVolt1497600(this->config->GetConfigValue(KipConfigValue_g_volt_1497600));
+    this->kip->setGVolt1536000(this->config->GetConfigValue(KipConfigValue_g_volt_1536000));
+
+    // Erista GPU voltages
+    this->kip->setGVoltE76800(this->config->GetConfigValue(KipConfigValue_g_volt_e_76800));
+    this->kip->setGVoltE115200(this->config->GetConfigValue(KipConfigValue_g_volt_e_115200));
+    this->kip->setGVoltE153600(this->config->GetConfigValue(KipConfigValue_g_volt_e_153600));
+    this->kip->setGVoltE192000(this->config->GetConfigValue(KipConfigValue_g_volt_e_192000));
+    this->kip->setGVoltE230400(this->config->GetConfigValue(KipConfigValue_g_volt_e_230400));
+    this->kip->setGVoltE268800(this->config->GetConfigValue(KipConfigValue_g_volt_e_268800));
+    this->kip->setGVoltE307200(this->config->GetConfigValue(KipConfigValue_g_volt_e_307200));
+    this->kip->setGVoltE345600(this->config->GetConfigValue(KipConfigValue_g_volt_e_345600));
+    this->kip->setGVoltE384000(this->config->GetConfigValue(KipConfigValue_g_volt_e_384000));
+    this->kip->setGVoltE422400(this->config->GetConfigValue(KipConfigValue_g_volt_e_422400));
+    this->kip->setGVoltE460800(this->config->GetConfigValue(KipConfigValue_g_volt_e_460800));
+    this->kip->setGVoltE499200(this->config->GetConfigValue(KipConfigValue_g_volt_e_499200));
+    this->kip->setGVoltE537600(this->config->GetConfigValue(KipConfigValue_g_volt_e_537600));
+    this->kip->setGVoltE576000(this->config->GetConfigValue(KipConfigValue_g_volt_e_576000));
+    this->kip->setGVoltE614400(this->config->GetConfigValue(KipConfigValue_g_volt_e_614400));
+    this->kip->setGVoltE652800(this->config->GetConfigValue(KipConfigValue_g_volt_e_652800));
+    this->kip->setGVoltE691200(this->config->GetConfigValue(KipConfigValue_g_volt_e_691200));
+    this->kip->setGVoltE729600(this->config->GetConfigValue(KipConfigValue_g_volt_e_729600));
+    this->kip->setGVoltE768000(this->config->GetConfigValue(KipConfigValue_g_volt_e_768000));
+    this->kip->setGVoltE806400(this->config->GetConfigValue(KipConfigValue_g_volt_e_806400));
+    this->kip->setGVoltE844800(this->config->GetConfigValue(KipConfigValue_g_volt_e_844800));
+    this->kip->setGVoltE883200(this->config->GetConfigValue(KipConfigValue_g_volt_e_883200));
+    this->kip->setGVoltE921600(this->config->GetConfigValue(KipConfigValue_g_volt_e_921600));
+    this->kip->setGVoltE960000(this->config->GetConfigValue(KipConfigValue_g_volt_e_960000));
+    this->kip->setGVoltE998400(this->config->GetConfigValue(KipConfigValue_g_volt_e_998400));
+    this->kip->setGVoltE1036800(this->config->GetConfigValue(KipConfigValue_g_volt_e_1036800));
+    this->kip->setGVoltE1075200(this->config->GetConfigValue(KipConfigValue_g_volt_e_1075200));
+
+    // Persist changes to KIP
+    this->kip->writeKip();
+
+}
+
+void ClockManager::GetKipConfigValues() {
+    // General KIP values
+    this->config->SetConfigValue(KipConfigValue_MTCConf, this->kip->getMtcConf());
+    this->config->SetConfigValue(KipConfigValue_commonCpuBoostClock, this->kip->getCommonCpuBoostClock());
+    this->config->SetConfigValue(KipConfigValue_commonEmcMemVolt, this->kip->getCommonEmcMemVolt());
+
+    // Erista specific
+    this->config->SetConfigValue(KipConfigValue_eristaCpuMaxVolt, this->kip->getEristaCpuMaxVolt());
+    this->config->SetConfigValue(KipConfigValue_eristaEmcMaxClock, this->kip->getEristaEmcMaxClock());
+
+    // Mariko specific
+    this->config->SetConfigValue(KipConfigValue_marikoCpuMaxVolt, this->kip->getMarikoCpuMaxVolt());
+    this->config->SetConfigValue(KipConfigValue_marikoEmcMaxClock, this->kip->getMarikoEmcMaxClock());
+    this->config->SetConfigValue(KipConfigValue_marikoEmcVddqVolt, this->kip->getMarikoEmcVddqVolt());
+
+    // Undervolt / UV values
+    this->config->SetConfigValue(KipConfigValue_marikoCpuUV, this->kip->getMarikoCpuUV());
+    this->config->SetConfigValue(KipConfigValue_marikoGpuUV, this->kip->getMarikoGpuUV());
+    this->config->SetConfigValue(KipConfigValue_eristaCpuUV, this->kip->getEristaCpuUV());
+    this->config->SetConfigValue(KipConfigValue_eristaGpuUV, this->kip->getEristaGpuUV());
+
+    // GPU offset / EMC DVB
+    this->config->SetConfigValue(KipConfigValue_commonGpuVoltOffset, this->kip->getCommonGpuVoltOffset());
+    this->config->SetConfigValue(KipConfigValue_marikoEmcDvbShift, this->kip->getMarikoEmcDvbShift());
+
+    // Memory timing values
+    this->config->SetConfigValue(KipConfigValue_t1_tRCD, this->kip->getT1_tRCD());
+    this->config->SetConfigValue(KipConfigValue_t2_tRP, this->kip->getT2_tRP());
+    this->config->SetConfigValue(KipConfigValue_t3_tRAS, this->kip->getT3_tRAS());
+    this->config->SetConfigValue(KipConfigValue_t4_tRRD, this->kip->getT4_tRRD());
+    this->config->SetConfigValue(KipConfigValue_t5_tRFC, this->kip->getT5_tRFC());
+    this->config->SetConfigValue(KipConfigValue_t6_tRTW, this->kip->getT6_tRTW());
+    this->config->SetConfigValue(KipConfigValue_t7_tWTR, this->kip->getT7_tWTR());
+    this->config->SetConfigValue(KipConfigValue_t8_tREFI, this->kip->getT8_tREFI());
+
+    this->config->SetConfigValue(KipConfigValue_mem_burst_read_latency, this->kip->getMemBurstReadLatency());
+    this->config->SetConfigValue(KipConfigValue_mem_burst_write_latency, this->kip->getMemBurstWriteLatency());
+
+    // Additional voltages
+    this->config->SetConfigValue(KipConfigValue_marikoCpuHighVmin, this->kip->getMarikoCpuHighVmin());
+    this->config->SetConfigValue(KipConfigValue_marikoCpuLowVmin, this->kip->getMarikoCpuLowVmin());
+
+    this->config->SetConfigValue(KipConfigValue_eristaGpuVmin, this->kip->getEristaGpuVmin());
+    this->config->SetConfigValue(KipConfigValue_marikoGpuVmin, this->kip->getMarikoGpuVmin());
+    this->config->SetConfigValue(KipConfigValue_marikoGpuVmax, this->kip->getMarikoGpuVmax());
+
+    this->config->SetConfigValue(KipConfigValue_marikoGpuFullUnlock, this->kip->getMarikoGpuFullUnlock());
+
+    // Mariko GPU voltages
+    this->config->SetConfigValue(KipConfigValue_g_volt_76800, this->kip->getGVolt76800());
+    this->config->SetConfigValue(KipConfigValue_g_volt_153600, this->kip->getGVolt153600());
+    this->config->SetConfigValue(KipConfigValue_g_volt_230400, this->kip->getGVolt230400());
+    this->config->SetConfigValue(KipConfigValue_g_volt_307200, this->kip->getGVolt307200());
+    this->config->SetConfigValue(KipConfigValue_g_volt_384000, this->kip->getGVolt384000());
+    this->config->SetConfigValue(KipConfigValue_g_volt_460800, this->kip->getGVolt460800());
+    this->config->SetConfigValue(KipConfigValue_g_volt_537600, this->kip->getGVolt537600());
+    this->config->SetConfigValue(KipConfigValue_g_volt_614400, this->kip->getGVolt614400());
+    this->config->SetConfigValue(KipConfigValue_g_volt_691200, this->kip->getGVolt691200());
+    this->config->SetConfigValue(KipConfigValue_g_volt_768000, this->kip->getGVolt768000());
+    this->config->SetConfigValue(KipConfigValue_g_volt_844800, this->kip->getGVolt844800());
+    this->config->SetConfigValue(KipConfigValue_g_volt_921600, this->kip->getGVolt921600());
+    this->config->SetConfigValue(KipConfigValue_g_volt_998400, this->kip->getGVolt998400());
+    this->config->SetConfigValue(KipConfigValue_g_volt_1075200, this->kip->getGVolt1075200());
+    this->config->SetConfigValue(KipConfigValue_g_volt_1152000, this->kip->getGVolt1152000());
+    this->config->SetConfigValue(KipConfigValue_g_volt_1228800, this->kip->getGVolt1228800());
+    this->config->SetConfigValue(KipConfigValue_g_volt_1267200, this->kip->getGVolt1267200());
+    this->config->SetConfigValue(KipConfigValue_g_volt_1305600, this->kip->getGVolt1305600());
+    this->config->SetConfigValue(KipConfigValue_g_volt_1344000, this->kip->getGVolt1344000());
+    this->config->SetConfigValue(KipConfigValue_g_volt_1382400, this->kip->getGVolt1382400());
+    this->config->SetConfigValue(KipConfigValue_g_volt_1420800, this->kip->getGVolt1420800());
+    this->config->SetConfigValue(KipConfigValue_g_volt_1459200, this->kip->getGVolt1459200());
+    this->config->SetConfigValue(KipConfigValue_g_volt_1497600, this->kip->getGVolt1497600());
+    this->config->SetConfigValue(KipConfigValue_g_volt_1536000, this->kip->getGVolt1536000());
+
+    // Erista GPU voltages
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_76800, this->kip->getGVoltE76800());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_115200, this->kip->getGVoltE115200());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_153600, this->kip->getGVoltE153600());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_192000, this->kip->getGVoltE192000());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_230400, this->kip->getGVoltE230400());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_268800, this->kip->getGVoltE268800());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_307200, this->kip->getGVoltE307200());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_345600, this->kip->getGVoltE345600());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_384000, this->kip->getGVoltE384000());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_422400, this->kip->getGVoltE422400());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_460800, this->kip->getGVoltE460800());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_499200, this->kip->getGVoltE499200());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_537600, this->kip->getGVoltE537600());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_576000, this->kip->getGVoltE576000());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_614400, this->kip->getGVoltE614400());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_652800, this->kip->getGVoltE652800());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_691200, this->kip->getGVoltE691200());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_729600, this->kip->getGVoltE729600());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_768000, this->kip->getGVoltE768000());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_806400, this->kip->getGVoltE806400());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_844800, this->kip->getGVoltE844800());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_883200, this->kip->getGVoltE883200());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_921600, this->kip->getGVoltE921600());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_960000, this->kip->getGVoltE960000());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_998400, this->kip->getGVoltE998400());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_1036800, this->kip->getGVoltE1036800());
+    this->config->SetConfigValue(KipConfigValue_g_volt_e_1075200, this->kip->getGVoltE1075200());
 }
\ No newline at end of file
diff --git a/Source/sys-clk/sysmodule/src/clock_manager.h b/Source/sys-clk/sysmodule/src/clock_manager.h
index c29681d8..c3918a0e 100644
--- a/Source/sys-clk/sysmodule/src/clock_manager.h
+++ b/Source/sys-clk/sysmodule/src/clock_manager.h
@@ -35,6 +35,7 @@
 #include "board.h"
 #include <nxExt/cpp/lockable_mutex.h>
 #include "integrations.h"
+#include "kip_handler.hpp"
 
 class ReverseNXSync;
 
@@ -58,12 +59,15 @@ class ClockManager
     void ResetToStockClocks();
     void WaitForNextTick();
     void SetRNXRTMode(ReverseNXMode mode);
+    void SetKipData();
+    void GetKipConfigValues();
     struct {
       std::uint32_t count;
       std::uint32_t list[SYSCLK_FREQ_LIST_MAX];
     } freqTable[SysClkModule_EnumMax];
-
   protected:
+    KipHandler* kip = new KipHandler("sdmc:/atmosphere/kips/hoc.kip");
+
     bool IsAssignableHz(SysClkModule module, std::uint32_t hz);
     std::uint32_t GetMaxAllowedHz(SysClkModule module, SysClkProfile profile);
     std::uint32_t GetNearestHz(SysClkModule module, std::uint32_t inHz, std::uint32_t maxHz);
diff --git a/Source/sys-clk/sysmodule/src/config.cpp b/Source/sys-clk/sysmodule/src/config.cpp
index 301515e3..7565efcc 100644
--- a/Source/sys-clk/sysmodule/src/config.cpp
+++ b/Source/sys-clk/sysmodule/src/config.cpp
@@ -405,6 +405,22 @@ std::uint64_t Config::GetConfigValue(SysClkConfigValue kval)
     return this->configValues[kval];
 }
 
+void Config::SetConfigValue(SysClkConfigValue kval, std::uint64_t value)
+{
+    ASSERT_ENUM_VALID(SysClkConfigValue, kval);
+
+    std::scoped_lock lock{this->configMutex};
+
+    if(sysclkValidConfigValue(kval, value))
+    {
+        this->configValues[kval] = value;
+    }
+    else
+    {
+        this->configValues[kval] = sysclkDefaultConfigValue(kval);
+    }
+}
+
 const char* Config::GetConfigValueName(SysClkConfigValue kval, bool pretty)
 {
     ASSERT_ENUM_VALID(SysClkConfigValue, kval);
diff --git a/Source/sys-clk/sysmodule/src/config.h b/Source/sys-clk/sysmodule/src/config.h
index d7f2ad62..18a90cb9 100644
--- a/Source/sys-clk/sysmodule/src/config.h
+++ b/Source/sys-clk/sysmodule/src/config.h
@@ -62,6 +62,7 @@ class Config
     std::uint32_t GetOverrideHz(SysClkModule module);
 
     std::uint64_t GetConfigValue(SysClkConfigValue val);
+    void SetConfigValue(SysClkConfigValue val, std::uint64_t value);
     const char* GetConfigValueName(SysClkConfigValue val, bool pretty);
     void GetConfigValues(SysClkConfigValueList* out_configValues);
     bool SetConfigValues(SysClkConfigValueList* configValues, bool immediate);
diff --git a/Source/sys-clk/sysmodule/src/ipc_service.cpp b/Source/sys-clk/sysmodule/src/ipc_service.cpp
index ba43f7d6..ca88daae 100644
--- a/Source/sys-clk/sysmodule/src/ipc_service.cpp
+++ b/Source/sys-clk/sysmodule/src/ipc_service.cpp
@@ -43,6 +43,7 @@ IpcService::IpcService(ClockManager* clockMgr)
 
     this->running = false;
     this->clockMgr = clockMgr;
+    
 }
 
 void IpcService::SetRunning(bool running)
@@ -189,6 +190,8 @@ Result IpcService::ServiceHandlerFunc(void* arg, const IpcServerRequest* r, u8*
                 return ipcSrv->SetReverseNXRTMode(mode);
             }
             break;
+        case HocClkIpcCmd_SetKipData:
+            return ipcSrv->SetKipData();
     }
 
     return SYSCLK_ERROR(Generic);
@@ -345,3 +348,10 @@ Result IpcService::SetReverseNXRTMode(ReverseNXMode mode) {
     ClockManager::GetInstance()->SetRNXRTMode(mode);
     return 0;
 }
+
+Result IpcService::SetKipData() {
+    // ClockManager::GetInstance()->SetRNXRTMode(mode);
+    
+    return 0;
+}
+
diff --git a/Source/sys-clk/sysmodule/src/ipc_service.h b/Source/sys-clk/sysmodule/src/ipc_service.h
index 28fa5124..a3ee842b 100644
--- a/Source/sys-clk/sysmodule/src/ipc_service.h
+++ b/Source/sys-clk/sysmodule/src/ipc_service.h
@@ -31,10 +31,12 @@
 #include <nxExt.h>
 #include <sysclk.h>
 #include "clock_manager.h"
+#include "kip_handler.hpp"
 
 class IpcService
 {
   public:
+
     IpcService(ClockManager* clockMgr);
     virtual ~IpcService();
     void SetRunning(bool running);
@@ -54,11 +56,12 @@ class IpcService
     Result SetConfigValues(SysClkConfigValueList* configValues);
     Result GetFreqList(SysClkIpc_GetFreqList_Args* args, std::uint32_t* out_list, std::size_t size, std::uint32_t* out_count);
     Result SetReverseNXRTMode(ReverseNXMode mode);
-
+    Result SetKipData();
     bool running;
     Thread thread;
     LockableMutex threadMutex;
     IpcServer server;
     ClockManager* clockMgr;
-    protected:
+  protected:
+
 };
diff --git a/Source/sys-clk/sysmodule/src/kip_handler.cpp b/Source/sys-clk/sysmodule/src/kip_handler.cpp
new file mode 100644
index 00000000..56c02c1f
--- /dev/null
+++ b/Source/sys-clk/sysmodule/src/kip_handler.cpp
@@ -0,0 +1,294 @@
+/*
+ * HOC Configurator - KIP Handler Implementation
+ * Copyright (C) Dominatorul, Souldbminer
+ */
+
+#include "kip_handler.hpp"
+#include <fstream>
+#include <cstring>
+#include <vector>
+
+bool KipHandler::readKip() {
+    std::ifstream file(kipPath, std::ios::binary);
+    if (!file.is_open()) {
+        return false;
+    }
+    
+    // Read entire file
+    file.seekg(0, std::ios::end);
+    size_t fileSize = file.tellg();
+    file.seekg(0, std::ios::beg);
+    
+    std::vector<uint8_t> buffer(fileSize);
+    file.read(reinterpret_cast<char*>(buffer.data()), fileSize);
+    file.close();
+    
+    // Find CUST magic
+    size_t magicPos = 0;
+    bool found = false;
+    for (size_t i = 0; i < fileSize - 4; i++) {
+        if (memcmp(&buffer[i], MAGIC, 4) == 0) {
+            magicPos = i + 4;
+            found = true;
+            break;
+        }
+    }
+    
+    if (!found) {
+        return false;
+    }
+    
+    // Read structure (assuming packed uint32_t structure)
+    size_t offset = magicPos;
+    auto readU32 = [&]() -> uint32_t {
+        uint32_t val;
+        memcpy(&val, &buffer[offset], sizeof(uint32_t));
+        offset += sizeof(uint32_t);
+        return val;
+    };
+    
+    data.custRev = readU32();
+    data.mtcConf = readU32();
+    data.hpMode = readU32();
+
+    data.commonCpuBoostClock = readU32();
+    data.commonEmcMemVolt = readU32();
+    data.eristaCpuMaxVolt = readU32();
+    data.eristaEmcMaxClock = readU32();
+    data.marikoCpuMaxVolt = readU32();
+    data.marikoEmcMaxClock = readU32();
+    data.marikoEmcVddqVolt = readU32();
+    data.marikoCpuUV = readU32();
+    data.marikoGpuUV = readU32();
+    data.eristaCpuUV = readU32();
+    data.eristaGpuUV = readU32();
+    data.commonGpuVoltOffset = readU32();
+    data.marikoEmcDvbShift = readU32();
+    
+    // Memory timings
+    data.t1_tRCD = readU32();
+    data.t2_tRP = readU32();
+    data.t3_tRAS = readU32();
+    data.t4_tRRD = readU32();
+    data.t5_tRFC = readU32();
+    data.t6_tRTW = readU32();
+    data.t7_tWTR = readU32();
+    data.t8_tREFI = readU32();
+    data.mem_burst_read_latency = readU32();
+    data.mem_burst_write_latency = readU32();
+
+    // Additional voltages
+    data.marikoCpuHighVmin = readU32();
+    data.marikoCpuLowVmin = readU32();
+    data.eristaGpuVmin = readU32();
+    data.marikoGpuVmin = readU32();
+    data.marikoGpuVmax = readU32();
+    
+    data.marikoGpuFullUnlock = readU32();
+    
+    // GPU voltages Mariko
+    data.g_volt_76800 = readU32();
+    data.g_volt_153600 = readU32();
+    data.g_volt_230400 = readU32();
+    data.g_volt_307200 = readU32();
+    data.g_volt_384000 = readU32();
+    data.g_volt_460800 = readU32();
+    data.g_volt_537600 = readU32();
+    data.g_volt_614400 = readU32();
+    data.g_volt_691200 = readU32();
+    data.g_volt_768000 = readU32();
+    data.g_volt_844800 = readU32();
+    data.g_volt_921600 = readU32();
+    data.g_volt_998400 = readU32();
+    data.g_volt_1075200 = readU32();
+    data.g_volt_1152000 = readU32();
+    data.g_volt_1228800 = readU32();
+    data.g_volt_1267200 = readU32();
+    data.g_volt_1305600 = readU32();
+    data.g_volt_1344000 = readU32();
+    data.g_volt_1382400 = readU32();
+    data.g_volt_1420800 = readU32();
+    data.g_volt_1459200 = readU32();
+    data.g_volt_1497600 = readU32();
+    data.g_volt_1536000 = readU32();
+    
+    // GPU voltages Erista
+    data.g_volt_e_76800 = readU32();
+    data.g_volt_e_115200 = readU32();
+
+    data.g_volt_e_153600 = readU32();
+    data.g_volt_e_192000 = readU32();
+
+    data.g_volt_e_230400 = readU32();
+    data.g_volt_e_268800 = readU32();
+
+    data.g_volt_e_307200 = readU32();
+    data.g_volt_e_345600 = readU32();
+
+    data.g_volt_e_384000 = readU32();
+    data.g_volt_e_422400 = readU32();
+
+    data.g_volt_e_460800 = readU32();
+    data.g_volt_e_499200 = readU32();
+
+    data.g_volt_e_537600 = readU32();
+    data.g_volt_e_576000 = readU32();
+
+    data.g_volt_e_614400 = readU32();
+    data.g_volt_e_652800 = readU32();
+
+    data.g_volt_e_691200 = readU32();
+    data.g_volt_e_729600 = readU32();
+
+    data.g_volt_e_768000 = readU32();
+    data.g_volt_e_806400 = readU32();
+
+    data.g_volt_e_844800 = readU32();
+    data.g_volt_e_883200 = readU32();
+
+    data.g_volt_e_921600 = readU32();
+    data.g_volt_e_960000 = readU32();
+
+    data.g_volt_e_998400 = readU32();
+    data.g_volt_e_1036800 = readU32();
+
+    data.g_volt_e_1075200 = readU32();
+    
+    return true;
+}
+
+bool KipHandler::writeKip() {
+    std::fstream file(kipPath, std::ios::in | std::ios::out | std::ios::binary);
+    if (!file.is_open()) {
+        return false;
+    }
+    
+    // Read entire file
+    file.seekg(0, std::ios::end);
+    size_t fileSize = file.tellg();
+    file.seekg(0, std::ios::beg);
+    
+    std::vector<uint8_t> buffer(fileSize);
+    file.read(reinterpret_cast<char*>(buffer.data()), fileSize);
+    
+    // Find CUST magic
+    size_t magicPos = 0;
+    bool found = false;
+    for (size_t i = 0; i < fileSize - 4; i++) {
+        if (memcmp(&buffer[i], MAGIC, 4) == 0) {
+            magicPos = i + 4;
+            found = true;
+            break;
+        }
+    }
+    
+    if (!found) {
+        file.close();
+        return false;
+    }
+    
+    // Write structure
+    size_t offset = magicPos;
+    auto writeU32 = [&](uint32_t val) {
+        memcpy(&buffer[offset], &val, sizeof(uint32_t));
+        offset += sizeof(uint32_t);
+    };
+    
+    writeU32(data.custRev);
+    writeU32(data.mtcConf);
+    writeU32(data.commonCpuBoostClock);
+    writeU32(data.commonEmcMemVolt);
+    writeU32(data.eristaCpuMaxVolt);
+    writeU32(data.eristaEmcMaxClock);
+    writeU32(data.marikoCpuMaxVolt);
+    writeU32(data.marikoEmcMaxClock);
+    writeU32(data.marikoEmcVddqVolt);
+    writeU32(data.marikoCpuUV);
+    writeU32(data.marikoGpuUV);
+    writeU32(data.eristaCpuUV);
+    writeU32(data.eristaGpuUV);
+    writeU32(data.commonGpuVoltOffset);
+    writeU32(data.marikoEmcDvbShift);
+    
+    // Memory timings
+    writeU32(data.t1_tRCD);
+    writeU32(data.t2_tRP);
+    writeU32(data.t3_tRAS);
+    writeU32(data.t4_tRRD);
+    writeU32(data.t5_tRFC);
+    writeU32(data.t6_tRTW);
+    writeU32(data.t7_tWTR);
+    writeU32(data.t8_tREFI);
+    writeU32(data.mem_burst_read_latency);
+    writeU32(data.mem_burst_write_latency);
+
+    // Additional voltages
+    writeU32(data.marikoCpuHighVmin);
+    writeU32(data.marikoCpuLowVmin);
+
+    writeU32(data.eristaGpuVmin);
+    writeU32(data.marikoGpuVmin);
+    writeU32(data.marikoGpuVmax);
+    
+    // GPU voltages Mariko
+    writeU32(data.g_volt_76800);
+    writeU32(data.g_volt_153600);
+    writeU32(data.g_volt_230400);
+    writeU32(data.g_volt_307200);
+    writeU32(data.g_volt_384000);
+    writeU32(data.g_volt_460800);
+    writeU32(data.g_volt_537600);
+    writeU32(data.g_volt_614400);
+    writeU32(data.g_volt_691200);
+    writeU32(data.g_volt_768000);
+    writeU32(data.g_volt_844800);
+    writeU32(data.g_volt_921600);
+    writeU32(data.g_volt_998400);
+    writeU32(data.g_volt_1075200);
+    writeU32(data.g_volt_1152000);
+    writeU32(data.g_volt_1228800);
+    writeU32(data.g_volt_1267200);
+    writeU32(data.g_volt_1305600);
+    writeU32(data.g_volt_1344000);
+    writeU32(data.g_volt_1382400);
+    writeU32(data.g_volt_1420800);
+    writeU32(data.g_volt_1459200);
+    writeU32(data.g_volt_1497600);
+    writeU32(data.g_volt_1536000);
+    
+    // GPU voltages Erista
+    writeU32(data.g_volt_e_76800);
+    writeU32(data.g_volt_e_115200);
+    writeU32(data.g_volt_e_153600);
+    writeU32(data.g_volt_e_192000);
+    writeU32(data.g_volt_e_230400);
+    writeU32(data.g_volt_e_268800);
+    writeU32(data.g_volt_e_307200);
+    writeU32(data.g_volt_e_345600);
+    writeU32(data.g_volt_e_384000);
+    writeU32(data.g_volt_e_422400);
+    writeU32(data.g_volt_e_460800);
+    writeU32(data.g_volt_e_499200);
+    writeU32(data.g_volt_e_537600);
+    writeU32(data.g_volt_e_576000);
+    writeU32(data.g_volt_e_614400);
+    writeU32(data.g_volt_e_652800);
+    writeU32(data.g_volt_e_691200);
+    writeU32(data.g_volt_e_729600);
+    writeU32(data.g_volt_e_768000);
+    writeU32(data.g_volt_e_806400);
+    writeU32(data.g_volt_e_844800);
+    writeU32(data.g_volt_e_883200);
+    writeU32(data.g_volt_e_921600);
+    writeU32(data.g_volt_e_960000);
+    writeU32(data.g_volt_e_998400);
+    writeU32(data.g_volt_e_1036800);
+    writeU32(data.g_volt_e_1075200);
+    
+    // Write back to file
+    file.seekp(0, std::ios::beg);
+    file.write(reinterpret_cast<char*>(buffer.data()), fileSize);
+    file.close();
+    
+    return true;
+}
\ No newline at end of file
diff --git a/Source/sys-clk/sysmodule/src/kip_handler.hpp b/Source/sys-clk/sysmodule/src/kip_handler.hpp
new file mode 100644
index 00000000..ff561371
--- /dev/null
+++ b/Source/sys-clk/sysmodule/src/kip_handler.hpp
@@ -0,0 +1,328 @@
+/*
+ * HOC Configurator - KIP Handler
+ * Copyright (C) Dominatorul, Souldbminer
+ */
+
+#pragma once
+#include <string>
+#include <cstdint>
+#include <vector>
+
+class KipHandler {
+private:
+    std::string kipPath = "sdmc:/atmosphere/kips/hoc.kip";
+    const uint8_t MAGIC[4] = {'C', 'U', 'S', 'T'};
+    
+    struct KipData {
+        uint32_t custRev;
+        uint32_t mtcConf;
+        uint32_t hpMode;
+        uint32_t commonCpuBoostClock;
+        uint32_t commonEmcMemVolt;
+        uint32_t eristaCpuMaxVolt;
+        uint32_t eristaEmcMaxClock;
+        uint32_t marikoCpuMaxVolt;
+        uint32_t marikoEmcMaxClock;
+        uint32_t marikoEmcVddqVolt;
+        uint32_t marikoCpuUV;
+        uint32_t marikoGpuUV;
+        uint32_t eristaCpuUV;
+        uint32_t eristaGpuUV;
+        uint32_t commonGpuVoltOffset;
+        uint32_t marikoEmcDvbShift;
+        
+        // Memory timings
+        uint32_t t1_tRCD;
+        uint32_t t2_tRP;
+        uint32_t t3_tRAS;
+        uint32_t t4_tRRD;
+        uint32_t t5_tRFC;
+        uint32_t t6_tRTW;
+        uint32_t t7_tWTR;
+        uint32_t t8_tREFI;
+        uint32_t mem_burst_read_latency;
+        uint32_t mem_burst_write_latency;
+        
+        // Additional voltages
+        uint32_t marikoCpuHighVmin;
+        uint32_t marikoCpuLowVmin;
+
+        uint32_t eristaGpuVmin;
+        uint32_t marikoGpuVmin;
+        uint32_t marikoGpuVmax;
+        
+        uint32_t marikoGpuFullUnlock;
+
+        // GPU voltages for each frequency (Mariko)
+        uint32_t g_volt_76800;
+        uint32_t g_volt_153600;
+        uint32_t g_volt_230400;
+        uint32_t g_volt_307200;
+        uint32_t g_volt_384000;
+        uint32_t g_volt_460800;
+        uint32_t g_volt_537600;
+        uint32_t g_volt_614400;
+        uint32_t g_volt_691200;
+        uint32_t g_volt_768000;
+        uint32_t g_volt_844800;
+        uint32_t g_volt_921600;
+        uint32_t g_volt_998400;
+        uint32_t g_volt_1075200;
+        uint32_t g_volt_1152000;
+        uint32_t g_volt_1228800;
+        uint32_t g_volt_1267200;
+        uint32_t g_volt_1305600;
+        uint32_t g_volt_1344000;
+        uint32_t g_volt_1382400;
+        uint32_t g_volt_1420800;
+        uint32_t g_volt_1459200;
+        uint32_t g_volt_1497600;
+        uint32_t g_volt_1536000;
+        
+        // GPU voltages for each frequency (Erista)
+        uint32_t g_volt_e_76800;
+        uint32_t g_volt_e_115200;
+        uint32_t g_volt_e_153600;
+        uint32_t g_volt_e_192000;
+
+        uint32_t g_volt_e_230400;
+        uint32_t g_volt_e_268800;
+
+        uint32_t g_volt_e_307200;
+        uint32_t g_volt_e_345600;
+
+        uint32_t g_volt_e_384000;
+        uint32_t g_volt_e_422400;
+
+        uint32_t g_volt_e_460800;
+        uint32_t g_volt_e_499200;
+
+        uint32_t g_volt_e_537600;
+        uint32_t g_volt_e_576000;
+
+        uint32_t g_volt_e_614400;
+        uint32_t g_volt_e_652800;
+
+        uint32_t g_volt_e_691200;
+        uint32_t g_volt_e_729600;
+
+        uint32_t g_volt_e_768000;
+        uint32_t g_volt_e_806400;
+
+        uint32_t g_volt_e_844800;
+        uint32_t g_volt_e_883200;
+
+        uint32_t g_volt_e_921600;
+        uint32_t g_volt_e_960000;
+        uint32_t g_volt_e_998400;
+        uint32_t g_volt_e_1036800;
+        uint32_t g_volt_e_1075200;
+    };
+    
+    KipData data;
+
+public:
+    KipHandler(const std::string& path) : kipPath(path) {
+        // Initialize with defaults
+    }
+    
+    bool readKip();
+    bool writeKip();
+    
+    // Getters
+    KipData& getData() { return data; }
+    const KipData& getData() const { return data; }
+    
+    // Setters for all KipData fields
+//     void setCustRev(uint32_t val) { data.custRev = val; }
+    void setMtcConf(uint32_t val) { data.mtcConf = val; }
+    void setHpMode(uint32_t val) { data.hpMode = val; }
+    void setCommonCpuBoostClock(uint32_t val) { data.commonCpuBoostClock = val; }
+    void setCommonEmcMemVolt(uint32_t val) { data.commonEmcMemVolt = val; }
+    void setEristaCpuMaxVolt(uint32_t val) { data.eristaCpuMaxVolt = val; }
+    void setEristaEmcMaxClock(uint32_t val) { data.eristaEmcMaxClock = val; }
+    void setMarikoCpuMaxVolt(uint32_t val) { data.marikoCpuMaxVolt = val; }
+    void setMarikoEmcMaxClock(uint32_t val) { data.marikoEmcMaxClock = val; }
+    void setMarikoEmcVddqVolt(uint32_t val) { data.marikoEmcVddqVolt = val; }
+    void setMarikoCpuUV(uint32_t val) { data.marikoCpuUV = val; }
+    void setMarikoGpuUV(uint32_t val) { data.marikoGpuUV = val; }
+    void setEristaCpuUV(uint32_t val) { data.eristaCpuUV = val; }
+    void setEristaGpuUV(uint32_t val) { data.eristaGpuUV = val; }
+    void setCommonGpuVoltOffset(uint32_t val) { data.commonGpuVoltOffset = val; }
+    void setMarikoEmcDvbShift(uint32_t val) { data.marikoEmcDvbShift = val; }
+    
+    // Memory timing setters
+    void setT1_tRCD(uint32_t val) { data.t1_tRCD = val; }
+    void setT2_tRP(uint32_t val) { data.t2_tRP = val; }
+    void setT3_tRAS(uint32_t val) { data.t3_tRAS = val; }
+    void setT4_tRRD(uint32_t val) { data.t4_tRRD = val; }
+    void setT5_tRFC(uint32_t val) { data.t5_tRFC = val; }
+    void setT6_tRTW(uint32_t val) { data.t6_tRTW = val; }
+    void setT7_tWTR(uint32_t val) { data.t7_tWTR = val; }
+    void setT8_tREFI(uint32_t val) { data.t8_tREFI = val; }
+    void setMemBurstReadLatency(uint32_t val) { data.mem_burst_read_latency = val; }
+    void setMemBurstWriteLatency(uint32_t val) { data.mem_burst_write_latency = val; }
+    
+    // Additional voltage setters
+    void setMarikoCpuHighVmin(uint32_t val) { data.marikoCpuHighVmin = val; }
+    void setMarikoCpuLowVmin(uint32_t val) { data.marikoCpuLowVmin = val; }
+    void setEristaGpuVmin(uint32_t val) { data.eristaGpuVmin = val; }
+    void setMarikoGpuVmin(uint32_t val) { data.marikoGpuVmin = val; }
+    void setMarikoGpuVmax(uint32_t val) { data.marikoGpuVmax = val; }
+    void setMarikoGpuFullUnlock(uint32_t val) { data.marikoGpuFullUnlock = val; }
+    
+    // GPU voltage setters for Mariko
+    void setGVolt76800(uint32_t val) { data.g_volt_76800 = val; }
+    void setGVolt153600(uint32_t val) { data.g_volt_153600 = val; }
+    void setGVolt230400(uint32_t val) { data.g_volt_230400 = val; }
+    void setGVolt307200(uint32_t val) { data.g_volt_307200 = val; }
+    void setGVolt384000(uint32_t val) { data.g_volt_384000 = val; }
+    void setGVolt460800(uint32_t val) { data.g_volt_460800 = val; }
+    void setGVolt537600(uint32_t val) { data.g_volt_537600 = val; }
+    void setGVolt614400(uint32_t val) { data.g_volt_614400 = val; }
+    void setGVolt691200(uint32_t val) { data.g_volt_691200 = val; }
+    void setGVolt768000(uint32_t val) { data.g_volt_768000 = val; }
+    void setGVolt844800(uint32_t val) { data.g_volt_844800 = val; }
+    void setGVolt921600(uint32_t val) { data.g_volt_921600 = val; }
+    void setGVolt998400(uint32_t val) { data.g_volt_998400 = val; }
+    void setGVolt1075200(uint32_t val) { data.g_volt_1075200 = val; }
+    void setGVolt1152000(uint32_t val) { data.g_volt_1152000 = val; }
+    void setGVolt1228800(uint32_t val) { data.g_volt_1228800 = val; }
+    void setGVolt1267200(uint32_t val) { data.g_volt_1267200 = val; }
+    void setGVolt1305600(uint32_t val) { data.g_volt_1305600 = val; }
+    void setGVolt1344000(uint32_t val) { data.g_volt_1344000 = val; }
+    void setGVolt1382400(uint32_t val) { data.g_volt_1382400 = val; }
+    void setGVolt1420800(uint32_t val) { data.g_volt_1420800 = val; }
+    void setGVolt1459200(uint32_t val) { data.g_volt_1459200 = val; }
+    void setGVolt1497600(uint32_t val) { data.g_volt_1497600 = val; }
+    void setGVolt1536000(uint32_t val) { data.g_volt_1536000 = val; }
+    
+    // GPU voltage setters for Erista
+    void setGVoltE76800(uint32_t val) { data.g_volt_e_76800 = val; }
+    void setGVoltE115200(uint32_t val) { data.g_volt_e_115200 = val; }
+    void setGVoltE153600(uint32_t val) { data.g_volt_e_153600 = val; }
+    void setGVoltE192000(uint32_t val) { data.g_volt_e_192000 = val; }
+    void setGVoltE230400(uint32_t val) { data.g_volt_e_230400 = val; }
+    void setGVoltE268800(uint32_t val) { data.g_volt_e_268800 = val; }
+    void setGVoltE307200(uint32_t val) { data.g_volt_e_307200 = val; }
+    void setGVoltE345600(uint32_t val) { data.g_volt_e_345600 = val; }
+    void setGVoltE384000(uint32_t val) { data.g_volt_e_384000 = val; }
+    void setGVoltE422400(uint32_t val) { data.g_volt_e_422400 = val; }
+    void setGVoltE460800(uint32_t val) { data.g_volt_e_460800 = val; }
+    void setGVoltE499200(uint32_t val) { data.g_volt_e_499200 = val; }
+    void setGVoltE537600(uint32_t val) { data.g_volt_e_537600 = val; }
+    void setGVoltE576000(uint32_t val) { data.g_volt_e_576000 = val; }
+    void setGVoltE614400(uint32_t val) { data.g_volt_e_614400 = val; }
+    void setGVoltE652800(uint32_t val) { data.g_volt_e_652800 = val; }
+    void setGVoltE691200(uint32_t val) { data.g_volt_e_691200 = val; }
+    void setGVoltE729600(uint32_t val) { data.g_volt_e_729600 = val; }
+    void setGVoltE768000(uint32_t val) { data.g_volt_e_768000 = val; }
+    void setGVoltE806400(uint32_t val) { data.g_volt_e_806400 = val; }
+    void setGVoltE844800(uint32_t val) { data.g_volt_e_844800 = val; }
+    void setGVoltE883200(uint32_t val) { data.g_volt_e_883200 = val; }
+    void setGVoltE921600(uint32_t val) { data.g_volt_e_921600 = val; }
+    void setGVoltE960000(uint32_t val) { data.g_volt_e_960000 = val; }
+    void setGVoltE998400(uint32_t val) { data.g_volt_e_998400 = val; }
+    void setGVoltE1036800(uint32_t val) { data.g_volt_e_1036800 = val; }
+    void setGVoltE1075200(uint32_t val) { data.g_volt_e_1075200 = val; }
+    
+    // Getters for all KipData fields
+    uint32_t getMtcConf() const { return data.mtcConf; }
+    uint32_t getHpMode() const { return data.hpMode; }
+    uint32_t getCommonCpuBoostClock() const { return data.commonCpuBoostClock; }
+    uint32_t getCommonEmcMemVolt() const { return data.commonEmcMemVolt; }
+    uint32_t getEristaCpuMaxVolt() const { return data.eristaCpuMaxVolt; }
+    uint32_t getEristaEmcMaxClock() const { return data.eristaEmcMaxClock; }
+    uint32_t getMarikoCpuMaxVolt() const { return data.marikoCpuMaxVolt; }
+    uint32_t getMarikoEmcMaxClock() const { return data.marikoEmcMaxClock; }
+    uint32_t getMarikoEmcVddqVolt() const { return data.marikoEmcVddqVolt; }
+    uint32_t getMarikoCpuUV() const { return data.marikoCpuUV; }
+    uint32_t getMarikoGpuUV() const { return data.marikoGpuUV; }
+    uint32_t getEristaCpuUV() const { return data.eristaCpuUV; }
+    uint32_t getEristaGpuUV() const { return data.eristaGpuUV; }
+    uint32_t getCommonGpuVoltOffset() const { return data.commonGpuVoltOffset; }
+    uint32_t getMarikoEmcDvbShift() const { return data.marikoEmcDvbShift; }
+    
+    // Memory timing getters
+    uint32_t getT1_tRCD() const { return data.t1_tRCD; }
+    uint32_t getT2_tRP() const { return data.t2_tRP; }
+    uint32_t getT3_tRAS() const { return data.t3_tRAS; }
+    uint32_t getT4_tRRD() const { return data.t4_tRRD; }
+    uint32_t getT5_tRFC() const { return data.t5_tRFC; }
+    uint32_t getT6_tRTW() const { return data.t6_tRTW; }
+    uint32_t getT7_tWTR() const { return data.t7_tWTR; }
+    uint32_t getT8_tREFI() const { return data.t8_tREFI; }
+    uint32_t getMemBurstReadLatency() const { return data.mem_burst_read_latency; }
+    uint32_t getMemBurstWriteLatency() const { return data.mem_burst_write_latency; }
+    
+    // Additional voltage getters
+    uint32_t getMarikoCpuHighVmin() const { return data.marikoCpuHighVmin; }
+    uint32_t getMarikoCpuLowVmin() const { return data.marikoCpuLowVmin; }
+    uint32_t getEristaGpuVmin() const { return data.eristaGpuVmin; }
+    uint32_t getMarikoGpuVmin() const { return data.marikoGpuVmin; }
+    uint32_t getMarikoGpuVmax() const { return data.marikoGpuVmax; }
+    uint32_t getMarikoGpuFullUnlock() const { return data.marikoGpuFullUnlock; }
+    
+    // GPU voltage getters for Mariko
+    uint32_t getGVolt76800() const { return data.g_volt_76800; }
+    uint32_t getGVolt153600() const { return data.g_volt_153600; }
+    uint32_t getGVolt230400() const { return data.g_volt_230400; }
+    uint32_t getGVolt307200() const { return data.g_volt_307200; }
+    uint32_t getGVolt384000() const { return data.g_volt_384000; }
+    uint32_t getGVolt460800() const { return data.g_volt_460800; }
+    uint32_t getGVolt537600() const { return data.g_volt_537600; }
+    uint32_t getGVolt614400() const { return data.g_volt_614400; }
+    uint32_t getGVolt691200() const { return data.g_volt_691200; }
+    uint32_t getGVolt768000() const { return data.g_volt_768000; }
+    uint32_t getGVolt844800() const { return data.g_volt_844800; }
+    uint32_t getGVolt921600() const { return data.g_volt_921600; }
+    uint32_t getGVolt998400() const { return data.g_volt_998400; }
+    uint32_t getGVolt1075200() const { return data.g_volt_1075200; }
+    uint32_t getGVolt1152000() const { return data.g_volt_1152000; }
+    uint32_t getGVolt1228800() const { return data.g_volt_1228800; }
+    uint32_t getGVolt1267200() const { return data.g_volt_1267200; }
+    uint32_t getGVolt1305600() const { return data.g_volt_1305600; }
+    uint32_t getGVolt1344000() const { return data.g_volt_1344000; }
+    uint32_t getGVolt1382400() const { return data.g_volt_1382400; }
+    uint32_t getGVolt1420800() const { return data.g_volt_1420800; }
+    uint32_t getGVolt1459200() const { return data.g_volt_1459200; }
+    uint32_t getGVolt1497600() const { return data.g_volt_1497600; }
+    uint32_t getGVolt1536000() const { return data.g_volt_1536000; }
+    
+    // GPU voltage getters for Erista
+    uint32_t getGVoltE76800() const { return data.g_volt_e_76800; }
+    uint32_t getGVoltE115200() const { return data.g_volt_e_115200; }
+    uint32_t getGVoltE153600() const { return data.g_volt_e_153600; }
+    uint32_t getGVoltE192000() const { return data.g_volt_e_192000; }
+    uint32_t getGVoltE230400() const { return data.g_volt_e_230400; }
+    uint32_t getGVoltE268800() const { return data.g_volt_e_268800; }
+    uint32_t getGVoltE307200() const { return data.g_volt_e_307200; }
+    uint32_t getGVoltE345600() const { return data.g_volt_e_345600; }
+    uint32_t getGVoltE384000() const { return data.g_volt_e_384000; }
+    uint32_t getGVoltE422400() const { return data.g_volt_e_422400; }
+    uint32_t getGVoltE460800() const { return data.g_volt_e_460800; }
+    uint32_t getGVoltE499200() const { return data.g_volt_e_499200; }
+    uint32_t getGVoltE537600() const { return data.g_volt_e_537600; }
+    uint32_t getGVoltE576000() const { return data.g_volt_e_576000; }
+    uint32_t getGVoltE614400() const { return data.g_volt_e_614400; }
+    uint32_t getGVoltE652800() const { return data.g_volt_e_652800; }
+    uint32_t getGVoltE691200() const { return data.g_volt_e_691200; }
+    uint32_t getGVoltE729600() const { return data.g_volt_e_729600; }
+    uint32_t getGVoltE768000() const { return data.g_volt_e_768000; }
+    uint32_t getGVoltE806400() const { return data.g_volt_e_806400; }
+    uint32_t getGVoltE844800() const { return data.g_volt_e_844800; }
+    uint32_t getGVoltE883200() const { return data.g_volt_e_883200; }
+    uint32_t getGVoltE921600() const { return data.g_volt_e_921600; }
+    uint32_t getGVoltE960000() const { return data.g_volt_e_960000; }
+    uint32_t getGVoltE998400() const { return data.g_volt_e_998400; }
+    uint32_t getGVoltE1036800() const { return data.g_volt_e_1036800; }
+    uint32_t getGVoltE1075200() const { return data.g_volt_e_1075200; }
+    
+    // Utility
+    std::string getKipPath() const { return kipPath; }
+    void setKipPath(const std::string& path) { kipPath = path; }
+};
+
+static inline void storeKipValues() {
+
+}
\ No newline at end of file