improve timings
This commit is contained in:
1 parent
763ef09020
commit
bd6d615143
13 files changed
+566
-436
No files matched your search
+135
-150
@@ -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();
|
||||
}
|
||||
|
||||
}
|
||||
+1
@@ -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);
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user