improve timings

This commit is contained in:
Lightos1 committed 2026-09-06 15:37:36 +02:00
1 parent 763ef09020
commit bd6d615143
13 files changed
+566 -436

No files matched your search

@@ -15,189 +15,174 @@
*/
#include "../../mtc_timing_value.hpp"
#include "../common/calculate_timings_common.hpp"
namespace ams::ldr::hoc::pcv::erista {
/* Dumped from bpmp fw mtc table (l4t). */
const RextPatch g_rext_table[] = {
{1'633'000, 0x17}, {1'728'000, 0x17}, {1'795'200, 0x19},
{1'862'400, 0x1A}, {1'894'400, 0x1A}, {1'932'800, 0x1A},
{1'958'400, 0x1A}, {1'996'800, 0x1A}, {2'035'200, 0x1A},
{2'064'000, 0x19}, {2'099'200, 0x19}, {2'131'200, 0x1A},
{2'163'200, 0x1A}, {2'188'800, 0x1A}, {2'227'200, 0x1A},
{2'265'600, 0x1B}, {2'291'200, 0x1B}, {2'329'600, 0x1A},
{2'361'600, 0x1A},
};
namespace {
/* Dumped from bpmp fw mtc table (l4t). */
const RextPatch gRextTable[] = {
{1'633'000, 0x17}, {1'728'000, 0x17}, {1'795'200, 0x19},
{1'862'400, 0x1A}, {1'894'400, 0x1A}, {1'932'800, 0x1A},
{1'958'400, 0x1A}, {1'996'800, 0x1A}, {2'035'200, 0x1A},
{2'064'000, 0x19}, {2'099'200, 0x19}, {2'131'200, 0x1A},
{2'163'200, 0x1A}, {2'188'800, 0x1A}, {2'227'200, 0x1A},
{2'265'600, 0x1B}, {2'291'200, 0x1B}, {2'329'600, 0x1A},
{2'361'600, 0x1A},
};
const RextPatch *LookupRext(u32 freq) {
for (u32 i = 0; i < std::size(g_rext_table); i++) {
if (g_rext_table[i].freq >= freq) {
return &g_rext_table[i];
const RextPatch *LookupRext(u32 freq) {
for (u32 i = 0; i < std::size(gRextTable); i++) {
if (gRextTable[i].freq >= freq) {
return &gRextTable[i];
}
}
}
return nullptr;
}
void GetRext(u32 freq) {
if (auto r = LookupRext(freq)) {
rext = r->rext;
return;
return nullptr;
}
/* Fallback */
rext = 0x1A;
}
void SwitchLatency(volatile u32 &latency, u32 index, u32 latencyStep) {
latency += index * latencyStep;
}
static s32 GetMaxLatencyIndex(volatile u32 *latencyArray, u32 latencySize) {
s32 maxIndex = -1;
for (u32 i = 0; i < latencySize; ++i) {
if (latencyArray[i]) {
maxIndex = i;
}
}
return maxIndex;
}
void AutoLatency(volatile u32 &latency, u32 freq, u32 latencyStep) {
if (freq > 1600'000 && freq <= 1866'000) { /* 1866tRWL */
latency += latencyStep * 2;
} else { /* 2133tRWL */
latency += latencyStep * 3;
}
}
void HandleLatency(u32 freq, volatile u32 &latency, volatile u32 *latencyArray, u32 indexMax, u32 latencyStep) {
for (u32 i = 0; i <= indexMax; ++i) {
if (latencyArray[i] != 0 && freq <= latencyArray[i]) {
SwitchLatency(latency, i, latencyStep);
void GetRext(u32 freq) {
if (auto r = LookupRext(freq)) {
rext = r->rext;
return;
}
/* Fallback */
rext = 0x1A;
}
SwitchLatency(latency, indexMax, latencyStep);
}
void CalculateReadTimings(u32 freq, double tCK_avg) {
tR2P = CalculateNTRTP();
void HandleLatency(u32 freq) {
static s32 rlIndexMax = GetMaxLatencyIndex(C.readLatency, std::size(C.readLatency));
static s32 wlIndexMax = GetMaxLatencyIndex(C.writeLatency, std::size(C.writeLatency));
constexpr u32 ReadLatencyStep = 4;
constexpr u32 WriteLatencyStep = 2;
bool autoLatencyRead = false, autoLatencyWrite = false;
double fullRoundDelay = flyByTime + tDQSCK_max;
if (rlIndexMax == -1) {
AutoLatency(RL, freq, ReadLatencyStep);
autoLatencyRead = true;
/* Read to write turnaround. */
/* Nvidia seem to use a 0.25 constant here for tK1, I am 99% certain this is tDQSTA. */
/* This still left a mismatch; after some brute forcing I got GET_CYCLE_FLOOR(1.5) - 8 (using a static latency) as the cleanest result. */
/* The latency definitely is not WL, but when testing for every latency, it lines up perfectly with wqsOn and wl seems to cancel out? */
tR2W = RL + (BL / 2) + CEIL((fullRoundDelay / tCK_avg) + tDQSTA) - GET_CYCLE_FLOOR(1.5) - GetWdqsOn() + tWPRE - (C.t6_tRTW * 3) + finetRTW;
/* Read data valid: Read command -> data ready to be latched into the registers. */
rdv = RL + GET_CYCLE_CEIL(fullRoundDelay) + 18;
/* Read command -> data poppable at the pad macros, 16 cycles ahead of rdv. */
qpop = rdv - 16;
constexpr double TrimmerStepPs = 3.0;
constexpr double MaxTrimmerSteps = 95.0;
double tCkAvgPs = tCK_avg * 1000.0;
double tckDerated = tCkAvgPs * 0.85;
u32 derateStepCount = MIN(FLOOR(tckDerated / TrimmerStepPs), MaxTrimmerSteps);
double deratedNsDelay = (derateStepCount * TrimmerStepPs) / 1000.0;
/* readEyeEndDerated, nv call this quseExtra. */
u32 quseExtra = GET_CYCLE_CEIL(fullRoundDelay - deratedNsDelay);
/* The amount of deration from the perspective of a full round trip. */
u32 readEyeEndDerateMargin = GET_CYCLE_CEIL(fullRoundDelay) - quseExtra;
u32 tQuse = FLOOR((flyByTime + 0.94) / tCK_avg);
u32 readEyeStart = tQuse + RL + 1;
u32 einputMinimal = readEyeStart + readEyeEndDerateMargin - 2;
/* Data valid window, quse aligns with the start of the read eye (probably). */
/* DQS needs to be logically and'ed with quse in order to be valid. */
/* einputMinimal satisfies this. */
quse = einputMinimal;
/* Difference between the two eye edges. */
quse_width = quseExtra - tQuse + 4;
/* input receiver takes time to enable. */
u32 einputLatency = GET_CYCLE_CEIL(10.0);
/* Enable input receiver. */
einput = einputMinimal - einputLatency;
/* Duration of input receiver being enabled? */
einput_duration = einputLatency + quse_width + 4;
/* qrst_duration is CEIL(a / tCK_avg + b) */
/* a and b were derived through a brute forcer. */
u32 qrst_duration = CEIL(1.4 / tCK_avg + 3.5);
u32 qrstLow = MAX(static_cast<s32>(einput - qrst_duration - 2), static_cast<s32>(0));
/* quse reset? */
qrst = PACK_U32(qrst_duration, qrstLow);
/* Qsafe, safe to reset quse? */
qsafe = (einput_duration + 3) + MAX(MIN(qrstLow * rdv, qrst_duration + qrst_duration), einput);
/* Input buffer delay? */
ibdly = PACK_U32_NIBBLE_HIGH_BYTE_LOW(1, quse - qrst_duration - 2.0);
GetRext(freq);
}
if (wlIndexMax == -1) {
AutoLatency(WL, freq, WriteLatencyStep);
autoLatencyWrite = true;
void CalculateWriteTimings(double tCK_avg) {
/* Write to read turnaround. */
/* According to jedec specifications: nWR >= tWTR + nRTP */
/* Therefore tWTR >= nWR - tRTP. */
const u32 nTWTR = GET_CYCLE_CEIL(tWTRStock);
const u32 nWr = CalculateNWr();
u32 autoPrecharcetWTRMin = nWr - tR2P;
/* tWTR reduction is applied in a weird way to not break existing setups. */
tW2R = WL + 1 + MAX(autoPrecharcetWTRMin, nTWTR) - GET_CYCLE_CEIL(tWTR) + finetWTR;
tW2P = (CEIL(WL * 1.7303) * 2) - 5;
tWTPDEN = CEIL(((1.8 / tCK_avg) + MAX(RL + (2.7 / tCK_avg), static_cast<double>(tW2P))) + (BL / 2));
wdv = WL;
wsv = WL - 2;
wev = WL - 4;
/* Output buffer delay? */
u32 obdlyHigh = 3 / FLOOR(MIN(static_cast<double>(2), tCK_avg * (WL - 7)));
u32 obdlyLow = MAX(WL - FLOOR((126.0 / CEIL(tCK_avg + 8.601))), 0.0);
obdly = PACK_U32_NIBBLE_HIGH_BYTE_LOW(obdlyHigh, obdlyLow);
}
if (autoLatencyRead && autoLatencyWrite) {
return;
}
void CalculatePowerDownTimings(double tCK_avg) {
pdex2rw = CEIL((CEIL(12.335 - tCK_avg) + (7.430 / tCK_avg) - CEIL(tCK_avg * 11.361)));
tCLKSTOP = FLOOR(MIN(8.488 / tCK_avg, 23.0)) + 8.0;
if (!autoLatencyRead) {
HandleLatency(freq, RL, C.readLatency, rlIndexMax, ReadLatencyStep);
}
if (!autoLatencyWrite) {
HandleLatency(freq, WL, C.writeLatency, wlIndexMax, WriteLatencyStep);
const double tMMRI = tRCD + (tCK_avg * 3);
pdex2mrr = tMMRI + 10;
}
}
void CalculateMrw2() {
static const u8 rlMapDBI[8] = {
6, 12, 16, 22, 28, 32, 36, 40
u8 GetNWrIndex() {
static const u8 nWrMap[8] = {
6, 10, 16, 20, 24, 30, 34, 40
};
static const u8 wlMapSetA[8] = {
4, 6, 8, 10, 12, 14, 16, 18
};
const u32 nWr = CalculateNWr();
u32 rlIndex = 0;
u32 wlIndex = 0;
for (u32 i = 0; i < std::size(rlMapDBI); ++i) {
if (rlMapDBI[i] == 32) {
rlIndex = i;
break;
for (u8 i = 0; i < std::size(nWrMap); ++i) {
if (nWrMap[i] >= nWr) {
return i;
}
}
for (u32 i = 0; i < std::size(wlMapSetA); ++i) {
if (wlMapSetA[i] == WL) {
wlIndex = i;
break;
}
}
/* DBI is always enabled. */
mrw2 = static_cast<u8>(((rlIndex & 0x7) | ((wlIndex & 0x7) << 3) | ((0 & 0x1) << 6)));
return static_cast<u8>(std::size(nWrMap) - 1);
}
void CalculateTimings(double tCK_avg, u32 freq) {
RL = RL_1331;
WL = WL_1331;
RL = RL_1333;
WL = WL_1333;
/* I don't understand why, I don't want to know why, but for some fucking reason erista doesn't handle RL 40. */
/* This should not be required but for these fuck damn reasons any type of dram oc will crash instantly with RL 40. */
/* But it works fine in l4t? Even when copying the tables it still doesn't work??? WTF */
readLatency[std::size(readLatency) - 1] = 0;
HandleLatency(freq);
GetRext(freq);
CalculateMrw2();
RL = std::min(static_cast<u32>(RL_1866), RL);
tR2P = CEIL((RL * 0.426) - 2.0);
tR2W = FLOOR(FLOOR((5.0 / tCK_avg) + ((FLOOR(48.0 / WL) - 0.478) * 3.0)) / 1.501) + RL - (C.t6_tRTW * 3) + finetRTW;
u32 fullRoundDelay = CEIL((flyByTime + tDQSCK_max) / tCK_avg);
rdv = RL + fullRoundDelay + 19;
qpop = rdv - 16;
constexpr double TrimmerStepPs = 3.0;
constexpr double MaxTrimmerSteps = 96.0;
double tCkAvgPs = tCK_avg * 1000.0;
double tckDerated = tCkAvgPs * 0.85;
u32 derateStepCount = MIN(FLOOR(tckDerated / TrimmerStepPs), MaxTrimmerSteps);
double deratedNsDelay = (derateStepCount * TrimmerStepPs) / 1000.0;
u32 fullTripDerating = fullRoundDelay - CEIL((flyByTime + tDQSCK_max - deratedNsDelay) / tCK_avg);
u32 readEyeStart = FLOOR((flyByTime + 0.94) / tCK_avg) + RL;
/* Data valid window, quse aligns with the start of the read eye (probably). */
/* DQS needs to be logically and'ed with quse in order to be valid. */
quse = readEyeStart + fullTripDerating - 2;
quse_width = CEIL(((4.897 / tCK_avg) - FLOOR(2.538 / tCK_avg)) + 3.782);
einput_duration = FLOOR(9.936 / tCK_avg) + 5.0 + quse_width;
einput = quse - CEIL(9.928 / tCK_avg);
u32 qrst_duration = FLOOR(8.399 - tCK_avg);
u32 qrstLow = MAX(static_cast<s32>(einput - qrst_duration - 2), static_cast<s32>(0));
qrst = PACK_U32(qrst_duration, qrstLow);
ibdly = PACK_U32_NIBBLE_HIGH_BYTE_LOW(1, quse - qrst_duration - 2.0);
qsafe = (einput_duration + 3) + MAX(MIN(qrstLow * rdv, qrst_duration + qrst_duration), einput);
tW2P = (CEIL(WL * 1.7303) * 2) - 5;
tWTPDEN = CEIL(((1.803 / tCK_avg) + MAX(RL + (2.694 / tCK_avg), static_cast<double>(tW2P))) + (BL / 2));
const s32 wlToRl = static_cast<s32>(WL) - static_cast<s32>(RL);
tW2R = FLOOR(MAX((5.020 / tCK_avg) + 1.130, WL - MAX(-CEIL(0.258 * wlToRl), 1.964)) * 1.964) + WL - CEIL(tWTR / tCK_avg) + finetWTR;
wdv = WL;
wsv = WL - 2;
wev = 0xA + (WL - 14);
u32 obdlyHigh = 3 / FLOOR(MIN(static_cast<double>(2), tCK_avg * (WL - 7)));
u32 obdlyLow = MAX(WL - FLOOR((126.0 / CEIL(tCK_avg + 8.601))), 0.0);
obdly = PACK_U32_NIBBLE_HIGH_BYTE_LOW(obdlyHigh, obdlyLow);
pdex2rw = CEIL((CEIL(12.335 - tCK_avg) + (7.430 / tCK_avg) - CEIL(tCK_avg * 11.361)));
tCLKSTOP = FLOOR(MIN(8.488 / tCK_avg, 23.0)) + 8.0;
const double tMMRI = tRCD + (tCK_avg * 3);
pdex2mrr = tMMRI + 10;
CalculateReadTimings(freq, tCK_avg);
CalculateWriteTimings(tCK_avg);
CalculatePowerDownTimings(tCK_avg);
mrw2 = CalculateMrw2();
}
}
@@ -18,6 +18,7 @@
namespace ams::ldr::hoc::pcv::erista {
u8 GetNWrIndex();
void CalculateTimings(double tCK_avg, u32 freq);
}
@@ -46,6 +46,7 @@ namespace ams::ldr::hoc::pcv::erista {
#define WRITE_PARAM_ALL_REG(TABLE, PARAM, VALUE) \
TABLE->burst_regs.PARAM = VALUE; \
TABLE->shadow_regs_ca_train.PARAM = VALUE; \
TABLE->shadow_regs_quse_train.PARAM = VALUE; \
TABLE->shadow_regs_rdwr_train.PARAM = VALUE;
/* Ram power down */
@@ -109,28 +110,28 @@ namespace ams::ldr::hoc::pcv::erista {
/* Accept imperfection or prepare for suffering. */
// #if defined(AMS_BUILD_FOR_AUDITING) || defined(AMS_BUILD_FOR_DEBUGGING)
// WRITE_PARAM_ALL_REG(table, emc_einput, einput);
// WRITE_PARAM_ALL_REG(table, emc_einput_duration, einput_duration);
// WRITE_PARAM_ALL_REG(table, emc_obdly, obdly);
WRITE_PARAM_ALL_REG(table, emc_einput, einput);
WRITE_PARAM_ALL_REG(table, emc_einput_duration, einput_duration);
WRITE_PARAM_ALL_REG(table, emc_obdly, obdly);
WRITE_PARAM_ALL_REG(table, emc_ibdly, ibdly);
WRITE_PARAM_ALL_REG(table, emc_wdv_mask, wdv);
// WRITE_PARAM_ALL_REG(table, emc_quse_width, quse_width);
// WRITE_PARAM_ALL_REG(table, emc_quse, quse);
WRITE_PARAM_ALL_REG(table, emc_quse_width, quse_width);
WRITE_PARAM_ALL_REG(table, emc_quse, quse);
WRITE_PARAM_ALL_REG(table, emc_wdv, wdv);
WRITE_PARAM_ALL_REG(table, emc_wsv, wsv);
WRITE_PARAM_ALL_REG(table, emc_wev, wev);
// WRITE_PARAM_ALL_REG(table, emc_qrst, qrst);
// WRITE_PARAM_ALL_REG(table, emc_tr_qrst, qrst);
// WRITE_PARAM_ALL_REG(table, emc_qsafe, qsafe);
// WRITE_PARAM_ALL_REG(table, emc_tr_qsafe, qsafe);
// WRITE_PARAM_ALL_REG(table, emc_tr_qpop, qpop);
// WRITE_PARAM_ALL_REG(table, emc_qpop, qpop);
// WRITE_PARAM_ALL_REG(table, emc_rdv, rdv);
// WRITE_PARAM_ALL_REG(table, emc_tr_rdv_mask, rdv + 2);
// WRITE_PARAM_ALL_REG(table, emc_rdv_early, rdv - 2);
// WRITE_PARAM_ALL_REG(table, emc_rdv_early_mask, rdv);
// WRITE_PARAM_ALL_REG(table, emc_rdv_mask, rdv + 2);
// WRITE_PARAM_ALL_REG(table, emc_tr_rdv, rdv);
WRITE_PARAM_ALL_REG(table, emc_qrst, qrst);
WRITE_PARAM_ALL_REG(table, emc_tr_qrst, qrst);
WRITE_PARAM_ALL_REG(table, emc_qsafe, qsafe);
WRITE_PARAM_ALL_REG(table, emc_tr_qsafe, qsafe);
WRITE_PARAM_ALL_REG(table, emc_tr_qpop, qpop);
WRITE_PARAM_ALL_REG(table, emc_qpop, qpop);
WRITE_PARAM_ALL_REG(table, emc_rdv, rdv);
WRITE_PARAM_ALL_REG(table, emc_tr_rdv_mask, rdv + 2);
WRITE_PARAM_ALL_REG(table, emc_rdv_early, rdv - 2);
WRITE_PARAM_ALL_REG(table, emc_rdv_early_mask, rdv);
WRITE_PARAM_ALL_REG(table, emc_rdv_mask, rdv + 2);
WRITE_PARAM_ALL_REG(table, emc_tr_rdv, rdv);
table->emc_mrw2 = (table->emc_mrw2 & ~0xFFu) | static_cast<u32>(mrw2);
table->dram_timings.rl = RL;
// #endif
@@ -223,8 +224,7 @@ namespace ams::ldr::hoc::pcv::erista {
const u32 tRFCabStock = tRFC_values[0] * 2;
table->dram_timings.t_rfc = tRFCabStock;
table->emc_mrw2 = (table->emc_mrw2 & ~0xFFu) | static_cast<u32>(mrw2);
table->emc_mrw = (table->emc_mrw & ~0x70u) | 0x40; /* nWR */
table->emc_mrw = (table->emc_mrw & ~0x70u) | (GetNWrIndex() << 4);
table->emc_cfg_2 = 0x11083D;
table->min_volt = std::clamp(900 + (C.emcDvbShift * 25), 900, 1050);
}