in drm/amd/display/dc/dml/dcn30/display_mode_vba_30.c [3637:5339]
void dml30_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_lib)
{
struct vba_vars_st *v = &mode_lib->vba;
int MinPrefetchMode, MaxPrefetchMode;
int i;
unsigned int j, k, m;
bool EnoughWritebackUnits = true;
bool WritebackModeSupport = true;
bool ViewportExceedsSurface = false;
double MaxTotalVActiveRDBandwidth = 0;
long ReorderingBytes = 0;
bool NotUrgentLatencyHiding[DC__NUM_DPP__MAX] = { 0 };
/*MODE SUPPORT, VOLTAGE STATE AND SOC CONFIGURATION*/
CalculateMinAndMaxPrefetchMode(
mode_lib->vba.AllowDRAMSelfRefreshOrDRAMClockChangeInVblank,
&MinPrefetchMode, &MaxPrefetchMode);
/*Scale Ratio, taps Support Check*/
v->ScaleRatioAndTapsSupport = true;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->ScalerEnabled[k] == false
&& ((v->SourcePixelFormat[k] != dm_444_64
&& v->SourcePixelFormat[k] != dm_444_32
&& v->SourcePixelFormat[k] != dm_444_16
&& v->SourcePixelFormat[k] != dm_mono_16
&& v->SourcePixelFormat[k] != dm_mono_8
&& v->SourcePixelFormat[k] != dm_rgbe
&& v->SourcePixelFormat[k] != dm_rgbe_alpha)
|| v->HRatio[k] != 1.0
|| v->htaps[k] != 1.0
|| v->VRatio[k] != 1.0
|| v->vtaps[k] != 1.0)) {
v->ScaleRatioAndTapsSupport = false;
} else if (v->vtaps[k] < 1.0 || v->vtaps[k] > 8.0
|| v->htaps[k] < 1.0 || v->htaps[k] > 8.0
|| (v->htaps[k] > 1.0
&& (v->htaps[k] % 2) == 1)
|| v->HRatio[k] > v->MaxHSCLRatio
|| v->VRatio[k] > v->MaxVSCLRatio
|| v->HRatio[k] > v->htaps[k]
|| v->VRatio[k] > v->vtaps[k]
|| (v->SourcePixelFormat[k] != dm_444_64
&& v->SourcePixelFormat[k] != dm_444_32
&& v->SourcePixelFormat[k] != dm_444_16
&& v->SourcePixelFormat[k] != dm_mono_16
&& v->SourcePixelFormat[k] != dm_mono_8
&& v->SourcePixelFormat[k] != dm_rgbe
&& (v->VTAPsChroma[k] < 1
|| v->VTAPsChroma[k] > 8
|| v->HTAPsChroma[k] < 1
|| v->HTAPsChroma[k] > 8
|| (v->HTAPsChroma[k] > 1 && v->HTAPsChroma[k] % 2 == 1)
|| v->HRatioChroma[k] > v->MaxHSCLRatio
|| v->VRatioChroma[k] > v->MaxVSCLRatio
|| v->HRatioChroma[k] > v->HTAPsChroma[k]
|| v->VRatioChroma[k] > v->VTAPsChroma[k]))) {
v->ScaleRatioAndTapsSupport = false;
}
}
/*Source Format, Pixel Format and Scan Support Check*/
v->SourceFormatPixelAndScanSupport = true;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if ((v->SurfaceTiling[k] == dm_sw_linear && (!(v->SourceScan[k] != dm_vert) || v->DCCEnable[k] == true))
|| ((v->SurfaceTiling[k] == dm_sw_64kb_d || v->SurfaceTiling[k] == dm_sw_64kb_d_t || v->SurfaceTiling[k] == dm_sw_64kb_d_x)
&& !(v->SourcePixelFormat[k] == dm_444_64))) {
v->SourceFormatPixelAndScanSupport = false;
}
}
/*Bandwidth Support Check*/
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
CalculateBytePerPixelAnd256BBlockSizes(
v->SourcePixelFormat[k],
v->SurfaceTiling[k],
&v->BytePerPixelY[k],
&v->BytePerPixelC[k],
&v->BytePerPixelInDETY[k],
&v->BytePerPixelInDETC[k],
&v->Read256BlockHeightY[k],
&v->Read256BlockHeightC[k],
&v->Read256BlockWidthY[k],
&v->Read256BlockWidthC[k]);
}
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->SourceScan[k] != dm_vert) {
v->SwathWidthYSingleDPP[k] = v->ViewportWidth[k];
v->SwathWidthCSingleDPP[k] = v->ViewportWidthChroma[k];
} else {
v->SwathWidthYSingleDPP[k] = v->ViewportHeight[k];
v->SwathWidthCSingleDPP[k] = v->ViewportHeightChroma[k];
}
}
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
v->ReadBandwidthLuma[k] = v->SwathWidthYSingleDPP[k] * dml_ceil(v->BytePerPixelInDETY[k], 1.0) / (v->HTotal[k] / v->PixelClock[k]) * v->VRatio[k];
v->ReadBandwidthChroma[k] = v->SwathWidthYSingleDPP[k] / 2 * dml_ceil(v->BytePerPixelInDETC[k], 2.0) / (v->HTotal[k] / v->PixelClock[k]) * v->VRatio[k] / 2.0;
}
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->WritebackEnable[k] == true
&& v->WritebackPixelFormat[k] == dm_444_64) {
v->WriteBandwidth[k] = v->WritebackDestinationWidth[k]
* v->WritebackDestinationHeight[k]
/ (v->WritebackSourceHeight[k]
* v->HTotal[k]
/ v->PixelClock[k]) * 8.0;
} else if (v->WritebackEnable[k] == true) {
v->WriteBandwidth[k] = v->WritebackDestinationWidth[k]
* v->WritebackDestinationHeight[k]
/ (v->WritebackSourceHeight[k]
* v->HTotal[k]
/ v->PixelClock[k]) * 4.0;
} else {
v->WriteBandwidth[k] = 0.0;
}
}
/*Writeback Latency support check*/
v->WritebackLatencySupport = true;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->WritebackEnable[k] == true) {
if (v->WritebackConfiguration == dm_whole_buffer_for_single_stream_no_interleave ||
v->WritebackConfiguration == dm_whole_buffer_for_single_stream_interleave) {
if (v->WriteBandwidth[k]
> 2.0 * v->WritebackInterfaceBufferSize * 1024
/ v->WritebackLatency) {
v->WritebackLatencySupport = false;
}
} else {
if (v->WriteBandwidth[k]
> v->WritebackInterfaceBufferSize * 1024
/ v->WritebackLatency) {
v->WritebackLatencySupport = false;
}
}
}
}
/*Writeback Mode Support Check*/
v->TotalNumberOfActiveWriteback = 0;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->WritebackEnable[k] == true) {
v->TotalNumberOfActiveWriteback =
v->TotalNumberOfActiveWriteback + 1;
}
}
if (v->TotalNumberOfActiveWriteback > v->MaxNumWriteback) {
EnoughWritebackUnits = false;
}
if (!v->WritebackSupportInterleaveAndUsingWholeBufferForASingleStream
&& (v->WritebackConfiguration == dm_whole_buffer_for_single_stream_no_interleave
|| v->WritebackConfiguration == dm_whole_buffer_for_single_stream_interleave)) {
WritebackModeSupport = false;
}
if (v->WritebackConfiguration == dm_whole_buffer_for_single_stream_no_interleave && v->TotalNumberOfActiveWriteback > 1) {
WritebackModeSupport = false;
}
/*Writeback Scale Ratio and Taps Support Check*/
v->WritebackScaleRatioAndTapsSupport = true;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->WritebackEnable[k] == true) {
if (v->WritebackHRatio[k] > v->WritebackMaxHSCLRatio
|| v->WritebackVRatio[k]
> v->WritebackMaxVSCLRatio
|| v->WritebackHRatio[k]
< v->WritebackMinHSCLRatio
|| v->WritebackVRatio[k]
< v->WritebackMinVSCLRatio
|| v->WritebackHTaps[k]
> v->WritebackMaxHSCLTaps
|| v->WritebackVTaps[k]
> v->WritebackMaxVSCLTaps
|| v->WritebackHRatio[k]
> v->WritebackHTaps[k]
|| v->WritebackVRatio[k]
> v->WritebackVTaps[k]
|| (v->WritebackHTaps[k] > 2.0
&& ((v->WritebackHTaps[k] % 2)
== 1))) {
v->WritebackScaleRatioAndTapsSupport = false;
}
if (2.0 * v->WritebackDestinationWidth[k] * (v->WritebackVTaps[k] - 1) * 57 > v->WritebackLineBufferSize) {
v->WritebackScaleRatioAndTapsSupport = false;
}
}
}
/*Maximum DISPCLK/DPPCLK Support check*/
v->WritebackRequiredDISPCLK = 0.0;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->WritebackEnable[k] == true) {
v->WritebackRequiredDISPCLK = dml_max(v->WritebackRequiredDISPCLK,
dml30_CalculateWriteBackDISPCLK(
v->WritebackPixelFormat[k],
v->PixelClock[k],
v->WritebackHRatio[k],
v->WritebackVRatio[k],
v->WritebackHTaps[k],
v->WritebackVTaps[k],
v->WritebackSourceWidth[k],
v->WritebackDestinationWidth[k],
v->HTotal[k],
v->WritebackLineBufferSize));
}
}
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->HRatio[k] > 1.0) {
v->PSCL_FACTOR[k] = dml_min(v->MaxDCHUBToPSCLThroughput, v->MaxPSCLToLBThroughput * v->HRatio[k] / dml_ceil(v->htaps[k] / 6.0, 1.0));
} else {
v->PSCL_FACTOR[k] = dml_min(v->MaxDCHUBToPSCLThroughput, v->MaxPSCLToLBThroughput);
}
if (v->BytePerPixelC[k] == 0.0) {
v->PSCL_FACTOR_CHROMA[k] = 0.0;
v->MinDPPCLKUsingSingleDPP[k] = v->PixelClock[k]
* dml_max3(v->vtaps[k] / 6.0 * dml_min(1.0, v->HRatio[k]), v->HRatio[k] * v->VRatio[k] / v->PSCL_FACTOR[k], 1.0);
if ((v->htaps[k] > 6.0 || v->vtaps[k] > 6.0) && v->MinDPPCLKUsingSingleDPP[k] < 2.0 * v->PixelClock[k]) {
v->MinDPPCLKUsingSingleDPP[k] = 2.0 * v->PixelClock[k];
}
} else {
if (v->HRatioChroma[k] > 1.0) {
v->PSCL_FACTOR_CHROMA[k] = dml_min(v->MaxDCHUBToPSCLThroughput,
v->MaxPSCLToLBThroughput * v->HRatioChroma[k] / dml_ceil(v->HTAPsChroma[k] / 6.0, 1.0));
} else {
v->PSCL_FACTOR_CHROMA[k] = dml_min(v->MaxDCHUBToPSCLThroughput, v->MaxPSCLToLBThroughput);
}
v->MinDPPCLKUsingSingleDPP[k] = v->PixelClock[k] * dml_max5(v->vtaps[k] / 6.0 * dml_min(1.0, v->HRatio[k]),
v->HRatio[k] * v->VRatio[k] / v->PSCL_FACTOR[k],
v->VTAPsChroma[k] / 6.0 * dml_min(1.0, v->HRatioChroma[k]),
v->HRatioChroma[k] * v->VRatioChroma[k] / v->PSCL_FACTOR_CHROMA[k],
1.0);
if ((v->htaps[k] > 6.0 || v->vtaps[k] > 6.0 || v->HTAPsChroma[k] > 6.0 || v->VTAPsChroma[k] > 6.0)
&& v->MinDPPCLKUsingSingleDPP[k] < 2.0 * v->PixelClock[k]) {
v->MinDPPCLKUsingSingleDPP[k] = 2.0 * v->PixelClock[k];
}
}
}
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
int MaximumSwathWidthSupportLuma = 0;
int MaximumSwathWidthSupportChroma = 0;
if (v->SurfaceTiling[k] == dm_sw_linear) {
MaximumSwathWidthSupportLuma = 8192.0;
} else if (v->SourceScan[k] == dm_vert && v->BytePerPixelC[k] > 0) {
MaximumSwathWidthSupportLuma = 2880.0;
} else {
MaximumSwathWidthSupportLuma = 5760.0;
}
if (v->SourcePixelFormat[k] == dm_420_8 || v->SourcePixelFormat[k] == dm_420_10 || v->SourcePixelFormat[k] == dm_420_12) {
MaximumSwathWidthSupportChroma = MaximumSwathWidthSupportLuma / 2.0;
} else {
MaximumSwathWidthSupportChroma = MaximumSwathWidthSupportLuma;
}
v->MaximumSwathWidthInLineBufferLuma = v->LineBufferSize * dml_max(v->HRatio[k], 1.0) / v->LBBitPerPixel[k]
/ (v->vtaps[k] + dml_max(dml_ceil(v->VRatio[k], 1.0) - 2, 0.0));
if (v->BytePerPixelC[k] == 0.0) {
v->MaximumSwathWidthInLineBufferChroma = 0;
} else {
v->MaximumSwathWidthInLineBufferChroma = v->LineBufferSize * dml_max(v->HRatioChroma[k], 1.0) / v->LBBitPerPixel[k]
/ (v->VTAPsChroma[k] + dml_max(dml_ceil(v->VRatioChroma[k], 1.0) - 2, 0.0));
}
v->MaximumSwathWidthLuma[k] = dml_min(MaximumSwathWidthSupportLuma, v->MaximumSwathWidthInLineBufferLuma);
v->MaximumSwathWidthChroma[k] = dml_min(MaximumSwathWidthSupportChroma, v->MaximumSwathWidthInLineBufferChroma);
}
CalculateSwathAndDETConfiguration(
true,
v->NumberOfActivePlanes,
v->DETBufferSizeInKByte[0],
v->MaximumSwathWidthLuma,
v->MaximumSwathWidthChroma,
v->SourceScan,
v->SourcePixelFormat,
v->SurfaceTiling,
v->ViewportWidth,
v->ViewportHeight,
v->SurfaceWidthY,
v->SurfaceWidthC,
v->SurfaceHeightY,
v->SurfaceHeightC,
v->Read256BlockHeightY,
v->Read256BlockHeightC,
v->Read256BlockWidthY,
v->Read256BlockWidthC,
v->odm_combine_dummy,
v->BlendingAndTiming,
v->BytePerPixelY,
v->BytePerPixelC,
v->BytePerPixelInDETY,
v->BytePerPixelInDETC,
v->HActive,
v->HRatio,
v->HRatioChroma,
v->DPPPerPlane,
v->swath_width_luma_ub,
v->swath_width_chroma_ub,
v->SwathWidthY,
v->SwathWidthC,
v->SwathHeightY,
v->SwathHeightC,
v->DETBufferSizeY,
v->DETBufferSizeC,
v->SingleDPPViewportSizeSupportPerPlane,
&v->ViewportSizeSupport[0][0]);
for (i = 0; i < v->soc.num_states; i++) {
for (j = 0; j < 2; j++) {
v->MaxDispclkRoundedDownToDFSGranularity = RoundToDFSGranularityDown(v->MaxDispclk[i], v->DISPCLKDPPCLKVCOSpeed);
v->MaxDppclkRoundedDownToDFSGranularity = RoundToDFSGranularityDown(v->MaxDppclk[i], v->DISPCLKDPPCLKVCOSpeed);
v->RequiredDISPCLK[i][j] = 0.0;
v->DISPCLK_DPPCLK_Support[i][j] = true;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
v->PlaneRequiredDISPCLKWithoutODMCombine = v->PixelClock[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
* (1.0 + v->DISPCLKRampingMargin / 100.0);
if ((v->PlaneRequiredDISPCLKWithoutODMCombine >= v->MaxDispclk[i] && v->MaxDispclk[i] == v->MaxDispclk[mode_lib->soc.num_states - 1]
&& v->MaxDppclk[i] == v->MaxDppclk[mode_lib->soc.num_states - 1])) {
v->PlaneRequiredDISPCLKWithoutODMCombine = v->PixelClock[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
}
v->PlaneRequiredDISPCLKWithODMCombine2To1 = v->PixelClock[k] / 2 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
* (1 + v->DISPCLKRampingMargin / 100.0);
if ((v->PlaneRequiredDISPCLKWithODMCombine2To1 >= v->MaxDispclk[i] && v->MaxDispclk[i] == v->MaxDispclk[mode_lib->soc.num_states - 1]
&& v->MaxDppclk[i] == v->MaxDppclk[mode_lib->soc.num_states - 1])) {
v->PlaneRequiredDISPCLKWithODMCombine2To1 = v->PixelClock[k] / 2 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
}
v->PlaneRequiredDISPCLKWithODMCombine4To1 = v->PixelClock[k] / 4 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
* (1 + v->DISPCLKRampingMargin / 100.0);
if ((v->PlaneRequiredDISPCLKWithODMCombine4To1 >= v->MaxDispclk[i] && v->MaxDispclk[i] == v->MaxDispclk[mode_lib->soc.num_states - 1]
&& v->MaxDppclk[i] == v->MaxDppclk[mode_lib->soc.num_states - 1])) {
v->PlaneRequiredDISPCLKWithODMCombine4To1 = v->PixelClock[k] / 4 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
}
if (v->ODMCombinePolicy == dm_odm_combine_policy_none) {
v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_disabled;
v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithoutODMCombine;
} else if (v->ODMCombinePolicy == dm_odm_combine_policy_2to1) {
v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_2to1;
v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine2To1;
} else if (v->ODMCombinePolicy == dm_odm_combine_policy_4to1
|| v->PlaneRequiredDISPCLKWithODMCombine2To1 > v->MaxDispclkRoundedDownToDFSGranularity) {
v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_4to1;
v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine4To1;
} else if (v->PlaneRequiredDISPCLKWithoutODMCombine > v->MaxDispclkRoundedDownToDFSGranularity) {
v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_2to1;
v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine2To1;
} else {
v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_disabled;
v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithoutODMCombine;
}
if (v->DSCEnabled[k] && v->HActive[k] > DCN30_MAX_DSC_IMAGE_WIDTH
&& v->ODMCombineEnablePerState[i][k] != dm_odm_combine_mode_4to1) {
if (v->HActive[k] / 2 > DCN30_MAX_DSC_IMAGE_WIDTH) {
v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_4to1;
v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine4To1;
} else {
v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_2to1;
v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine2To1;
}
}
if (v->OutputFormat[k] == dm_420 && v->HActive[k] > DCN30_MAX_FMT_420_BUFFER_WIDTH
&& v->ODMCombineEnablePerState[i][k] != dm_odm_combine_mode_4to1) {
if (v->HActive[k] / 2 > DCN30_MAX_FMT_420_BUFFER_WIDTH) {
v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_4to1;
v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine4To1;
} else {
v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_2to1;
v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine2To1;
}
}
if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1) {
v->MPCCombine[i][j][k] = false;
v->NoOfDPP[i][j][k] = 4;
v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 4;
} else if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
v->MPCCombine[i][j][k] = false;
v->NoOfDPP[i][j][k] = 2;
v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 2;
} else if ((v->WhenToDoMPCCombine == dm_mpc_never
|| (v->MinDPPCLKUsingSingleDPP[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) <= v->MaxDppclkRoundedDownToDFSGranularity
&& v->SingleDPPViewportSizeSupportPerPlane[k] == true))) {
v->MPCCombine[i][j][k] = false;
v->NoOfDPP[i][j][k] = 1;
v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
} else {
v->MPCCombine[i][j][k] = true;
v->NoOfDPP[i][j][k] = 2;
v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 2.0;
}
v->RequiredDISPCLK[i][j] = dml_max(v->RequiredDISPCLK[i][j], v->PlaneRequiredDISPCLK);
if ((v->MinDPPCLKUsingSingleDPP[k] / v->NoOfDPP[i][j][k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
> v->MaxDppclkRoundedDownToDFSGranularity) || (v->PlaneRequiredDISPCLK > v->MaxDispclkRoundedDownToDFSGranularity)) {
v->DISPCLK_DPPCLK_Support[i][j] = false;
}
}
v->TotalNumberOfActiveDPP[i][j] = 0;
v->TotalNumberOfSingleDPPPlanes[i][j] = 0;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
v->TotalNumberOfActiveDPP[i][j] = v->TotalNumberOfActiveDPP[i][j] + v->NoOfDPP[i][j][k];
if (v->NoOfDPP[i][j][k] == 1)
v->TotalNumberOfSingleDPPPlanes[i][j] = v->TotalNumberOfSingleDPPPlanes[i][j] + 1;
}
if (j == 1 && v->WhenToDoMPCCombine != dm_mpc_never) {
while (!(v->TotalNumberOfActiveDPP[i][j] >= v->MaxNumDPP || v->TotalNumberOfSingleDPPPlanes[i][j] == 0)) {
double BWOfNonSplitPlaneOfMaximumBandwidth = 0;
unsigned int NumberOfNonSplitPlaneOfMaximumBandwidth = 0;
BWOfNonSplitPlaneOfMaximumBandwidth = 0;
NumberOfNonSplitPlaneOfMaximumBandwidth = 0;
for (k = 0; k < v->NumberOfActivePlanes; ++k) {
if (v->ReadBandwidthLuma[k] + v->ReadBandwidthChroma[k] > BWOfNonSplitPlaneOfMaximumBandwidth
&& v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_disabled && v->MPCCombine[i][j][k] == false) {
BWOfNonSplitPlaneOfMaximumBandwidth = v->ReadBandwidthLuma[k] + v->ReadBandwidthChroma[k];
NumberOfNonSplitPlaneOfMaximumBandwidth = k;
}
}
v->MPCCombine[i][j][NumberOfNonSplitPlaneOfMaximumBandwidth] = true;
v->NoOfDPP[i][j][NumberOfNonSplitPlaneOfMaximumBandwidth] = 2;
v->RequiredDPPCLK[i][j][NumberOfNonSplitPlaneOfMaximumBandwidth] = v->MinDPPCLKUsingSingleDPP[NumberOfNonSplitPlaneOfMaximumBandwidth]
* (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100) / 2;
v->TotalNumberOfActiveDPP[i][j] = v->TotalNumberOfActiveDPP[i][j] + 1;
v->TotalNumberOfSingleDPPPlanes[i][j] = v->TotalNumberOfSingleDPPPlanes[i][j] - 1;
}
}
if (v->TotalNumberOfActiveDPP[i][j] > v->MaxNumDPP) {
v->RequiredDISPCLK[i][j] = 0.0;
v->DISPCLK_DPPCLK_Support[i][j] = true;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_disabled;
if (v->SingleDPPViewportSizeSupportPerPlane[k] == false && v->WhenToDoMPCCombine != dm_mpc_never) {
v->MPCCombine[i][j][k] = true;
v->NoOfDPP[i][j][k] = 2;
v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 2.0;
} else {
v->MPCCombine[i][j][k] = false;
v->NoOfDPP[i][j][k] = 1;
v->RequiredDPPCLK[i][j][k] = v->MinDPPCLKUsingSingleDPP[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
}
if (!(v->MaxDispclk[i] == v->MaxDispclk[v->soc.num_states - 1] && v->MaxDppclk[i] == v->MaxDppclk[v->soc.num_states - 1])) {
v->PlaneRequiredDISPCLK = v->PixelClock[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
* (1.0 + v->DISPCLKRampingMargin / 100.0);
} else {
v->PlaneRequiredDISPCLK = v->PixelClock[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
}
v->RequiredDISPCLK[i][j] = dml_max(v->RequiredDISPCLK[i][j], v->PlaneRequiredDISPCLK);
if ((v->MinDPPCLKUsingSingleDPP[k] / v->NoOfDPP[i][j][k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
> v->MaxDppclkRoundedDownToDFSGranularity) || (v->PlaneRequiredDISPCLK > v->MaxDispclkRoundedDownToDFSGranularity)) {
v->DISPCLK_DPPCLK_Support[i][j] = false;
}
}
v->TotalNumberOfActiveDPP[i][j] = 0.0;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
v->TotalNumberOfActiveDPP[i][j] = v->TotalNumberOfActiveDPP[i][j] + v->NoOfDPP[i][j][k];
}
}
v->RequiredDISPCLK[i][j] = dml_max(v->RequiredDISPCLK[i][j], v->WritebackRequiredDISPCLK);
if (v->MaxDispclkRoundedDownToDFSGranularity < v->WritebackRequiredDISPCLK) {
v->DISPCLK_DPPCLK_Support[i][j] = false;
}
}
}
/*Total Available Pipes Support Check*/
for (i = 0; i < v->soc.num_states; i++) {
for (j = 0; j < 2; j++) {
if (v->TotalNumberOfActiveDPP[i][j] <= v->MaxNumDPP) {
v->TotalAvailablePipesSupport[i][j] = true;
} else {
v->TotalAvailablePipesSupport[i][j] = false;
}
}
}
/*Display IO and DSC Support Check*/
v->NonsupportedDSCInputBPC = false;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (!(v->DSCInputBitPerComponent[k] == 12.0
|| v->DSCInputBitPerComponent[k] == 10.0
|| v->DSCInputBitPerComponent[k] == 8.0)) {
v->NonsupportedDSCInputBPC = true;
}
}
/*Number Of DSC Slices*/
for (k = 0; k < v->NumberOfActivePlanes; ++k) {
if (v->BlendingAndTiming[k] == k) {
if (v->PixelClockBackEnd[k] > 3200) {
v->NumberOfDSCSlices[k] = dml_ceil(v->PixelClockBackEnd[k] / 400.0, 4.0);
} else if (v->PixelClockBackEnd[k] > 1360) {
v->NumberOfDSCSlices[k] = 8;
} else if (v->PixelClockBackEnd[k] > 680) {
v->NumberOfDSCSlices[k] = 4;
} else if (v->PixelClockBackEnd[k] > 340) {
v->NumberOfDSCSlices[k] = 2;
} else {
v->NumberOfDSCSlices[k] = 1;
}
} else {
v->NumberOfDSCSlices[k] = 0;
}
}
for (i = 0; i < v->soc.num_states; i++) {
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
v->RequiresDSC[i][k] = false;
v->RequiresFEC[i][k] = false;
if (v->BlendingAndTiming[k] == k) {
if (v->Output[k] == dm_hdmi) {
v->RequiresDSC[i][k] = false;
v->RequiresFEC[i][k] = false;
v->OutputBppPerState[i][k] = TruncToValidBPP(
dml_min(600.0, v->PHYCLKPerState[i]) * 10,
3,
v->HTotal[k],
v->HActive[k],
v->PixelClockBackEnd[k],
v->ForcedOutputLinkBPP[k],
false,
v->Output[k],
v->OutputFormat[k],
v->DSCInputBitPerComponent[k],
v->NumberOfDSCSlices[k],
v->AudioSampleRate[k],
v->AudioSampleLayout[k],
v->ODMCombineEnablePerState[i][k]);
} else if (v->Output[k] == dm_dp || v->Output[k] == dm_edp) {
if (v->DSCEnable[k] == true) {
v->RequiresDSC[i][k] = true;
v->LinkDSCEnable = true;
if (v->Output[k] == dm_dp) {
v->RequiresFEC[i][k] = true;
} else {
v->RequiresFEC[i][k] = false;
}
} else {
v->RequiresDSC[i][k] = false;
v->LinkDSCEnable = false;
v->RequiresFEC[i][k] = false;
}
v->Outbpp = BPP_INVALID;
if (v->PHYCLKPerState[i] >= 270.0) {
v->Outbpp = TruncToValidBPP(
(1.0 - v->Downspreading / 100.0) * 2700,
v->OutputLinkDPLanes[k],
v->HTotal[k],
v->HActive[k],
v->PixelClockBackEnd[k],
v->ForcedOutputLinkBPP[k],
v->LinkDSCEnable,
v->Output[k],
v->OutputFormat[k],
v->DSCInputBitPerComponent[k],
v->NumberOfDSCSlices[k],
v->AudioSampleRate[k],
v->AudioSampleLayout[k],
v->ODMCombineEnablePerState[i][k]);
v->OutputBppPerState[i][k] = v->Outbpp;
// TODO: Need some other way to handle this nonsense
// v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR"
}
if (v->Outbpp == BPP_INVALID && v->PHYCLKPerState[i] >= 540.0) {
v->Outbpp = TruncToValidBPP(
(1.0 - v->Downspreading / 100.0) * 5400,
v->OutputLinkDPLanes[k],
v->HTotal[k],
v->HActive[k],
v->PixelClockBackEnd[k],
v->ForcedOutputLinkBPP[k],
v->LinkDSCEnable,
v->Output[k],
v->OutputFormat[k],
v->DSCInputBitPerComponent[k],
v->NumberOfDSCSlices[k],
v->AudioSampleRate[k],
v->AudioSampleLayout[k],
v->ODMCombineEnablePerState[i][k]);
v->OutputBppPerState[i][k] = v->Outbpp;
// TODO: Need some other way to handle this nonsense
// v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR2"
}
if (v->Outbpp == BPP_INVALID && v->PHYCLKPerState[i] >= 810.0) {
v->Outbpp = TruncToValidBPP(
(1.0 - v->Downspreading / 100.0) * 8100,
v->OutputLinkDPLanes[k],
v->HTotal[k],
v->HActive[k],
v->PixelClockBackEnd[k],
v->ForcedOutputLinkBPP[k],
v->LinkDSCEnable,
v->Output[k],
v->OutputFormat[k],
v->DSCInputBitPerComponent[k],
v->NumberOfDSCSlices[k],
v->AudioSampleRate[k],
v->AudioSampleLayout[k],
v->ODMCombineEnablePerState[i][k]);
if (v->Outbpp == BPP_INVALID && v->ForcedOutputLinkBPP[k] == 0) {
//if (v->Outbpp == BPP_INVALID && v->DSCEnabled[k] == dm_dsc_enable_only_if_necessary && v->ForcedOutputLinkBPP[k] == 0) {
v->RequiresDSC[i][k] = true;
v->LinkDSCEnable = true;
if (v->Output[k] == dm_dp) {
v->RequiresFEC[i][k] = true;
}
v->Outbpp = TruncToValidBPP(
(1.0 - v->Downspreading / 100.0) * 8100,
v->OutputLinkDPLanes[k],
v->HTotal[k],
v->HActive[k],
v->PixelClockBackEnd[k],
v->ForcedOutputLinkBPP[k],
v->LinkDSCEnable,
v->Output[k],
v->OutputFormat[k],
v->DSCInputBitPerComponent[k],
v->NumberOfDSCSlices[k],
v->AudioSampleRate[k],
v->AudioSampleLayout[k],
v->ODMCombineEnablePerState[i][k]);
}
v->OutputBppPerState[i][k] = v->Outbpp;
// TODO: Need some other way to handle this nonsense
// v->OutputTypeAndRatePerState[i][k] = v->Output[k] & " HBR3"
}
}
} else {
v->OutputBppPerState[i][k] = 0;
}
}
}
for (i = 0; i < v->soc.num_states; i++) {
v->DIOSupport[i] = true;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (!v->skip_dio_check[k] && v->BlendingAndTiming[k] == k && (v->Output[k] == dm_dp || v->Output[k] == dm_edp || v->Output[k] == dm_hdmi)
&& (v->OutputBppPerState[i][k] == 0
|| (v->OutputFormat[k] == dm_420 && v->Interlace[k] == true && v->ProgressiveToInterlaceUnitInOPP == true))) {
v->DIOSupport[i] = false;
}
}
}
for (i = 0; i < v->soc.num_states; ++i) {
v->ODMCombine4To1SupportCheckOK[i] = true;
for (k = 0; k < v->NumberOfActivePlanes; ++k) {
if (v->BlendingAndTiming[k] == k && v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1
&& (v->ODMCombine4To1Supported == false || v->Output[k] == dm_dp || v->Output[k] == dm_edp || v->Output[k] == dm_hdmi)) {
v->ODMCombine4To1SupportCheckOK[i] = false;
}
}
}
/* Skip dscclk validation: as long as dispclk is supported, dscclk is also implicitly supported */
for (i = 0; i < v->soc.num_states; i++) {
v->NotEnoughDSCUnits[i] = false;
v->TotalDSCUnitsRequired = 0.0;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->RequiresDSC[i][k] == true) {
if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1) {
v->TotalDSCUnitsRequired = v->TotalDSCUnitsRequired + 4.0;
} else if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
v->TotalDSCUnitsRequired = v->TotalDSCUnitsRequired + 2.0;
} else {
v->TotalDSCUnitsRequired = v->TotalDSCUnitsRequired + 1.0;
}
}
}
if (v->TotalDSCUnitsRequired > v->NumberOfDSC) {
v->NotEnoughDSCUnits[i] = true;
}
}
/*DSC Delay per state*/
for (i = 0; i < v->soc.num_states; i++) {
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->OutputBppPerState[i][k] == BPP_INVALID) {
v->BPP = 0.0;
} else {
v->BPP = v->OutputBppPerState[i][k];
}
if (v->RequiresDSC[i][k] == true && v->BPP != 0.0) {
if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_disabled) {
v->DSCDelayPerState[i][k] = dscceComputeDelay(
v->DSCInputBitPerComponent[k],
v->BPP,
dml_ceil(1.0 * v->HActive[k] / v->NumberOfDSCSlices[k], 1.0),
v->NumberOfDSCSlices[k],
v->OutputFormat[k],
v->Output[k]) + dscComputeDelay(v->OutputFormat[k], v->Output[k]);
} else if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
v->DSCDelayPerState[i][k] = 2.0
* dscceComputeDelay(
v->DSCInputBitPerComponent[k],
v->BPP,
dml_ceil(1.0 * v->HActive[k] / v->NumberOfDSCSlices[k], 1.0),
v->NumberOfDSCSlices[k] / 2,
v->OutputFormat[k],
v->Output[k]) + dscComputeDelay(v->OutputFormat[k], v->Output[k]);
} else {
v->DSCDelayPerState[i][k] = 4.0
* (dscceComputeDelay(
v->DSCInputBitPerComponent[k],
v->BPP,
dml_ceil(1.0 * v->HActive[k] / v->NumberOfDSCSlices[k], 1.0),
v->NumberOfDSCSlices[k] / 4,
v->OutputFormat[k],
v->Output[k]) + dscComputeDelay(v->OutputFormat[k], v->Output[k]));
}
v->DSCDelayPerState[i][k] = v->DSCDelayPerState[i][k] * v->PixelClock[k] / v->PixelClockBackEnd[k];
} else {
v->DSCDelayPerState[i][k] = 0.0;
}
}
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
for (m = 0; m <= v->NumberOfActivePlanes - 1; m++) {
if (v->BlendingAndTiming[k] == m && v->RequiresDSC[i][m] == true) {
v->DSCDelayPerState[i][k] = v->DSCDelayPerState[i][m];
}
}
}
}
//Calculate Swath, DET Configuration, DCFCLKDeepSleep
//
for (i = 0; i < mode_lib->soc.num_states; ++i) {
for (j = 0; j <= 1; ++j) {
for (k = 0; k < v->NumberOfActivePlanes; ++k) {
v->RequiredDPPCLKThisState[k] = v->RequiredDPPCLK[i][j][k];
v->NoOfDPPThisState[k] = v->NoOfDPP[i][j][k];
v->ODMCombineEnableThisState[k] = v->ODMCombineEnablePerState[i][k];
}
CalculateSwathAndDETConfiguration(
false,
v->NumberOfActivePlanes,
v->DETBufferSizeInKByte[0],
v->MaximumSwathWidthLuma,
v->MaximumSwathWidthChroma,
v->SourceScan,
v->SourcePixelFormat,
v->SurfaceTiling,
v->ViewportWidth,
v->ViewportHeight,
v->SurfaceWidthY,
v->SurfaceWidthC,
v->SurfaceHeightY,
v->SurfaceHeightC,
v->Read256BlockHeightY,
v->Read256BlockHeightC,
v->Read256BlockWidthY,
v->Read256BlockWidthC,
v->ODMCombineEnableThisState,
v->BlendingAndTiming,
v->BytePerPixelY,
v->BytePerPixelC,
v->BytePerPixelInDETY,
v->BytePerPixelInDETC,
v->HActive,
v->HRatio,
v->HRatioChroma,
v->NoOfDPPThisState,
v->swath_width_luma_ub_this_state,
v->swath_width_chroma_ub_this_state,
v->SwathWidthYThisState,
v->SwathWidthCThisState,
v->SwathHeightYThisState,
v->SwathHeightCThisState,
v->DETBufferSizeYThisState,
v->DETBufferSizeCThisState,
v->dummystring,
&v->ViewportSizeSupport[i][j]);
for (k = 0; k < v->NumberOfActivePlanes; ++k) {
v->swath_width_luma_ub_all_states[i][j][k] = v->swath_width_luma_ub_this_state[k];
v->swath_width_chroma_ub_all_states[i][j][k] = v->swath_width_chroma_ub_this_state[k];
v->SwathWidthYAllStates[i][j][k] = v->SwathWidthYThisState[k];
v->SwathWidthCAllStates[i][j][k] = v->SwathWidthCThisState[k];
v->SwathHeightYAllStates[i][j][k] = v->SwathHeightYThisState[k];
v->SwathHeightCAllStates[i][j][k] = v->SwathHeightCThisState[k];
v->DETBufferSizeYAllStates[i][j][k] = v->DETBufferSizeYThisState[k];
v->DETBufferSizeCAllStates[i][j][k] = v->DETBufferSizeCThisState[k];
}
}
}
for (k = 0; k < v->NumberOfActivePlanes; ++k) {
v->cursor_bw[k] = v->NumberOfCursors[k] * v->CursorWidth[k][0] * v->CursorBPP[k][0] / 8.0 / (v->HTotal[k] / v->PixelClock[k]) * v->VRatio[k];
}
for (i = 0; i < v->soc.num_states; i++) {
for (j = 0; j < 2; j++) {
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
v->swath_width_luma_ub_this_state[k] = v->swath_width_luma_ub_all_states[i][j][k];
v->swath_width_chroma_ub_this_state[k] = v->swath_width_chroma_ub_all_states[i][j][k];
v->SwathWidthYThisState[k] = v->SwathWidthYAllStates[i][j][k];
v->SwathWidthCThisState[k] = v->SwathWidthCAllStates[i][j][k];
v->SwathHeightYThisState[k] = v->SwathHeightYAllStates[i][j][k];
v->SwathHeightCThisState[k] = v->SwathHeightCAllStates[i][j][k];
v->DETBufferSizeYThisState[k] = v->DETBufferSizeYAllStates[i][j][k];
v->DETBufferSizeCThisState[k] = v->DETBufferSizeCAllStates[i][j][k];
}
v->TotalNumberOfDCCActiveDPP[i][j] = 0;
for (k = 0; k < v->NumberOfActivePlanes; ++k) {
if (v->DCCEnable[k] == true) {
v->TotalNumberOfDCCActiveDPP[i][j] = v->TotalNumberOfDCCActiveDPP[i][j] + v->NoOfDPP[i][j][k];
}
}
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->SourcePixelFormat[k] == dm_420_8 || v->SourcePixelFormat[k] == dm_420_10 || v->SourcePixelFormat[k] == dm_420_12
|| v->SourcePixelFormat[k] == dm_rgbe_alpha) {
if ((v->SourcePixelFormat[k] == dm_420_10 || v->SourcePixelFormat[k] == dm_420_12) && v->SourceScan[k] != dm_vert) {
v->PTEBufferSizeInRequestsForLuma = (v->PTEBufferSizeInRequestsLuma + v->PTEBufferSizeInRequestsChroma) / 2;
v->PTEBufferSizeInRequestsForChroma = v->PTEBufferSizeInRequestsForLuma;
} else {
v->PTEBufferSizeInRequestsForLuma = v->PTEBufferSizeInRequestsLuma;
v->PTEBufferSizeInRequestsForChroma = v->PTEBufferSizeInRequestsChroma;
}
v->PDEAndMetaPTEBytesPerFrameC = CalculateVMAndRowBytes(
mode_lib,
v->DCCEnable[k],
v->Read256BlockHeightC[k],
v->Read256BlockWidthY[k],
v->SourcePixelFormat[k],
v->SurfaceTiling[k],
v->BytePerPixelC[k],
v->SourceScan[k],
v->SwathWidthCThisState[k],
v->ViewportHeightChroma[k],
v->GPUVMEnable,
v->HostVMEnable,
v->HostVMMaxNonCachedPageTableLevels,
v->GPUVMMinPageSize,
v->HostVMMinPageSize,
v->PTEBufferSizeInRequestsForChroma,
v->PitchC[k],
0.0,
&v->MacroTileWidthC[k],
&v->MetaRowBytesC,
&v->DPTEBytesPerRowC,
&v->PTEBufferSizeNotExceededC[i][j][k],
&v->dummyinteger7,
&v->dpte_row_height_chroma[k],
&v->dummyinteger28,
&v->dummyinteger26,
&v->dummyinteger23,
&v->meta_row_height_chroma[k],
&v->dummyinteger8,
&v->dummyinteger9,
&v->dummyinteger19,
&v->dummyinteger20,
&v->dummyinteger17,
&v->dummyinteger10,
&v->dummyinteger11);
v->PrefetchLinesC[i][j][k] = CalculatePrefetchSourceLines(
mode_lib,
v->VRatioChroma[k],
v->VTAPsChroma[k],
v->Interlace[k],
v->ProgressiveToInterlaceUnitInOPP,
v->SwathHeightCThisState[k],
v->ViewportYStartC[k],
&v->PrefillC[k],
&v->MaxNumSwC[k]);
} else {
v->PTEBufferSizeInRequestsForLuma = v->PTEBufferSizeInRequestsLuma + v->PTEBufferSizeInRequestsChroma;
v->PTEBufferSizeInRequestsForChroma = 0;
v->PDEAndMetaPTEBytesPerFrameC = 0.0;
v->MetaRowBytesC = 0.0;
v->DPTEBytesPerRowC = 0.0;
v->PrefetchLinesC[i][j][k] = 0.0;
v->PTEBufferSizeNotExceededC[i][j][k] = true;
}
v->PDEAndMetaPTEBytesPerFrameY = CalculateVMAndRowBytes(
mode_lib,
v->DCCEnable[k],
v->Read256BlockHeightY[k],
v->Read256BlockWidthY[k],
v->SourcePixelFormat[k],
v->SurfaceTiling[k],
v->BytePerPixelY[k],
v->SourceScan[k],
v->SwathWidthYThisState[k],
v->ViewportHeight[k],
v->GPUVMEnable,
v->HostVMEnable,
v->HostVMMaxNonCachedPageTableLevels,
v->GPUVMMinPageSize,
v->HostVMMinPageSize,
v->PTEBufferSizeInRequestsForLuma,
v->PitchY[k],
v->DCCMetaPitchY[k],
&v->MacroTileWidthY[k],
&v->MetaRowBytesY,
&v->DPTEBytesPerRowY,
&v->PTEBufferSizeNotExceededY[i][j][k],
v->dummyinteger4,
&v->dpte_row_height[k],
&v->dummyinteger29,
&v->dummyinteger27,
&v->dummyinteger24,
&v->meta_row_height[k],
&v->dummyinteger25,
&v->dpte_group_bytes[k],
&v->dummyinteger21,
&v->dummyinteger22,
&v->dummyinteger18,
&v->dummyinteger5,
&v->dummyinteger6);
v->PrefetchLinesY[i][j][k] = CalculatePrefetchSourceLines(
mode_lib,
v->VRatio[k],
v->vtaps[k],
v->Interlace[k],
v->ProgressiveToInterlaceUnitInOPP,
v->SwathHeightYThisState[k],
v->ViewportYStartY[k],
&v->PrefillY[k],
&v->MaxNumSwY[k]);
v->PDEAndMetaPTEBytesPerFrame[i][j][k] = v->PDEAndMetaPTEBytesPerFrameY + v->PDEAndMetaPTEBytesPerFrameC;
v->MetaRowBytes[i][j][k] = v->MetaRowBytesY + v->MetaRowBytesC;
v->DPTEBytesPerRow[i][j][k] = v->DPTEBytesPerRowY + v->DPTEBytesPerRowC;
CalculateRowBandwidth(
v->GPUVMEnable,
v->SourcePixelFormat[k],
v->VRatio[k],
v->VRatioChroma[k],
v->DCCEnable[k],
v->HTotal[k] / v->PixelClock[k],
v->MetaRowBytesY,
v->MetaRowBytesC,
v->meta_row_height[k],
v->meta_row_height_chroma[k],
v->DPTEBytesPerRowY,
v->DPTEBytesPerRowC,
v->dpte_row_height[k],
v->dpte_row_height_chroma[k],
&v->meta_row_bandwidth[i][j][k],
&v->dpte_row_bandwidth[i][j][k]);
}
v->UrgLatency[i] = CalculateUrgentLatency(
v->UrgentLatencyPixelDataOnly,
v->UrgentLatencyPixelMixedWithVMData,
v->UrgentLatencyVMDataOnly,
v->DoUrgentLatencyAdjustment,
v->UrgentLatencyAdjustmentFabricClockComponent,
v->UrgentLatencyAdjustmentFabricClockReference,
v->FabricClockPerState[i]);
for (k = 0; k < v->NumberOfActivePlanes; ++k) {
CalculateUrgentBurstFactor(
v->swath_width_luma_ub_this_state[k],
v->swath_width_chroma_ub_this_state[k],
v->DETBufferSizeInKByte[0],
v->SwathHeightYThisState[k],
v->SwathHeightCThisState[k],
v->HTotal[k] / v->PixelClock[k],
v->UrgLatency[i],
v->CursorBufferSize,
v->CursorWidth[k][0],
v->CursorBPP[k][0],
v->VRatio[k],
v->VRatioChroma[k],
v->BytePerPixelInDETY[k],
v->BytePerPixelInDETC[k],
v->DETBufferSizeYThisState[k],
v->DETBufferSizeCThisState[k],
&v->UrgentBurstFactorCursor[k],
&v->UrgentBurstFactorLuma[k],
&v->UrgentBurstFactorChroma[k],
&NotUrgentLatencyHiding[k]);
}
v->NotUrgentLatencyHiding[i][j] = false;
for (k = 0; k < v->NumberOfActivePlanes; ++k) {
if (NotUrgentLatencyHiding[k]) {
v->NotUrgentLatencyHiding[i][j] = true;
}
}
for (k = 0; k < v->NumberOfActivePlanes; ++k) {
v->VActivePixelBandwidth[i][j][k] = v->ReadBandwidthLuma[k] * v->UrgentBurstFactorLuma[k]
+ v->ReadBandwidthChroma[k] * v->UrgentBurstFactorChroma[k];
v->VActiveCursorBandwidth[i][j][k] = v->cursor_bw[k] * v->UrgentBurstFactorCursor[k];
}
v->TotalVActivePixelBandwidth[i][j] = 0;
v->TotalVActiveCursorBandwidth[i][j] = 0;
v->TotalMetaRowBandwidth[i][j] = 0;
v->TotalDPTERowBandwidth[i][j] = 0;
for (k = 0; k < v->NumberOfActivePlanes; ++k) {
v->TotalVActivePixelBandwidth[i][j] = v->TotalVActivePixelBandwidth[i][j] + v->VActivePixelBandwidth[i][j][k];
v->TotalVActiveCursorBandwidth[i][j] = v->TotalVActiveCursorBandwidth[i][j] + v->VActiveCursorBandwidth[i][j][k];
v->TotalMetaRowBandwidth[i][j] = v->TotalMetaRowBandwidth[i][j] + v->NoOfDPP[i][j][k] * v->meta_row_bandwidth[i][j][k];
v->TotalDPTERowBandwidth[i][j] = v->TotalDPTERowBandwidth[i][j] + v->NoOfDPP[i][j][k] * v->dpte_row_bandwidth[i][j][k];
}
CalculateDCFCLKDeepSleep(
mode_lib,
v->NumberOfActivePlanes,
v->BytePerPixelY,
v->BytePerPixelC,
v->VRatio,
v->VRatioChroma,
v->SwathWidthYThisState,
v->SwathWidthCThisState,
v->NoOfDPPThisState,
v->HRatio,
v->HRatioChroma,
v->PixelClock,
v->PSCL_FACTOR,
v->PSCL_FACTOR_CHROMA,
v->RequiredDPPCLKThisState,
v->ReadBandwidthLuma,
v->ReadBandwidthChroma,
v->ReturnBusWidth,
&v->ProjectedDCFCLKDeepSleep[i][j]);
}
}
//Calculate Return BW
for (i = 0; i < mode_lib->soc.num_states; ++i) {
for (j = 0; j <= 1; ++j) {
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->BlendingAndTiming[k] == k) {
if (v->WritebackEnable[k] == true) {
v->WritebackDelayTime[k] = v->WritebackLatency
+ CalculateWriteBackDelay(
v->WritebackPixelFormat[k],
v->WritebackHRatio[k],
v->WritebackVRatio[k],
v->WritebackVTaps[k],
v->WritebackDestinationWidth[k],
v->WritebackDestinationHeight[k],
v->WritebackSourceHeight[k],
v->HTotal[k]) / v->RequiredDISPCLK[i][j];
} else {
v->WritebackDelayTime[k] = 0.0;
}
for (m = 0; m <= v->NumberOfActivePlanes - 1; m++) {
if (v->BlendingAndTiming[m] == k && v->WritebackEnable[m] == true) {
v->WritebackDelayTime[k] = dml_max(
v->WritebackDelayTime[k],
v->WritebackLatency
+ CalculateWriteBackDelay(
v->WritebackPixelFormat[m],
v->WritebackHRatio[m],
v->WritebackVRatio[m],
v->WritebackVTaps[m],
v->WritebackDestinationWidth[m],
v->WritebackDestinationHeight[m],
v->WritebackSourceHeight[m],
v->HTotal[m]) / v->RequiredDISPCLK[i][j]);
}
}
}
}
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
for (m = 0; m <= v->NumberOfActivePlanes - 1; m++) {
if (v->BlendingAndTiming[k] == m) {
v->WritebackDelayTime[k] = v->WritebackDelayTime[m];
}
}
}
v->MaxMaxVStartup[i][j] = 0;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
v->MaximumVStartup[i][j][k] = v->VTotal[k] - v->VActive[k]
- dml_max(1.0, dml_ceil(1.0 * v->WritebackDelayTime[k] / (v->HTotal[k] / v->PixelClock[k]), 1.0));
v->MaxMaxVStartup[i][j] = dml_max(v->MaxMaxVStartup[i][j], v->MaximumVStartup[i][j][k]);
}
}
}
ReorderingBytes = v->NumberOfChannels
* dml_max3(
v->UrgentOutOfOrderReturnPerChannelPixelDataOnly,
v->UrgentOutOfOrderReturnPerChannelPixelMixedWithVMData,
v->UrgentOutOfOrderReturnPerChannelVMDataOnly);
v->FinalDRAMClockChangeLatency = (v->DRAMClockChangeLatencyOverride > 0 ? v->DRAMClockChangeLatencyOverride : v->DRAMClockChangeLatency);
for (i = 0; i < mode_lib->soc.num_states; ++i) {
for (j = 0; j <= 1; ++j) {
v->DCFCLKState[i][j] = v->DCFCLKPerState[i];
}
}
if (v->UseMinimumRequiredDCFCLK == true) {
UseMinimumDCFCLK(
mode_lib,
v->MaxInterDCNTileRepeaters,
MaxPrefetchMode,
v->FinalDRAMClockChangeLatency,
v->SREnterPlusExitTime,
v->ReturnBusWidth,
v->RoundTripPingLatencyCycles,
ReorderingBytes,
v->PixelChunkSizeInKByte,
v->MetaChunkSize,
v->GPUVMEnable,
v->GPUVMMaxPageTableLevels,
v->HostVMEnable,
v->NumberOfActivePlanes,
v->HostVMMinPageSize,
v->HostVMMaxNonCachedPageTableLevels,
v->DynamicMetadataVMEnabled,
v->ImmediateFlipRequirement[0],
v->ProgressiveToInterlaceUnitInOPP,
v->MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation,
v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly,
v->VTotal,
v->VActive,
v->DynamicMetadataTransmittedBytes,
v->DynamicMetadataLinesBeforeActiveRequired,
v->Interlace,
v->RequiredDPPCLK,
v->RequiredDISPCLK,
v->UrgLatency,
v->NoOfDPP,
v->ProjectedDCFCLKDeepSleep,
v->MaximumVStartup,
v->TotalVActivePixelBandwidth,
v->TotalVActiveCursorBandwidth,
v->TotalMetaRowBandwidth,
v->TotalDPTERowBandwidth,
v->TotalNumberOfActiveDPP,
v->TotalNumberOfDCCActiveDPP,
v->dpte_group_bytes,
v->PrefetchLinesY,
v->PrefetchLinesC,
v->swath_width_luma_ub_all_states,
v->swath_width_chroma_ub_all_states,
v->BytePerPixelY,
v->BytePerPixelC,
v->HTotal,
v->PixelClock,
v->PDEAndMetaPTEBytesPerFrame,
v->DPTEBytesPerRow,
v->MetaRowBytes,
v->DynamicMetadataEnable,
v->VActivePixelBandwidth,
v->VActiveCursorBandwidth,
v->ReadBandwidthLuma,
v->ReadBandwidthChroma,
v->DCFCLKPerState,
v->DCFCLKState);
if (v->ClampMinDCFCLK) {
/* Clamp calculated values to actual minimum */
for (i = 0; i < mode_lib->soc.num_states; ++i) {
for (j = 0; j <= 1; ++j) {
if (v->DCFCLKState[i][j] < mode_lib->soc.min_dcfclk) {
v->DCFCLKState[i][j] = mode_lib->soc.min_dcfclk;
}
}
}
}
}
for (i = 0; i < mode_lib->soc.num_states; ++i) {
for (j = 0; j <= 1; ++j) {
v->IdealSDPPortBandwidthPerState[i][j] = dml_min3(
v->ReturnBusWidth * v->DCFCLKState[i][j],
v->DRAMSpeedPerState[i] * v->NumberOfChannels * v->DRAMChannelWidth,
v->FabricClockPerState[i] * v->FabricDatapathToDCNDataReturn);
if (v->HostVMEnable != true) {
v->ReturnBWPerState[i][j] = v->IdealSDPPortBandwidthPerState[i][j] * v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly
/ 100;
} else {
v->ReturnBWPerState[i][j] = v->IdealSDPPortBandwidthPerState[i][j]
* v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData / 100;
}
}
}
//Re-ordering Buffer Support Check
for (i = 0; i < mode_lib->soc.num_states; ++i) {
for (j = 0; j <= 1; ++j) {
if ((v->ROBBufferSizeInKByte - v->PixelChunkSizeInKByte) * 1024 / v->ReturnBWPerState[i][j]
> (v->RoundTripPingLatencyCycles + 32) / v->DCFCLKState[i][j] + ReorderingBytes / v->ReturnBWPerState[i][j]) {
v->ROBSupport[i][j] = true;
} else {
v->ROBSupport[i][j] = false;
}
}
}
//Vertical Active BW support check
MaxTotalVActiveRDBandwidth = 0;
for (k = 0; k < v->NumberOfActivePlanes; ++k) {
MaxTotalVActiveRDBandwidth = MaxTotalVActiveRDBandwidth + v->ReadBandwidthLuma[k] + v->ReadBandwidthChroma[k];
}
for (i = 0; i < mode_lib->soc.num_states; ++i) {
for (j = 0; j <= 1; ++j) {
v->MaxTotalVerticalActiveAvailableBandwidth[i][j] = dml_min(
v->IdealSDPPortBandwidthPerState[i][j] * v->MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation / 100,
v->DRAMSpeedPerState[i] * v->NumberOfChannels * v->DRAMChannelWidth * v->MaxAveragePercentOfIdealDRAMBWDisplayCanUseInNormalSystemOperation
/ 100);
if (MaxTotalVActiveRDBandwidth <= v->MaxTotalVerticalActiveAvailableBandwidth[i][j]) {
v->TotalVerticalActiveBandwidthSupport[i][j] = true;
} else {
v->TotalVerticalActiveBandwidthSupport[i][j] = false;
}
}
}
//Prefetch Check
for (i = 0; i < mode_lib->soc.num_states; ++i) {
for (j = 0; j <= 1; ++j) {
int NextPrefetchModeState = MinPrefetchMode;
v->TimeCalc = 24 / v->ProjectedDCFCLKDeepSleep[i][j];
v->BandwidthWithoutPrefetchSupported[i][j] = true;
if (v->TotalVActivePixelBandwidth[i][j] + v->TotalVActiveCursorBandwidth[i][j] + v->TotalMetaRowBandwidth[i][j] + v->TotalDPTERowBandwidth[i][j]
> v->ReturnBWPerState[i][j] || v->NotUrgentLatencyHiding[i][j]) {
v->BandwidthWithoutPrefetchSupported[i][j] = false;
}
for (k = 0; k < v->NumberOfActivePlanes; ++k) {
v->NoOfDPPThisState[k] = v->NoOfDPP[i][j][k];
v->swath_width_luma_ub_this_state[k] = v->swath_width_luma_ub_all_states[i][j][k];
v->swath_width_chroma_ub_this_state[k] = v->swath_width_chroma_ub_all_states[i][j][k];
v->SwathWidthYThisState[k] = v->SwathWidthYAllStates[i][j][k];
v->SwathWidthCThisState[k] = v->SwathWidthCAllStates[i][j][k];
v->SwathHeightYThisState[k] = v->SwathHeightYAllStates[i][j][k];
v->SwathHeightCThisState[k] = v->SwathHeightCAllStates[i][j][k];
v->DETBufferSizeYThisState[k] = v->DETBufferSizeYAllStates[i][j][k];
v->DETBufferSizeCThisState[k] = v->DETBufferSizeCAllStates[i][j][k];
v->ODMCombineEnabled[k] = v->ODMCombineEnablePerState[i][k];
}
v->ExtraLatency = CalculateExtraLatency(
v->RoundTripPingLatencyCycles,
ReorderingBytes,
v->DCFCLKState[i][j],
v->TotalNumberOfActiveDPP[i][j],
v->PixelChunkSizeInKByte,
v->TotalNumberOfDCCActiveDPP[i][j],
v->MetaChunkSize,
v->ReturnBWPerState[i][j],
v->GPUVMEnable,
v->HostVMEnable,
v->NumberOfActivePlanes,
v->NoOfDPPThisState,
v->dpte_group_bytes,
v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
v->HostVMMinPageSize,
v->HostVMMaxNonCachedPageTableLevels);
v->NextMaxVStartup = v->MaxMaxVStartup[i][j];
do {
v->PrefetchModePerState[i][j] = NextPrefetchModeState;
v->MaxVStartup = v->NextMaxVStartup;
v->TWait = CalculateTWait(v->PrefetchModePerState[i][j], v->FinalDRAMClockChangeLatency, v->UrgLatency[i], v->SREnterPlusExitTime);
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
Pipe myPipe = { 0 };
myPipe.DPPCLK = v->RequiredDPPCLK[i][j][k];
myPipe.DISPCLK = v->RequiredDISPCLK[i][j];
myPipe.PixelClock = v->PixelClock[k];
myPipe.DCFCLKDeepSleep = v->ProjectedDCFCLKDeepSleep[i][j];
myPipe.DPPPerPlane = v->NoOfDPP[i][j][k];
myPipe.ScalerEnabled = v->ScalerEnabled[k];
myPipe.SourceScan = v->SourceScan[k];
myPipe.BlockWidth256BytesY = v->Read256BlockWidthY[k];
myPipe.BlockHeight256BytesY = v->Read256BlockHeightY[k];
myPipe.BlockWidth256BytesC = v->Read256BlockWidthC[k];
myPipe.BlockHeight256BytesC = v->Read256BlockHeightC[k];
myPipe.InterlaceEnable = v->Interlace[k];
myPipe.NumberOfCursors = v->NumberOfCursors[k];
myPipe.VBlank = v->VTotal[k] - v->VActive[k];
myPipe.HTotal = v->HTotal[k];
myPipe.DCCEnable = v->DCCEnable[k];
myPipe.ODMCombineEnabled = !!v->ODMCombineEnabled[k];
v->NoTimeForPrefetch[i][j][k] = CalculatePrefetchSchedule(
mode_lib,
v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
&myPipe,
v->DSCDelayPerState[i][k],
v->DPPCLKDelaySubtotal + v->DPPCLKDelayCNVCFormater,
v->DPPCLKDelaySCL,
v->DPPCLKDelaySCLLBOnly,
v->DPPCLKDelayCNVCCursor,
v->DISPCLKDelaySubtotal,
v->SwathWidthYThisState[k] / v->HRatio[k],
v->OutputFormat[k],
v->MaxInterDCNTileRepeaters,
dml_min(v->MaxVStartup, v->MaximumVStartup[i][j][k]),
v->MaximumVStartup[i][j][k],
v->GPUVMMaxPageTableLevels,
v->GPUVMEnable,
v->HostVMEnable,
v->HostVMMaxNonCachedPageTableLevels,
v->HostVMMinPageSize,
v->DynamicMetadataEnable[k],
v->DynamicMetadataVMEnabled,
v->DynamicMetadataLinesBeforeActiveRequired[k],
v->DynamicMetadataTransmittedBytes[k],
v->UrgLatency[i],
v->ExtraLatency,
v->TimeCalc,
v->PDEAndMetaPTEBytesPerFrame[i][j][k],
v->MetaRowBytes[i][j][k],
v->DPTEBytesPerRow[i][j][k],
v->PrefetchLinesY[i][j][k],
v->SwathWidthYThisState[k],
v->BytePerPixelY[k],
v->PrefillY[k],
v->MaxNumSwY[k],
v->PrefetchLinesC[i][j][k],
v->SwathWidthCThisState[k],
v->BytePerPixelC[k],
v->PrefillC[k],
v->MaxNumSwC[k],
v->swath_width_luma_ub_this_state[k],
v->swath_width_chroma_ub_this_state[k],
v->SwathHeightYThisState[k],
v->SwathHeightCThisState[k],
v->TWait,
v->ProgressiveToInterlaceUnitInOPP,
&v->DSTXAfterScaler[k],
&v->DSTYAfterScaler[k],
&v->LineTimesForPrefetch[k],
&v->PrefetchBW[k],
&v->LinesForMetaPTE[k],
&v->LinesForMetaAndDPTERow[k],
&v->VRatioPreY[i][j][k],
&v->VRatioPreC[i][j][k],
&v->RequiredPrefetchPixelDataBWLuma[i][j][k],
&v->RequiredPrefetchPixelDataBWChroma[i][j][k],
&v->NoTimeForDynamicMetadata[i][j][k],
&v->Tno_bw[k],
&v->prefetch_vmrow_bw[k],
&v->Tdmdl_vm[k],
&v->Tdmdl[k],
&v->VUpdateOffsetPix[k],
&v->VUpdateWidthPix[k],
&v->VReadyOffsetPix[k]);
}
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
CalculateUrgentBurstFactor(
v->swath_width_luma_ub_this_state[k],
v->swath_width_chroma_ub_this_state[k],
v->DETBufferSizeInKByte[0],
v->SwathHeightYThisState[k],
v->SwathHeightCThisState[k],
v->HTotal[k] / v->PixelClock[k],
v->UrgentLatency,
v->CursorBufferSize,
v->CursorWidth[k][0],
v->CursorBPP[k][0],
v->VRatioPreY[i][j][k],
v->VRatioPreC[i][j][k],
v->BytePerPixelInDETY[k],
v->BytePerPixelInDETC[k],
v->DETBufferSizeYThisState[k],
v->DETBufferSizeCThisState[k],
&v->UrgentBurstFactorCursorPre[k],
&v->UrgentBurstFactorLumaPre[k],
&v->UrgentBurstFactorChroma[k],
&v->NoUrgentLatencyHidingPre[k]);
}
v->MaximumReadBandwidthWithPrefetch = 0.0;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
v->cursor_bw_pre[k] = v->NumberOfCursors[k] * v->CursorWidth[k][0] * v->CursorBPP[k][0] / 8.0 / (v->HTotal[k] / v->PixelClock[k])
* v->VRatioPreY[i][j][k];
v->MaximumReadBandwidthWithPrefetch = v->MaximumReadBandwidthWithPrefetch
+ dml_max4(
v->VActivePixelBandwidth[i][j][k],
v->VActiveCursorBandwidth[i][j][k]
+ v->NoOfDPP[i][j][k] * (v->meta_row_bandwidth[i][j][k] + v->dpte_row_bandwidth[i][j][k]),
v->NoOfDPP[i][j][k] * v->prefetch_vmrow_bw[k],
v->NoOfDPP[i][j][k]
* (v->RequiredPrefetchPixelDataBWLuma[i][j][k] * v->UrgentBurstFactorLumaPre[k]
+ v->RequiredPrefetchPixelDataBWChroma[i][j][k]
* v->UrgentBurstFactorChromaPre[k])
+ v->cursor_bw_pre[k] * v->UrgentBurstFactorCursorPre[k]);
}
v->NotEnoughUrgentLatencyHidingPre = false;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->NoUrgentLatencyHidingPre[k] == true) {
v->NotEnoughUrgentLatencyHidingPre = true;
}
}
v->PrefetchSupported[i][j] = true;
if (v->BandwidthWithoutPrefetchSupported[i][j] == false || v->MaximumReadBandwidthWithPrefetch > v->ReturnBWPerState[i][j]
|| v->NotEnoughUrgentLatencyHidingPre == 1) {
v->PrefetchSupported[i][j] = false;
}
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->LineTimesForPrefetch[k] < 2.0 || v->LinesForMetaPTE[k] >= 32.0 || v->LinesForMetaAndDPTERow[k] >= 16.0
|| v->NoTimeForPrefetch[i][j][k] == true) {
v->PrefetchSupported[i][j] = false;
}
}
v->DynamicMetadataSupported[i][j] = true;
for (k = 0; k < v->NumberOfActivePlanes; ++k) {
if (v->NoTimeForDynamicMetadata[i][j][k] == true) {
v->DynamicMetadataSupported[i][j] = false;
}
}
v->VRatioInPrefetchSupported[i][j] = true;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->VRatioPreY[i][j][k] > 4.0 || v->VRatioPreC[i][j][k] > 4.0 || v->NoTimeForPrefetch[i][j][k] == true) {
v->VRatioInPrefetchSupported[i][j] = false;
}
}
v->AnyLinesForVMOrRowTooLarge = false;
for (k = 0; k < v->NumberOfActivePlanes; ++k) {
if (v->LinesForMetaAndDPTERow[k] >= 16 || v->LinesForMetaPTE[k] >= 32) {
v->AnyLinesForVMOrRowTooLarge = true;
}
}
if (v->PrefetchSupported[i][j] == true && v->VRatioInPrefetchSupported[i][j] == true) {
v->BandwidthAvailableForImmediateFlip = v->ReturnBWPerState[i][j];
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
v->BandwidthAvailableForImmediateFlip = v->BandwidthAvailableForImmediateFlip
- dml_max(
v->VActivePixelBandwidth[i][j][k] + v->VActiveCursorBandwidth[i][j][k],
v->NoOfDPP[i][j][k]
* (v->RequiredPrefetchPixelDataBWLuma[i][j][k] * v->UrgentBurstFactorLumaPre[k]
+ v->RequiredPrefetchPixelDataBWChroma[i][j][k]
* v->UrgentBurstFactorChromaPre[k])
+ v->cursor_bw_pre[k] * v->UrgentBurstFactorCursorPre[k]);
}
v->TotImmediateFlipBytes = 0.0;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
v->TotImmediateFlipBytes = v->TotImmediateFlipBytes + v->NoOfDPP[i][j][k] * v->PDEAndMetaPTEBytesPerFrame[i][j][k]
+ v->MetaRowBytes[i][j][k] + v->DPTEBytesPerRow[i][j][k];
}
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
CalculateFlipSchedule(
mode_lib,
v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelMixedWithVMData,
v->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyVMDataOnly,
v->ExtraLatency,
v->UrgLatency[i],
v->GPUVMMaxPageTableLevels,
v->HostVMEnable,
v->HostVMMaxNonCachedPageTableLevels,
v->GPUVMEnable,
v->HostVMMinPageSize,
v->PDEAndMetaPTEBytesPerFrame[i][j][k],
v->MetaRowBytes[i][j][k],
v->DPTEBytesPerRow[i][j][k],
v->BandwidthAvailableForImmediateFlip,
v->TotImmediateFlipBytes,
v->SourcePixelFormat[k],
v->HTotal[k] / v->PixelClock[k],
v->VRatio[k],
v->VRatioChroma[k],
v->Tno_bw[k],
v->DCCEnable[k],
v->dpte_row_height[k],
v->meta_row_height[k],
v->dpte_row_height_chroma[k],
v->meta_row_height_chroma[k],
&v->DestinationLinesToRequestVMInImmediateFlip[k],
&v->DestinationLinesToRequestRowInImmediateFlip[k],
&v->final_flip_bw[k],
&v->ImmediateFlipSupportedForPipe[k]);
}
v->total_dcn_read_bw_with_flip = 0.0;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
v->total_dcn_read_bw_with_flip = v->total_dcn_read_bw_with_flip
+ dml_max3(
v->NoOfDPP[i][j][k] * v->prefetch_vmrow_bw[k],
v->NoOfDPP[i][j][k] * v->final_flip_bw[k] + v->VActivePixelBandwidth[i][j][k]
+ v->VActiveCursorBandwidth[i][j][k],
v->NoOfDPP[i][j][k]
* (v->final_flip_bw[k]
+ v->RequiredPrefetchPixelDataBWLuma[i][j][k]
* v->UrgentBurstFactorLumaPre[k]
+ v->RequiredPrefetchPixelDataBWChroma[i][j][k]
* v->UrgentBurstFactorChromaPre[k])
+ v->cursor_bw_pre[k] * v->UrgentBurstFactorCursorPre[k]);
}
v->ImmediateFlipSupportedForState[i][j] = true;
if (v->total_dcn_read_bw_with_flip > v->ReturnBWPerState[i][j]) {
v->ImmediateFlipSupportedForState[i][j] = false;
}
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->ImmediateFlipSupportedForPipe[k] == false) {
v->ImmediateFlipSupportedForState[i][j] = false;
}
}
} else {
v->ImmediateFlipSupportedForState[i][j] = false;
}
if (v->MaxVStartup <= 13 || v->AnyLinesForVMOrRowTooLarge == false) {
v->NextMaxVStartup = v->MaxMaxVStartup[i][j];
NextPrefetchModeState = NextPrefetchModeState + 1;
} else {
v->NextMaxVStartup = v->NextMaxVStartup - 1;
}
} while (!((v->PrefetchSupported[i][j] == true && v->DynamicMetadataSupported[i][j] == true && v->VRatioInPrefetchSupported[i][j] == true
&& ((v->HostVMEnable == false && v->ImmediateFlipRequirement[0] != dm_immediate_flip_required)
|| v->ImmediateFlipSupportedForState[i][j] == true))
|| (v->NextMaxVStartup == v->MaxMaxVStartup[i][j] && NextPrefetchModeState > MaxPrefetchMode)));
CalculateWatermarksAndDRAMSpeedChangeSupport(
mode_lib,
v->PrefetchModePerState[i][j],
v->NumberOfActivePlanes,
v->MaxLineBufferLines,
v->LineBufferSize,
v->DPPOutputBufferPixels,
v->DETBufferSizeInKByte[0],
v->WritebackInterfaceBufferSize,
v->DCFCLKState[i][j],
v->ReturnBWPerState[i][j],
v->GPUVMEnable,
v->dpte_group_bytes,
v->MetaChunkSize,
v->UrgLatency[i],
v->ExtraLatency,
v->WritebackLatency,
v->WritebackChunkSize,
v->SOCCLKPerState[i],
v->FinalDRAMClockChangeLatency,
v->SRExitTime,
v->SREnterPlusExitTime,
v->ProjectedDCFCLKDeepSleep[i][j],
v->NoOfDPPThisState,
v->DCCEnable,
v->RequiredDPPCLKThisState,
v->DETBufferSizeYThisState,
v->DETBufferSizeCThisState,
v->SwathHeightYThisState,
v->SwathHeightCThisState,
v->LBBitPerPixel,
v->SwathWidthYThisState,
v->SwathWidthCThisState,
v->HRatio,
v->HRatioChroma,
v->vtaps,
v->VTAPsChroma,
v->VRatio,
v->VRatioChroma,
v->HTotal,
v->PixelClock,
v->BlendingAndTiming,
v->BytePerPixelInDETY,
v->BytePerPixelInDETC,
v->DSTXAfterScaler,
v->DSTYAfterScaler,
v->WritebackEnable,
v->WritebackPixelFormat,
v->WritebackDestinationWidth,
v->WritebackDestinationHeight,
v->WritebackSourceHeight,
&v->DRAMClockChangeSupport[i][j],
&v->UrgentWatermark,
&v->WritebackUrgentWatermark,
&v->DRAMClockChangeWatermark,
&v->WritebackDRAMClockChangeWatermark,
&v->StutterExitWatermark,
&v->StutterEnterPlusExitWatermark,
&v->MinActiveDRAMClockChangeLatencySupported);
}
}
/*PTE Buffer Size Check*/
for (i = 0; i < v->soc.num_states; i++) {
for (j = 0; j < 2; j++) {
v->PTEBufferSizeNotExceeded[i][j] = true;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->PTEBufferSizeNotExceededY[i][j][k] == false || v->PTEBufferSizeNotExceededC[i][j][k] == false) {
v->PTEBufferSizeNotExceeded[i][j] = false;
}
}
}
}
/*Cursor Support Check*/
v->CursorSupport = true;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->CursorWidth[k][0] > 0.0) {
if (v->CursorBPP[k][0] == 64 && v->Cursor64BppSupport == false) {
v->CursorSupport = false;
}
}
}
/*Valid Pitch Check*/
v->PitchSupport = true;
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
v->AlignedYPitch[k] = dml_ceil(dml_max(v->PitchY[k], v->SurfaceWidthY[k]), v->MacroTileWidthY[k]);
if (v->DCCEnable[k] == true) {
v->AlignedDCCMetaPitchY[k] = dml_ceil(dml_max(v->DCCMetaPitchY[k], v->SurfaceWidthY[k]), 64.0 * v->Read256BlockWidthY[k]);
} else {
v->AlignedDCCMetaPitchY[k] = v->DCCMetaPitchY[k];
}
if (v->SourcePixelFormat[k] != dm_444_64 && v->SourcePixelFormat[k] != dm_444_32 && v->SourcePixelFormat[k] != dm_444_16 && v->SourcePixelFormat[k] != dm_mono_16
&& v->SourcePixelFormat[k] != dm_rgbe && v->SourcePixelFormat[k] != dm_mono_8) {
v->AlignedCPitch[k] = dml_ceil(dml_max(v->PitchC[k], v->SurfaceWidthC[k]), v->MacroTileWidthC[k]);
if (v->DCCEnable[k] == true) {
v->AlignedDCCMetaPitchC[k] = dml_ceil(dml_max(v->DCCMetaPitchC[k], v->SurfaceWidthC[k]), 64.0 * v->Read256BlockWidthC[k]);
} else {
v->AlignedDCCMetaPitchC[k] = v->DCCMetaPitchC[k];
}
} else {
v->AlignedCPitch[k] = v->PitchC[k];
v->AlignedDCCMetaPitchC[k] = v->DCCMetaPitchC[k];
}
if (v->AlignedYPitch[k] > v->PitchY[k] || v->AlignedCPitch[k] > v->PitchC[k] || v->AlignedDCCMetaPitchY[k] > v->DCCMetaPitchY[k]
|| v->AlignedDCCMetaPitchC[k] > v->DCCMetaPitchC[k]) {
v->PitchSupport = false;
}
}
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
if (v->ViewportWidth[k] > v->SurfaceWidthY[k] || v->ViewportHeight[k] > v->SurfaceHeightY[k])
ViewportExceedsSurface = true;
if (v->SourcePixelFormat[k] != dm_444_64 && v->SourcePixelFormat[k] != dm_444_32 && v->SourcePixelFormat[k] != dm_444_16
&& v->SourcePixelFormat[k] != dm_444_8 && v->SourcePixelFormat[k] != dm_rgbe) {
if (v->ViewportWidthChroma[k] > v->SurfaceWidthC[k] || v->ViewportHeightChroma[k] > v->SurfaceHeightC[k]) {
ViewportExceedsSurface = true;
}
}
}
/*Mode Support, Voltage State and SOC Configuration*/
for (i = v->soc.num_states - 1; i >= 0; i--) {
for (j = 0; j < 2; j++) {
if (v->ScaleRatioAndTapsSupport == 1 && v->SourceFormatPixelAndScanSupport == 1 && v->ViewportSizeSupport[i][j] == 1
&& v->DIOSupport[i] == 1 && v->ODMCombine4To1SupportCheckOK[i] == 1
&& v->NotEnoughDSCUnits[i] == 0
&& v->DTBCLKRequiredMoreThanSupported[i] == 0
&& v->ROBSupport[i][j] == 1 && v->DISPCLK_DPPCLK_Support[i][j] == 1 && v->TotalAvailablePipesSupport[i][j] == 1
&& EnoughWritebackUnits == 1 && WritebackModeSupport == 1
&& v->WritebackLatencySupport == 1 && v->WritebackScaleRatioAndTapsSupport == 1 && v->CursorSupport == 1 && v->PitchSupport == 1
&& ViewportExceedsSurface == 0 && v->PrefetchSupported[i][j] == 1 && v->DynamicMetadataSupported[i][j] == 1
&& v->TotalVerticalActiveBandwidthSupport[i][j] == 1 && v->VRatioInPrefetchSupported[i][j] == 1
&& v->PTEBufferSizeNotExceeded[i][j] == 1 && v->NonsupportedDSCInputBPC == 0
&& ((v->HostVMEnable == 0 && v->ImmediateFlipRequirement[0] != dm_immediate_flip_required)
|| v->ImmediateFlipSupportedForState[i][j] == true)) {
v->ModeSupport[i][j] = true;
} else {
v->ModeSupport[i][j] = false;
}
}
}
{
unsigned int MaximumMPCCombine = 0;
for (i = v->soc.num_states; i >= 0; i--) {
if (i == v->soc.num_states || v->ModeSupport[i][0] == true || v->ModeSupport[i][1] == true) {
v->VoltageLevel = i;
v->ModeIsSupported = v->ModeSupport[i][0] == true || v->ModeSupport[i][1] == true;
if (v->ModeSupport[i][1] == true) {
MaximumMPCCombine = 1;
} else {
MaximumMPCCombine = 0;
}
}
}
v->ImmediateFlipSupport = v->ImmediateFlipSupportedForState[v->VoltageLevel][MaximumMPCCombine];
for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) {
v->MPCCombineEnable[k] = v->MPCCombine[v->VoltageLevel][MaximumMPCCombine][k];
v->DPPPerPlane[k] = v->NoOfDPP[v->VoltageLevel][MaximumMPCCombine][k];
}
v->DCFCLK = v->DCFCLKState[v->VoltageLevel][MaximumMPCCombine];
v->DRAMSpeed = v->DRAMSpeedPerState[v->VoltageLevel];
v->FabricClock = v->FabricClockPerState[v->VoltageLevel];
v->SOCCLK = v->SOCCLKPerState[v->VoltageLevel];
v->ReturnBW = v->ReturnBWPerState[v->VoltageLevel][MaximumMPCCombine];
v->maxMpcComb = MaximumMPCCombine;
}
}