1 /* 2 * Copyright 2018 Advanced Micro Devices, Inc. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included in 12 * all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 * 22 * Authors: AMD 23 * 24 */ 25 26 #include "../display_mode_lib.h" 27 #include "display_mode_vba_20.h" 28 #include "../dml_inline_defs.h" 29 30 /* 31 * NOTE: 32 * This file is gcc-parseable HW gospel, coming straight from HW engineers. 33 * 34 * It doesn't adhere to Linux kernel style and sometimes will do things in odd 35 * ways. Unless there is something clearly wrong with it the code should 36 * remain as-is as it provides us with a guarantee from HW that it is correct. 37 */ 38 39 #define BPP_INVALID 0 40 #define BPP_BLENDED_PIPE 0xffffffff 41 42 static double adjust_ReturnBW( 43 struct display_mode_lib *mode_lib, 44 double ReturnBW, 45 bool DCCEnabledAnyPlane, 46 double ReturnBandwidthToDCN); 47 static unsigned int dscceComputeDelay( 48 unsigned int bpc, 49 double bpp, 50 unsigned int sliceWidth, 51 unsigned int numSlices, 52 enum output_format_class pixelFormat); 53 static unsigned int dscComputeDelay(enum output_format_class pixelFormat); 54 // Super monster function with some 45 argument 55 static bool CalculatePrefetchSchedule( 56 struct display_mode_lib *mode_lib, 57 double DPPCLK, 58 double DISPCLK, 59 double PixelClock, 60 double DCFCLKDeepSleep, 61 unsigned int DSCDelay, 62 unsigned int DPPPerPlane, 63 bool ScalerEnabled, 64 unsigned int NumberOfCursors, 65 double DPPCLKDelaySubtotal, 66 double DPPCLKDelaySCL, 67 double DPPCLKDelaySCLLBOnly, 68 double DPPCLKDelayCNVCFormater, 69 double DPPCLKDelayCNVCCursor, 70 double DISPCLKDelaySubtotal, 71 unsigned int ScalerRecoutWidth, 72 enum output_format_class OutputFormat, 73 unsigned int VBlank, 74 unsigned int HTotal, 75 unsigned int MaxInterDCNTileRepeaters, 76 unsigned int VStartup, 77 unsigned int PageTableLevels, 78 bool GPUVMEnable, 79 bool DynamicMetadataEnable, 80 unsigned int DynamicMetadataLinesBeforeActiveRequired, 81 unsigned int DynamicMetadataTransmittedBytes, 82 bool DCCEnable, 83 double UrgentLatencyPixelDataOnly, 84 double UrgentExtraLatency, 85 double TCalc, 86 unsigned int PDEAndMetaPTEBytesFrame, 87 unsigned int MetaRowByte, 88 unsigned int PixelPTEBytesPerRow, 89 double PrefetchSourceLinesY, 90 unsigned int SwathWidthY, 91 double BytePerPixelDETY, 92 double VInitPreFillY, 93 unsigned int MaxNumSwathY, 94 double PrefetchSourceLinesC, 95 double BytePerPixelDETC, 96 double VInitPreFillC, 97 unsigned int MaxNumSwathC, 98 unsigned int SwathHeightY, 99 unsigned int SwathHeightC, 100 double TWait, 101 bool XFCEnabled, 102 double XFCRemoteSurfaceFlipDelay, 103 bool InterlaceEnable, 104 bool ProgressiveToInterlaceUnitInOPP, 105 double *DSTXAfterScaler, 106 double *DSTYAfterScaler, 107 double *DestinationLinesForPrefetch, 108 double *PrefetchBandwidth, 109 double *DestinationLinesToRequestVMInVBlank, 110 double *DestinationLinesToRequestRowInVBlank, 111 double *VRatioPrefetchY, 112 double *VRatioPrefetchC, 113 double *RequiredPrefetchPixDataBW, 114 unsigned int *VStartupRequiredWhenNotEnoughTimeForDynamicMetadata, 115 double *Tno_bw, 116 unsigned int *VUpdateOffsetPix, 117 double *VUpdateWidthPix, 118 double *VReadyOffsetPix); 119 static double RoundToDFSGranularityUp(double Clock, double VCOSpeed); 120 static double RoundToDFSGranularityDown(double Clock, double VCOSpeed); 121 static double CalculatePrefetchSourceLines( 122 struct display_mode_lib *mode_lib, 123 double VRatio, 124 double vtaps, 125 bool Interlace, 126 bool ProgressiveToInterlaceUnitInOPP, 127 unsigned int SwathHeight, 128 unsigned int ViewportYStart, 129 double *VInitPreFill, 130 unsigned int *MaxNumSwath); 131 static unsigned int CalculateVMAndRowBytes( 132 struct display_mode_lib *mode_lib, 133 bool DCCEnable, 134 unsigned int BlockHeight256Bytes, 135 unsigned int BlockWidth256Bytes, 136 enum source_format_class SourcePixelFormat, 137 unsigned int SurfaceTiling, 138 unsigned int BytePerPixel, 139 enum scan_direction_class ScanDirection, 140 unsigned int ViewportWidth, 141 unsigned int ViewportHeight, 142 unsigned int SwathWidthY, 143 bool GPUVMEnable, 144 unsigned int VMMPageSize, 145 unsigned int PTEBufferSizeInRequestsLuma, 146 unsigned int PDEProcessingBufIn64KBReqs, 147 unsigned int Pitch, 148 unsigned int DCCMetaPitch, 149 unsigned int *MacroTileWidth, 150 unsigned int *MetaRowByte, 151 unsigned int *PixelPTEBytesPerRow, 152 bool *PTEBufferSizeNotExceeded, 153 unsigned int *dpte_row_height, 154 unsigned int *meta_row_height); 155 static double CalculateTWait( 156 unsigned int PrefetchMode, 157 double DRAMClockChangeLatency, 158 double UrgentLatencyPixelDataOnly, 159 double SREnterPlusExitTime); 160 static double CalculateRemoteSurfaceFlipDelay( 161 struct display_mode_lib *mode_lib, 162 double VRatio, 163 double SwathWidth, 164 double Bpp, 165 double LineTime, 166 double XFCTSlvVupdateOffset, 167 double XFCTSlvVupdateWidth, 168 double XFCTSlvVreadyOffset, 169 double XFCXBUFLatencyTolerance, 170 double XFCFillBWOverhead, 171 double XFCSlvChunkSize, 172 double XFCBusTransportTime, 173 double TCalc, 174 double TWait, 175 double *SrcActiveDrainRate, 176 double *TInitXFill, 177 double *TslvChk); 178 static void CalculateActiveRowBandwidth( 179 bool GPUVMEnable, 180 enum source_format_class SourcePixelFormat, 181 double VRatio, 182 bool DCCEnable, 183 double LineTime, 184 unsigned int MetaRowByteLuma, 185 unsigned int MetaRowByteChroma, 186 unsigned int meta_row_height_luma, 187 unsigned int meta_row_height_chroma, 188 unsigned int PixelPTEBytesPerRowLuma, 189 unsigned int PixelPTEBytesPerRowChroma, 190 unsigned int dpte_row_height_luma, 191 unsigned int dpte_row_height_chroma, 192 double *meta_row_bw, 193 double *dpte_row_bw, 194 double *qual_row_bw); 195 static void CalculateFlipSchedule( 196 struct display_mode_lib *mode_lib, 197 double UrgentExtraLatency, 198 double UrgentLatencyPixelDataOnly, 199 unsigned int GPUVMMaxPageTableLevels, 200 bool GPUVMEnable, 201 double BandwidthAvailableForImmediateFlip, 202 unsigned int TotImmediateFlipBytes, 203 enum source_format_class SourcePixelFormat, 204 unsigned int ImmediateFlipBytes, 205 double LineTime, 206 double VRatio, 207 double Tno_bw, 208 double PDEAndMetaPTEBytesFrame, 209 unsigned int MetaRowByte, 210 unsigned int PixelPTEBytesPerRow, 211 bool DCCEnable, 212 unsigned int dpte_row_height, 213 unsigned int meta_row_height, 214 double qual_row_bw, 215 double *DestinationLinesToRequestVMInImmediateFlip, 216 double *DestinationLinesToRequestRowInImmediateFlip, 217 double *final_flip_bw, 218 bool *ImmediateFlipSupportedForPipe); 219 static double CalculateWriteBackDelay( 220 enum source_format_class WritebackPixelFormat, 221 double WritebackHRatio, 222 double WritebackVRatio, 223 unsigned int WritebackLumaHTaps, 224 unsigned int WritebackLumaVTaps, 225 unsigned int WritebackChromaHTaps, 226 unsigned int WritebackChromaVTaps, 227 unsigned int WritebackDestinationWidth); 228 229 static void dml20_DisplayPipeConfiguration(struct display_mode_lib *mode_lib); 230 static void dml20_DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation( 231 struct display_mode_lib *mode_lib); 232 233 void dml20_recalculate(struct display_mode_lib *mode_lib) 234 { 235 ModeSupportAndSystemConfiguration(mode_lib); 236 mode_lib->vba.FabricAndDRAMBandwidth = dml_min( 237 mode_lib->vba.DRAMSpeed * mode_lib->vba.NumberOfChannels * mode_lib->vba.DRAMChannelWidth, 238 mode_lib->vba.FabricClock * mode_lib->vba.FabricDatapathToDCNDataReturn) / 1000.0; 239 PixelClockAdjustmentForProgressiveToInterlaceUnit(mode_lib); 240 dml20_DisplayPipeConfiguration(mode_lib); 241 dml20_DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(mode_lib); 242 } 243 244 static double adjust_ReturnBW( 245 struct display_mode_lib *mode_lib, 246 double ReturnBW, 247 bool DCCEnabledAnyPlane, 248 double ReturnBandwidthToDCN) 249 { 250 double CriticalCompression; 251 252 if (DCCEnabledAnyPlane 253 && ReturnBandwidthToDCN 254 > mode_lib->vba.DCFCLK * mode_lib->vba.ReturnBusWidth / 4.0) 255 ReturnBW = 256 dml_min( 257 ReturnBW, 258 ReturnBandwidthToDCN * 4 259 * (1.0 260 - mode_lib->vba.UrgentLatencyPixelDataOnly 261 / ((mode_lib->vba.ROBBufferSizeInKByte 262 - mode_lib->vba.PixelChunkSizeInKByte) 263 * 1024 264 / ReturnBandwidthToDCN 265 - mode_lib->vba.DCFCLK 266 * mode_lib->vba.ReturnBusWidth 267 / 4) 268 + mode_lib->vba.UrgentLatencyPixelDataOnly)); 269 270 CriticalCompression = 2.0 * mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLK 271 * mode_lib->vba.UrgentLatencyPixelDataOnly 272 / (ReturnBandwidthToDCN * mode_lib->vba.UrgentLatencyPixelDataOnly 273 + (mode_lib->vba.ROBBufferSizeInKByte 274 - mode_lib->vba.PixelChunkSizeInKByte) 275 * 1024); 276 277 if (DCCEnabledAnyPlane && CriticalCompression > 1.0 && CriticalCompression < 4.0) 278 ReturnBW = 279 dml_min( 280 ReturnBW, 281 4.0 * ReturnBandwidthToDCN 282 * (mode_lib->vba.ROBBufferSizeInKByte 283 - mode_lib->vba.PixelChunkSizeInKByte) 284 * 1024 285 * mode_lib->vba.ReturnBusWidth 286 * mode_lib->vba.DCFCLK 287 * mode_lib->vba.UrgentLatencyPixelDataOnly 288 / dml_pow( 289 (ReturnBandwidthToDCN 290 * mode_lib->vba.UrgentLatencyPixelDataOnly 291 + (mode_lib->vba.ROBBufferSizeInKByte 292 - mode_lib->vba.PixelChunkSizeInKByte) 293 * 1024), 294 2)); 295 296 return ReturnBW; 297 } 298 299 static unsigned int dscceComputeDelay( 300 unsigned int bpc, 301 double bpp, 302 unsigned int sliceWidth, 303 unsigned int numSlices, 304 enum output_format_class pixelFormat) 305 { 306 // valid bpc = source bits per component in the set of {8, 10, 12} 307 // valid bpp = increments of 1/16 of a bit 308 // min = 6/7/8 in N420/N422/444, respectively 309 // max = such that compression is 1:1 310 //valid sliceWidth = number of pixels per slice line, must be less than or equal to 5184/numSlices (or 4096/numSlices in 420 mode) 311 //valid numSlices = number of slices in the horiziontal direction per DSC engine in the set of {1, 2, 3, 4} 312 //valid pixelFormat = pixel/color format in the set of {:N444_RGB, :S422, :N422, :N420} 313 314 // fixed value 315 unsigned int rcModelSize = 8192; 316 317 // N422/N420 operate at 2 pixels per clock 318 unsigned int pixelsPerClock, lstall, D, initalXmitDelay, w, s, ix, wx, p, l0, a, ax, l, 319 Delay, pixels; 320 321 if (pixelFormat == dm_n422 || pixelFormat == dm_420) 322 pixelsPerClock = 2; 323 // #all other modes operate at 1 pixel per clock 324 else 325 pixelsPerClock = 1; 326 327 //initial transmit delay as per PPS 328 initalXmitDelay = dml_round(rcModelSize / 2.0 / bpp / pixelsPerClock); 329 330 //compute ssm delay 331 if (bpc == 8) 332 D = 81; 333 else if (bpc == 10) 334 D = 89; 335 else 336 D = 113; 337 338 //divide by pixel per cycle to compute slice width as seen by DSC 339 w = sliceWidth / pixelsPerClock; 340 341 //422 mode has an additional cycle of delay 342 if (pixelFormat == dm_s422) 343 s = 1; 344 else 345 s = 0; 346 347 //main calculation for the dscce 348 ix = initalXmitDelay + 45; 349 wx = (w + 2) / 3; 350 p = 3 * wx - w; 351 l0 = ix / w; 352 a = ix + p * l0; 353 ax = (a + 2) / 3 + D + 6 + 1; 354 l = (ax + wx - 1) / wx; 355 if ((ix % w) == 0 && p != 0) 356 lstall = 1; 357 else 358 lstall = 0; 359 Delay = l * wx * (numSlices - 1) + ax + s + lstall + 22; 360 361 //dsc processes 3 pixel containers per cycle and a container can contain 1 or 2 pixels 362 pixels = Delay * 3 * pixelsPerClock; 363 return pixels; 364 } 365 366 static unsigned int dscComputeDelay(enum output_format_class pixelFormat) 367 { 368 unsigned int Delay = 0; 369 370 if (pixelFormat == dm_420) { 371 // sfr 372 Delay = Delay + 2; 373 // dsccif 374 Delay = Delay + 0; 375 // dscc - input deserializer 376 Delay = Delay + 3; 377 // dscc gets pixels every other cycle 378 Delay = Delay + 2; 379 // dscc - input cdc fifo 380 Delay = Delay + 12; 381 // dscc gets pixels every other cycle 382 Delay = Delay + 13; 383 // dscc - cdc uncertainty 384 Delay = Delay + 2; 385 // dscc - output cdc fifo 386 Delay = Delay + 7; 387 // dscc gets pixels every other cycle 388 Delay = Delay + 3; 389 // dscc - cdc uncertainty 390 Delay = Delay + 2; 391 // dscc - output serializer 392 Delay = Delay + 1; 393 // sft 394 Delay = Delay + 1; 395 } else if (pixelFormat == dm_n422) { 396 // sfr 397 Delay = Delay + 2; 398 // dsccif 399 Delay = Delay + 1; 400 // dscc - input deserializer 401 Delay = Delay + 5; 402 // dscc - input cdc fifo 403 Delay = Delay + 25; 404 // dscc - cdc uncertainty 405 Delay = Delay + 2; 406 // dscc - output cdc fifo 407 Delay = Delay + 10; 408 // dscc - cdc uncertainty 409 Delay = Delay + 2; 410 // dscc - output serializer 411 Delay = Delay + 1; 412 // sft 413 Delay = Delay + 1; 414 } else { 415 // sfr 416 Delay = Delay + 2; 417 // dsccif 418 Delay = Delay + 0; 419 // dscc - input deserializer 420 Delay = Delay + 3; 421 // dscc - input cdc fifo 422 Delay = Delay + 12; 423 // dscc - cdc uncertainty 424 Delay = Delay + 2; 425 // dscc - output cdc fifo 426 Delay = Delay + 7; 427 // dscc - output serializer 428 Delay = Delay + 1; 429 // dscc - cdc uncertainty 430 Delay = Delay + 2; 431 // sft 432 Delay = Delay + 1; 433 } 434 435 return Delay; 436 } 437 438 static bool CalculatePrefetchSchedule( 439 struct display_mode_lib *mode_lib, 440 double DPPCLK, 441 double DISPCLK, 442 double PixelClock, 443 double DCFCLKDeepSleep, 444 unsigned int DSCDelay, 445 unsigned int DPPPerPlane, 446 bool ScalerEnabled, 447 unsigned int NumberOfCursors, 448 double DPPCLKDelaySubtotal, 449 double DPPCLKDelaySCL, 450 double DPPCLKDelaySCLLBOnly, 451 double DPPCLKDelayCNVCFormater, 452 double DPPCLKDelayCNVCCursor, 453 double DISPCLKDelaySubtotal, 454 unsigned int ScalerRecoutWidth, 455 enum output_format_class OutputFormat, 456 unsigned int VBlank, 457 unsigned int HTotal, 458 unsigned int MaxInterDCNTileRepeaters, 459 unsigned int VStartup, 460 unsigned int PageTableLevels, 461 bool GPUVMEnable, 462 bool DynamicMetadataEnable, 463 unsigned int DynamicMetadataLinesBeforeActiveRequired, 464 unsigned int DynamicMetadataTransmittedBytes, 465 bool DCCEnable, 466 double UrgentLatencyPixelDataOnly, 467 double UrgentExtraLatency, 468 double TCalc, 469 unsigned int PDEAndMetaPTEBytesFrame, 470 unsigned int MetaRowByte, 471 unsigned int PixelPTEBytesPerRow, 472 double PrefetchSourceLinesY, 473 unsigned int SwathWidthY, 474 double BytePerPixelDETY, 475 double VInitPreFillY, 476 unsigned int MaxNumSwathY, 477 double PrefetchSourceLinesC, 478 double BytePerPixelDETC, 479 double VInitPreFillC, 480 unsigned int MaxNumSwathC, 481 unsigned int SwathHeightY, 482 unsigned int SwathHeightC, 483 double TWait, 484 bool XFCEnabled, 485 double XFCRemoteSurfaceFlipDelay, 486 bool InterlaceEnable, 487 bool ProgressiveToInterlaceUnitInOPP, 488 double *DSTXAfterScaler, 489 double *DSTYAfterScaler, 490 double *DestinationLinesForPrefetch, 491 double *PrefetchBandwidth, 492 double *DestinationLinesToRequestVMInVBlank, 493 double *DestinationLinesToRequestRowInVBlank, 494 double *VRatioPrefetchY, 495 double *VRatioPrefetchC, 496 double *RequiredPrefetchPixDataBW, 497 unsigned int *VStartupRequiredWhenNotEnoughTimeForDynamicMetadata, 498 double *Tno_bw, 499 unsigned int *VUpdateOffsetPix, 500 double *VUpdateWidthPix, 501 double *VReadyOffsetPix) 502 { 503 bool MyError = false; 504 unsigned int DPPCycles, DISPCLKCycles; 505 double DSTTotalPixelsAfterScaler, TotalRepeaterDelayTime; 506 double Tdm, LineTime, Tsetup; 507 double dst_y_prefetch_equ; 508 double Tsw_oto; 509 double prefetch_bw_oto; 510 double Tvm_oto; 511 double Tr0_oto; 512 double Tpre_oto; 513 double dst_y_prefetch_oto; 514 double TimeForFetchingMetaPTE = 0; 515 double TimeForFetchingRowInVBlank = 0; 516 double LinesToRequestPrefetchPixelData = 0; 517 518 if (ScalerEnabled) 519 DPPCycles = DPPCLKDelaySubtotal + DPPCLKDelaySCL; 520 else 521 DPPCycles = DPPCLKDelaySubtotal + DPPCLKDelaySCLLBOnly; 522 523 DPPCycles = DPPCycles + DPPCLKDelayCNVCFormater + NumberOfCursors * DPPCLKDelayCNVCCursor; 524 525 DISPCLKCycles = DISPCLKDelaySubtotal; 526 527 if (DPPCLK == 0.0 || DISPCLK == 0.0) 528 return true; 529 530 *DSTXAfterScaler = DPPCycles * PixelClock / DPPCLK + DISPCLKCycles * PixelClock / DISPCLK 531 + DSCDelay; 532 533 if (DPPPerPlane > 1) 534 *DSTXAfterScaler = *DSTXAfterScaler + ScalerRecoutWidth; 535 536 if (OutputFormat == dm_420 || (InterlaceEnable && ProgressiveToInterlaceUnitInOPP)) 537 *DSTYAfterScaler = 1; 538 else 539 *DSTYAfterScaler = 0; 540 541 DSTTotalPixelsAfterScaler = ((double) (*DSTYAfterScaler * HTotal)) + *DSTXAfterScaler; 542 *DSTYAfterScaler = dml_floor(DSTTotalPixelsAfterScaler / HTotal, 1); 543 *DSTXAfterScaler = DSTTotalPixelsAfterScaler - ((double) (*DSTYAfterScaler * HTotal)); 544 545 *VUpdateOffsetPix = dml_ceil(HTotal / 4.0, 1); 546 TotalRepeaterDelayTime = MaxInterDCNTileRepeaters * (2.0 / DPPCLK + 3.0 / DISPCLK); 547 *VUpdateWidthPix = (14.0 / DCFCLKDeepSleep + 12.0 / DPPCLK + TotalRepeaterDelayTime) 548 * PixelClock; 549 550 *VReadyOffsetPix = dml_max( 551 150.0 / DPPCLK, 552 TotalRepeaterDelayTime + 20.0 / DCFCLKDeepSleep + 10.0 / DPPCLK) 553 * PixelClock; 554 555 Tsetup = (double) (*VUpdateOffsetPix + *VUpdateWidthPix + *VReadyOffsetPix) / PixelClock; 556 557 LineTime = (double) HTotal / PixelClock; 558 559 if (DynamicMetadataEnable) { 560 double Tdmbf, Tdmec, Tdmsks; 561 562 Tdm = dml_max(0.0, UrgentExtraLatency - TCalc); 563 Tdmbf = DynamicMetadataTransmittedBytes / 4.0 / DISPCLK; 564 Tdmec = LineTime; 565 if (DynamicMetadataLinesBeforeActiveRequired == 0) 566 Tdmsks = VBlank * LineTime / 2.0; 567 else 568 Tdmsks = DynamicMetadataLinesBeforeActiveRequired * LineTime; 569 if (InterlaceEnable && !ProgressiveToInterlaceUnitInOPP) 570 Tdmsks = Tdmsks / 2; 571 if (VStartup * LineTime 572 < Tsetup + TWait + UrgentExtraLatency + Tdmbf + Tdmec + Tdmsks) { 573 MyError = true; 574 *VStartupRequiredWhenNotEnoughTimeForDynamicMetadata = (Tsetup + TWait 575 + UrgentExtraLatency + Tdmbf + Tdmec + Tdmsks) / LineTime; 576 } else 577 *VStartupRequiredWhenNotEnoughTimeForDynamicMetadata = 0.0; 578 } else 579 Tdm = 0; 580 581 if (GPUVMEnable) { 582 if (PageTableLevels == 4) 583 *Tno_bw = UrgentExtraLatency + UrgentLatencyPixelDataOnly; 584 else if (PageTableLevels == 3) 585 *Tno_bw = UrgentExtraLatency; 586 else 587 *Tno_bw = 0; 588 } else if (DCCEnable) 589 *Tno_bw = LineTime; 590 else 591 *Tno_bw = LineTime / 4; 592 593 dst_y_prefetch_equ = VStartup - dml_max(TCalc + TWait, XFCRemoteSurfaceFlipDelay) / LineTime 594 - (Tsetup + Tdm) / LineTime 595 - (*DSTYAfterScaler + *DSTXAfterScaler / HTotal); 596 597 Tsw_oto = dml_max(PrefetchSourceLinesY, PrefetchSourceLinesC) * LineTime; 598 599 prefetch_bw_oto = (MetaRowByte + PixelPTEBytesPerRow 600 + PrefetchSourceLinesY * SwathWidthY * dml_ceil(BytePerPixelDETY, 1) 601 + PrefetchSourceLinesC * SwathWidthY / 2 * dml_ceil(BytePerPixelDETC, 2)) 602 / Tsw_oto; 603 604 if (GPUVMEnable == true) { 605 Tvm_oto = 606 dml_max( 607 *Tno_bw + PDEAndMetaPTEBytesFrame / prefetch_bw_oto, 608 dml_max( 609 UrgentExtraLatency 610 + UrgentLatencyPixelDataOnly 611 * (PageTableLevels 612 - 1), 613 LineTime / 4.0)); 614 } else 615 Tvm_oto = LineTime / 4.0; 616 617 if ((GPUVMEnable == true || DCCEnable == true)) { 618 Tr0_oto = dml_max( 619 (MetaRowByte + PixelPTEBytesPerRow) / prefetch_bw_oto, 620 dml_max(UrgentLatencyPixelDataOnly, dml_max(LineTime - Tvm_oto, LineTime / 4))); 621 } else 622 Tr0_oto = LineTime - Tvm_oto; 623 624 Tpre_oto = Tvm_oto + Tr0_oto + Tsw_oto; 625 626 dst_y_prefetch_oto = Tpre_oto / LineTime; 627 628 if (dst_y_prefetch_oto < dst_y_prefetch_equ) 629 *DestinationLinesForPrefetch = dst_y_prefetch_oto; 630 else 631 *DestinationLinesForPrefetch = dst_y_prefetch_equ; 632 633 *DestinationLinesForPrefetch = dml_floor(4.0 * (*DestinationLinesForPrefetch + 0.125), 1) 634 / 4; 635 636 dml_print("DML: VStartup: %d\n", VStartup); 637 dml_print("DML: TCalc: %f\n", TCalc); 638 dml_print("DML: TWait: %f\n", TWait); 639 dml_print("DML: XFCRemoteSurfaceFlipDelay: %f\n", XFCRemoteSurfaceFlipDelay); 640 dml_print("DML: LineTime: %f\n", LineTime); 641 dml_print("DML: Tsetup: %f\n", Tsetup); 642 dml_print("DML: Tdm: %f\n", Tdm); 643 dml_print("DML: DSTYAfterScaler: %f\n", *DSTYAfterScaler); 644 dml_print("DML: DSTXAfterScaler: %f\n", *DSTXAfterScaler); 645 dml_print("DML: HTotal: %d\n", HTotal); 646 647 *PrefetchBandwidth = 0; 648 *DestinationLinesToRequestVMInVBlank = 0; 649 *DestinationLinesToRequestRowInVBlank = 0; 650 *VRatioPrefetchY = 0; 651 *VRatioPrefetchC = 0; 652 *RequiredPrefetchPixDataBW = 0; 653 if (*DestinationLinesForPrefetch > 1) { 654 *PrefetchBandwidth = (PDEAndMetaPTEBytesFrame + 2 * MetaRowByte 655 + 2 * PixelPTEBytesPerRow 656 + PrefetchSourceLinesY * SwathWidthY * dml_ceil(BytePerPixelDETY, 1) 657 + PrefetchSourceLinesC * SwathWidthY / 2 658 * dml_ceil(BytePerPixelDETC, 2)) 659 / (*DestinationLinesForPrefetch * LineTime - *Tno_bw); 660 if (GPUVMEnable) { 661 TimeForFetchingMetaPTE = 662 dml_max( 663 *Tno_bw 664 + (double) PDEAndMetaPTEBytesFrame 665 / *PrefetchBandwidth, 666 dml_max( 667 UrgentExtraLatency 668 + UrgentLatencyPixelDataOnly 669 * (PageTableLevels 670 - 1), 671 LineTime / 4)); 672 } else { 673 if (NumberOfCursors > 0 || XFCEnabled) 674 TimeForFetchingMetaPTE = LineTime / 4; 675 else 676 TimeForFetchingMetaPTE = 0.0; 677 } 678 679 if ((GPUVMEnable == true || DCCEnable == true)) { 680 TimeForFetchingRowInVBlank = 681 dml_max( 682 (MetaRowByte + PixelPTEBytesPerRow) 683 / *PrefetchBandwidth, 684 dml_max( 685 UrgentLatencyPixelDataOnly, 686 dml_max( 687 LineTime 688 - TimeForFetchingMetaPTE, 689 LineTime 690 / 4.0))); 691 } else { 692 if (NumberOfCursors > 0 || XFCEnabled) 693 TimeForFetchingRowInVBlank = LineTime - TimeForFetchingMetaPTE; 694 else 695 TimeForFetchingRowInVBlank = 0.0; 696 } 697 698 *DestinationLinesToRequestVMInVBlank = dml_floor( 699 4.0 * (TimeForFetchingMetaPTE / LineTime + 0.125), 700 1) / 4.0; 701 702 *DestinationLinesToRequestRowInVBlank = dml_floor( 703 4.0 * (TimeForFetchingRowInVBlank / LineTime + 0.125), 704 1) / 4.0; 705 706 LinesToRequestPrefetchPixelData = 707 *DestinationLinesForPrefetch 708 - ((NumberOfCursors > 0 || GPUVMEnable 709 || DCCEnable) ? 710 (*DestinationLinesToRequestVMInVBlank 711 + *DestinationLinesToRequestRowInVBlank) : 712 0.0); 713 714 if (LinesToRequestPrefetchPixelData > 0) { 715 716 *VRatioPrefetchY = (double) PrefetchSourceLinesY 717 / LinesToRequestPrefetchPixelData; 718 *VRatioPrefetchY = dml_max(*VRatioPrefetchY, 1.0); 719 if ((SwathHeightY > 4) && (VInitPreFillY > 3)) { 720 if (LinesToRequestPrefetchPixelData > (VInitPreFillY - 3.0) / 2.0) { 721 *VRatioPrefetchY = 722 dml_max( 723 (double) PrefetchSourceLinesY 724 / LinesToRequestPrefetchPixelData, 725 (double) MaxNumSwathY 726 * SwathHeightY 727 / (LinesToRequestPrefetchPixelData 728 - (VInitPreFillY 729 - 3.0) 730 / 2.0)); 731 *VRatioPrefetchY = dml_max(*VRatioPrefetchY, 1.0); 732 } else { 733 MyError = true; 734 *VRatioPrefetchY = 0; 735 } 736 } 737 738 *VRatioPrefetchC = (double) PrefetchSourceLinesC 739 / LinesToRequestPrefetchPixelData; 740 *VRatioPrefetchC = dml_max(*VRatioPrefetchC, 1.0); 741 742 if ((SwathHeightC > 4)) { 743 if (LinesToRequestPrefetchPixelData > (VInitPreFillC - 3.0) / 2.0) { 744 *VRatioPrefetchC = 745 dml_max( 746 *VRatioPrefetchC, 747 (double) MaxNumSwathC 748 * SwathHeightC 749 / (LinesToRequestPrefetchPixelData 750 - (VInitPreFillC 751 - 3.0) 752 / 2.0)); 753 *VRatioPrefetchC = dml_max(*VRatioPrefetchC, 1.0); 754 } else { 755 MyError = true; 756 *VRatioPrefetchC = 0; 757 } 758 } 759 760 *RequiredPrefetchPixDataBW = 761 DPPPerPlane 762 * ((double) PrefetchSourceLinesY 763 / LinesToRequestPrefetchPixelData 764 * dml_ceil( 765 BytePerPixelDETY, 766 1) 767 + (double) PrefetchSourceLinesC 768 / LinesToRequestPrefetchPixelData 769 * dml_ceil( 770 BytePerPixelDETC, 771 2) 772 / 2) 773 * SwathWidthY / LineTime; 774 } else { 775 MyError = true; 776 *VRatioPrefetchY = 0; 777 *VRatioPrefetchC = 0; 778 *RequiredPrefetchPixDataBW = 0; 779 } 780 781 } else { 782 MyError = true; 783 } 784 785 if (MyError) { 786 *PrefetchBandwidth = 0; 787 TimeForFetchingMetaPTE = 0; 788 TimeForFetchingRowInVBlank = 0; 789 *DestinationLinesToRequestVMInVBlank = 0; 790 *DestinationLinesToRequestRowInVBlank = 0; 791 *DestinationLinesForPrefetch = 0; 792 LinesToRequestPrefetchPixelData = 0; 793 *VRatioPrefetchY = 0; 794 *VRatioPrefetchC = 0; 795 *RequiredPrefetchPixDataBW = 0; 796 } 797 798 return MyError; 799 } 800 801 static double RoundToDFSGranularityUp(double Clock, double VCOSpeed) 802 { 803 return VCOSpeed * 4 / dml_floor(VCOSpeed * 4 / Clock, 1); 804 } 805 806 static double RoundToDFSGranularityDown(double Clock, double VCOSpeed) 807 { 808 return VCOSpeed * 4 / dml_ceil(VCOSpeed * 4 / Clock, 1); 809 } 810 811 static double CalculatePrefetchSourceLines( 812 struct display_mode_lib *mode_lib, 813 double VRatio, 814 double vtaps, 815 bool Interlace, 816 bool ProgressiveToInterlaceUnitInOPP, 817 unsigned int SwathHeight, 818 unsigned int ViewportYStart, 819 double *VInitPreFill, 820 unsigned int *MaxNumSwath) 821 { 822 unsigned int MaxPartialSwath; 823 824 if (ProgressiveToInterlaceUnitInOPP) 825 *VInitPreFill = dml_floor((VRatio + vtaps + 1) / 2.0, 1); 826 else 827 *VInitPreFill = dml_floor((VRatio + vtaps + 1 + Interlace * 0.5 * VRatio) / 2.0, 1); 828 829 if (!mode_lib->vba.IgnoreViewportPositioning) { 830 831 *MaxNumSwath = dml_ceil((*VInitPreFill - 1.0) / SwathHeight, 1) + 1.0; 832 833 if (*VInitPreFill > 1.0) 834 MaxPartialSwath = (unsigned int) (*VInitPreFill - 2) % SwathHeight; 835 else 836 MaxPartialSwath = (unsigned int) (*VInitPreFill + SwathHeight - 2) 837 % SwathHeight; 838 MaxPartialSwath = dml_max(1U, MaxPartialSwath); 839 840 } else { 841 842 if (ViewportYStart != 0) 843 dml_print( 844 "WARNING DML: using viewport y position of 0 even though actual viewport y position is non-zero in prefetch source lines calculation\n"); 845 846 *MaxNumSwath = dml_ceil(*VInitPreFill / SwathHeight, 1); 847 848 if (*VInitPreFill > 1.0) 849 MaxPartialSwath = (unsigned int) (*VInitPreFill - 1) % SwathHeight; 850 else 851 MaxPartialSwath = (unsigned int) (*VInitPreFill + SwathHeight - 1) 852 % SwathHeight; 853 } 854 855 return *MaxNumSwath * SwathHeight + MaxPartialSwath; 856 } 857 858 static unsigned int CalculateVMAndRowBytes( 859 struct display_mode_lib *mode_lib, 860 bool DCCEnable, 861 unsigned int BlockHeight256Bytes, 862 unsigned int BlockWidth256Bytes, 863 enum source_format_class SourcePixelFormat, 864 unsigned int SurfaceTiling, 865 unsigned int BytePerPixel, 866 enum scan_direction_class ScanDirection, 867 unsigned int ViewportWidth, 868 unsigned int ViewportHeight, 869 unsigned int SwathWidth, 870 bool GPUVMEnable, 871 unsigned int VMMPageSize, 872 unsigned int PTEBufferSizeInRequestsLuma, 873 unsigned int PDEProcessingBufIn64KBReqs, 874 unsigned int Pitch, 875 unsigned int DCCMetaPitch, 876 unsigned int *MacroTileWidth, 877 unsigned int *MetaRowByte, 878 unsigned int *PixelPTEBytesPerRow, 879 bool *PTEBufferSizeNotExceeded, 880 unsigned int *dpte_row_height, 881 unsigned int *meta_row_height) 882 { 883 unsigned int MetaRequestHeight; 884 unsigned int MetaRequestWidth; 885 unsigned int MetaSurfWidth; 886 unsigned int MetaSurfHeight; 887 unsigned int MPDEBytesFrame; 888 unsigned int MetaPTEBytesFrame; 889 unsigned int DCCMetaSurfaceBytes; 890 891 unsigned int MacroTileSizeBytes; 892 unsigned int MacroTileHeight; 893 unsigned int DPDE0BytesFrame; 894 unsigned int ExtraDPDEBytesFrame; 895 unsigned int PDEAndMetaPTEBytesFrame; 896 897 if (DCCEnable == true) { 898 MetaRequestHeight = 8 * BlockHeight256Bytes; 899 MetaRequestWidth = 8 * BlockWidth256Bytes; 900 if (ScanDirection == dm_horz) { 901 *meta_row_height = MetaRequestHeight; 902 MetaSurfWidth = dml_ceil((double) SwathWidth - 1, MetaRequestWidth) 903 + MetaRequestWidth; 904 *MetaRowByte = MetaSurfWidth * MetaRequestHeight * BytePerPixel / 256.0; 905 } else { 906 *meta_row_height = MetaRequestWidth; 907 MetaSurfHeight = dml_ceil((double) SwathWidth - 1, MetaRequestHeight) 908 + MetaRequestHeight; 909 *MetaRowByte = MetaSurfHeight * MetaRequestWidth * BytePerPixel / 256.0; 910 } 911 if (ScanDirection == dm_horz) { 912 DCCMetaSurfaceBytes = DCCMetaPitch 913 * (dml_ceil(ViewportHeight - 1, 64 * BlockHeight256Bytes) 914 + 64 * BlockHeight256Bytes) * BytePerPixel 915 / 256; 916 } else { 917 DCCMetaSurfaceBytes = DCCMetaPitch 918 * (dml_ceil( 919 (double) ViewportHeight - 1, 920 64 * BlockHeight256Bytes) 921 + 64 * BlockHeight256Bytes) * BytePerPixel 922 / 256; 923 } 924 if (GPUVMEnable == true) { 925 MetaPTEBytesFrame = (dml_ceil( 926 (double) (DCCMetaSurfaceBytes - VMMPageSize) 927 / (8 * VMMPageSize), 928 1) + 1) * 64; 929 MPDEBytesFrame = 128 * (mode_lib->vba.GPUVMMaxPageTableLevels - 1); 930 } else { 931 MetaPTEBytesFrame = 0; 932 MPDEBytesFrame = 0; 933 } 934 } else { 935 MetaPTEBytesFrame = 0; 936 MPDEBytesFrame = 0; 937 *MetaRowByte = 0; 938 } 939 940 if (SurfaceTiling == dm_sw_linear || SurfaceTiling == dm_sw_gfx7_2d_thin_gl || SurfaceTiling == dm_sw_gfx7_2d_thin_lvp) { 941 MacroTileSizeBytes = 256; 942 MacroTileHeight = BlockHeight256Bytes; 943 } else if (SurfaceTiling == dm_sw_4kb_s || SurfaceTiling == dm_sw_4kb_s_x 944 || SurfaceTiling == dm_sw_4kb_d || SurfaceTiling == dm_sw_4kb_d_x) { 945 MacroTileSizeBytes = 4096; 946 MacroTileHeight = 4 * BlockHeight256Bytes; 947 } else if (SurfaceTiling == dm_sw_64kb_s || SurfaceTiling == dm_sw_64kb_s_t 948 || SurfaceTiling == dm_sw_64kb_s_x || SurfaceTiling == dm_sw_64kb_d 949 || SurfaceTiling == dm_sw_64kb_d_t || SurfaceTiling == dm_sw_64kb_d_x 950 || SurfaceTiling == dm_sw_64kb_r_x) { 951 MacroTileSizeBytes = 65536; 952 MacroTileHeight = 16 * BlockHeight256Bytes; 953 } else { 954 MacroTileSizeBytes = 262144; 955 MacroTileHeight = 32 * BlockHeight256Bytes; 956 } 957 *MacroTileWidth = MacroTileSizeBytes / BytePerPixel / MacroTileHeight; 958 959 if (GPUVMEnable == true && mode_lib->vba.GPUVMMaxPageTableLevels > 1) { 960 if (ScanDirection == dm_horz) { 961 DPDE0BytesFrame = 962 64 963 * (dml_ceil( 964 ((Pitch 965 * (dml_ceil( 966 ViewportHeight 967 - 1, 968 MacroTileHeight) 969 + MacroTileHeight) 970 * BytePerPixel) 971 - MacroTileSizeBytes) 972 / (8 973 * 2097152), 974 1) + 1); 975 } else { 976 DPDE0BytesFrame = 977 64 978 * (dml_ceil( 979 ((Pitch 980 * (dml_ceil( 981 (double) SwathWidth 982 - 1, 983 MacroTileHeight) 984 + MacroTileHeight) 985 * BytePerPixel) 986 - MacroTileSizeBytes) 987 / (8 988 * 2097152), 989 1) + 1); 990 } 991 ExtraDPDEBytesFrame = 128 * (mode_lib->vba.GPUVMMaxPageTableLevels - 2); 992 } else { 993 DPDE0BytesFrame = 0; 994 ExtraDPDEBytesFrame = 0; 995 } 996 997 PDEAndMetaPTEBytesFrame = MetaPTEBytesFrame + MPDEBytesFrame + DPDE0BytesFrame 998 + ExtraDPDEBytesFrame; 999 1000 if (GPUVMEnable == true) { 1001 unsigned int PTERequestSize; 1002 unsigned int PixelPTEReqHeight; 1003 unsigned int PixelPTEReqWidth; 1004 double FractionOfPTEReturnDrop; 1005 unsigned int EffectivePDEProcessingBufIn64KBReqs; 1006 1007 if (SurfaceTiling == dm_sw_linear) { 1008 PixelPTEReqHeight = 1; 1009 PixelPTEReqWidth = 8.0 * VMMPageSize / BytePerPixel; 1010 PTERequestSize = 64; 1011 FractionOfPTEReturnDrop = 0; 1012 } else if (MacroTileSizeBytes == 4096) { 1013 PixelPTEReqHeight = MacroTileHeight; 1014 PixelPTEReqWidth = 8 * *MacroTileWidth; 1015 PTERequestSize = 64; 1016 if (ScanDirection == dm_horz) 1017 FractionOfPTEReturnDrop = 0; 1018 else 1019 FractionOfPTEReturnDrop = 7 / 8; 1020 } else if (VMMPageSize == 4096 && MacroTileSizeBytes > 4096) { 1021 PixelPTEReqHeight = 16 * BlockHeight256Bytes; 1022 PixelPTEReqWidth = 16 * BlockWidth256Bytes; 1023 PTERequestSize = 128; 1024 FractionOfPTEReturnDrop = 0; 1025 } else { 1026 PixelPTEReqHeight = MacroTileHeight; 1027 PixelPTEReqWidth = 8 * *MacroTileWidth; 1028 PTERequestSize = 64; 1029 FractionOfPTEReturnDrop = 0; 1030 } 1031 1032 if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10) 1033 EffectivePDEProcessingBufIn64KBReqs = PDEProcessingBufIn64KBReqs / 2; 1034 else 1035 EffectivePDEProcessingBufIn64KBReqs = PDEProcessingBufIn64KBReqs; 1036 1037 if (SurfaceTiling == dm_sw_linear) { 1038 *dpte_row_height = 1039 dml_min( 1040 128, 1041 1 1042 << (unsigned int) dml_floor( 1043 dml_log2( 1044 dml_min( 1045 (double) PTEBufferSizeInRequestsLuma 1046 * PixelPTEReqWidth, 1047 EffectivePDEProcessingBufIn64KBReqs 1048 * 65536.0 1049 / BytePerPixel) 1050 / Pitch), 1051 1)); 1052 *PixelPTEBytesPerRow = PTERequestSize 1053 * (dml_ceil( 1054 (double) (Pitch * *dpte_row_height - 1) 1055 / PixelPTEReqWidth, 1056 1) + 1); 1057 } else if (ScanDirection == dm_horz) { 1058 *dpte_row_height = PixelPTEReqHeight; 1059 *PixelPTEBytesPerRow = PTERequestSize 1060 * (dml_ceil(((double) SwathWidth - 1) / PixelPTEReqWidth, 1) 1061 + 1); 1062 } else { 1063 *dpte_row_height = dml_min(PixelPTEReqWidth, *MacroTileWidth); 1064 *PixelPTEBytesPerRow = PTERequestSize 1065 * (dml_ceil( 1066 ((double) SwathWidth - 1) 1067 / PixelPTEReqHeight, 1068 1) + 1); 1069 } 1070 if (*PixelPTEBytesPerRow * (1 - FractionOfPTEReturnDrop) 1071 <= 64 * PTEBufferSizeInRequestsLuma) { 1072 *PTEBufferSizeNotExceeded = true; 1073 } else { 1074 *PTEBufferSizeNotExceeded = false; 1075 } 1076 } else { 1077 *PixelPTEBytesPerRow = 0; 1078 *PTEBufferSizeNotExceeded = true; 1079 } 1080 1081 return PDEAndMetaPTEBytesFrame; 1082 } 1083 1084 static void dml20_DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation( 1085 struct display_mode_lib *mode_lib) 1086 { 1087 unsigned int j, k; 1088 1089 mode_lib->vba.WritebackDISPCLK = 0.0; 1090 mode_lib->vba.DISPCLKWithRamping = 0; 1091 mode_lib->vba.DISPCLKWithoutRamping = 0; 1092 mode_lib->vba.GlobalDPPCLK = 0.0; 1093 1094 // dml_ml->vba.DISPCLK and dml_ml->vba.DPPCLK Calculation 1095 // 1096 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1097 if (mode_lib->vba.WritebackEnable[k]) { 1098 mode_lib->vba.WritebackDISPCLK = 1099 dml_max( 1100 mode_lib->vba.WritebackDISPCLK, 1101 CalculateWriteBackDISPCLK( 1102 mode_lib->vba.WritebackPixelFormat[k], 1103 mode_lib->vba.PixelClock[k], 1104 mode_lib->vba.WritebackHRatio[k], 1105 mode_lib->vba.WritebackVRatio[k], 1106 mode_lib->vba.WritebackLumaHTaps[k], 1107 mode_lib->vba.WritebackLumaVTaps[k], 1108 mode_lib->vba.WritebackChromaHTaps[k], 1109 mode_lib->vba.WritebackChromaVTaps[k], 1110 mode_lib->vba.WritebackDestinationWidth[k], 1111 mode_lib->vba.HTotal[k], 1112 mode_lib->vba.WritebackChromaLineBufferWidth)); 1113 } 1114 } 1115 1116 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1117 if (mode_lib->vba.HRatio[k] > 1) { 1118 mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] = dml_min( 1119 mode_lib->vba.MaxDCHUBToPSCLThroughput, 1120 mode_lib->vba.MaxPSCLToLBThroughput 1121 * mode_lib->vba.HRatio[k] 1122 / dml_ceil( 1123 mode_lib->vba.htaps[k] 1124 / 6.0, 1125 1)); 1126 } else { 1127 mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] = dml_min( 1128 mode_lib->vba.MaxDCHUBToPSCLThroughput, 1129 mode_lib->vba.MaxPSCLToLBThroughput); 1130 } 1131 1132 mode_lib->vba.DPPCLKUsingSingleDPPLuma = 1133 mode_lib->vba.PixelClock[k] 1134 * dml_max( 1135 mode_lib->vba.vtaps[k] / 6.0 1136 * dml_min( 1137 1.0, 1138 mode_lib->vba.HRatio[k]), 1139 dml_max( 1140 mode_lib->vba.HRatio[k] 1141 * mode_lib->vba.VRatio[k] 1142 / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k], 1143 1.0)); 1144 1145 if ((mode_lib->vba.htaps[k] > 6 || mode_lib->vba.vtaps[k] > 6) 1146 && mode_lib->vba.DPPCLKUsingSingleDPPLuma 1147 < 2 * mode_lib->vba.PixelClock[k]) { 1148 mode_lib->vba.DPPCLKUsingSingleDPPLuma = 2 * mode_lib->vba.PixelClock[k]; 1149 } 1150 1151 if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8 1152 && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) { 1153 mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] = 0.0; 1154 mode_lib->vba.DPPCLKUsingSingleDPP[k] = 1155 mode_lib->vba.DPPCLKUsingSingleDPPLuma; 1156 } else { 1157 if (mode_lib->vba.HRatio[k] > 1) { 1158 mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] = 1159 dml_min( 1160 mode_lib->vba.MaxDCHUBToPSCLThroughput, 1161 mode_lib->vba.MaxPSCLToLBThroughput 1162 * mode_lib->vba.HRatio[k] 1163 / 2 1164 / dml_ceil( 1165 mode_lib->vba.HTAPsChroma[k] 1166 / 6.0, 1167 1.0)); 1168 } else { 1169 mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] = dml_min( 1170 mode_lib->vba.MaxDCHUBToPSCLThroughput, 1171 mode_lib->vba.MaxPSCLToLBThroughput); 1172 } 1173 mode_lib->vba.DPPCLKUsingSingleDPPChroma = 1174 mode_lib->vba.PixelClock[k] 1175 * dml_max( 1176 mode_lib->vba.VTAPsChroma[k] 1177 / 6.0 1178 * dml_min( 1179 1.0, 1180 mode_lib->vba.HRatio[k] 1181 / 2), 1182 dml_max( 1183 mode_lib->vba.HRatio[k] 1184 * mode_lib->vba.VRatio[k] 1185 / 4 1186 / mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k], 1187 1.0)); 1188 1189 if ((mode_lib->vba.HTAPsChroma[k] > 6 || mode_lib->vba.VTAPsChroma[k] > 6) 1190 && mode_lib->vba.DPPCLKUsingSingleDPPChroma 1191 < 2 * mode_lib->vba.PixelClock[k]) { 1192 mode_lib->vba.DPPCLKUsingSingleDPPChroma = 2 1193 * mode_lib->vba.PixelClock[k]; 1194 } 1195 1196 mode_lib->vba.DPPCLKUsingSingleDPP[k] = dml_max( 1197 mode_lib->vba.DPPCLKUsingSingleDPPLuma, 1198 mode_lib->vba.DPPCLKUsingSingleDPPChroma); 1199 } 1200 } 1201 1202 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1203 if (mode_lib->vba.BlendingAndTiming[k] != k) 1204 continue; 1205 if (mode_lib->vba.ODMCombineEnabled[k]) { 1206 mode_lib->vba.DISPCLKWithRamping = 1207 dml_max( 1208 mode_lib->vba.DISPCLKWithRamping, 1209 mode_lib->vba.PixelClock[k] / 2 1210 * (1 1211 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading 1212 / 100) 1213 * (1 1214 + mode_lib->vba.DISPCLKRampingMargin 1215 / 100)); 1216 mode_lib->vba.DISPCLKWithoutRamping = 1217 dml_max( 1218 mode_lib->vba.DISPCLKWithoutRamping, 1219 mode_lib->vba.PixelClock[k] / 2 1220 * (1 1221 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading 1222 / 100)); 1223 } else if (!mode_lib->vba.ODMCombineEnabled[k]) { 1224 mode_lib->vba.DISPCLKWithRamping = 1225 dml_max( 1226 mode_lib->vba.DISPCLKWithRamping, 1227 mode_lib->vba.PixelClock[k] 1228 * (1 1229 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading 1230 / 100) 1231 * (1 1232 + mode_lib->vba.DISPCLKRampingMargin 1233 / 100)); 1234 mode_lib->vba.DISPCLKWithoutRamping = 1235 dml_max( 1236 mode_lib->vba.DISPCLKWithoutRamping, 1237 mode_lib->vba.PixelClock[k] 1238 * (1 1239 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading 1240 / 100)); 1241 } 1242 } 1243 1244 mode_lib->vba.DISPCLKWithRamping = dml_max( 1245 mode_lib->vba.DISPCLKWithRamping, 1246 mode_lib->vba.WritebackDISPCLK); 1247 mode_lib->vba.DISPCLKWithoutRamping = dml_max( 1248 mode_lib->vba.DISPCLKWithoutRamping, 1249 mode_lib->vba.WritebackDISPCLK); 1250 1251 ASSERT(mode_lib->vba.DISPCLKDPPCLKVCOSpeed != 0); 1252 mode_lib->vba.DISPCLKWithRampingRoundedToDFSGranularity = RoundToDFSGranularityUp( 1253 mode_lib->vba.DISPCLKWithRamping, 1254 mode_lib->vba.DISPCLKDPPCLKVCOSpeed); 1255 mode_lib->vba.DISPCLKWithoutRampingRoundedToDFSGranularity = RoundToDFSGranularityUp( 1256 mode_lib->vba.DISPCLKWithoutRamping, 1257 mode_lib->vba.DISPCLKDPPCLKVCOSpeed); 1258 mode_lib->vba.MaxDispclkRoundedToDFSGranularity = RoundToDFSGranularityDown( 1259 mode_lib->vba.soc.clock_limits[mode_lib->vba.soc.num_states].dispclk_mhz, 1260 mode_lib->vba.DISPCLKDPPCLKVCOSpeed); 1261 if (mode_lib->vba.DISPCLKWithoutRampingRoundedToDFSGranularity 1262 > mode_lib->vba.MaxDispclkRoundedToDFSGranularity) { 1263 mode_lib->vba.DISPCLK_calculated = 1264 mode_lib->vba.DISPCLKWithoutRampingRoundedToDFSGranularity; 1265 } else if (mode_lib->vba.DISPCLKWithRampingRoundedToDFSGranularity 1266 > mode_lib->vba.MaxDispclkRoundedToDFSGranularity) { 1267 mode_lib->vba.DISPCLK_calculated = mode_lib->vba.MaxDispclkRoundedToDFSGranularity; 1268 } else { 1269 mode_lib->vba.DISPCLK_calculated = 1270 mode_lib->vba.DISPCLKWithRampingRoundedToDFSGranularity; 1271 } 1272 DTRACE(" dispclk_mhz (calculated) = %f", mode_lib->vba.DISPCLK_calculated); 1273 1274 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1275 if (mode_lib->vba.DPPPerPlane[k] == 0) { 1276 mode_lib->vba.DPPCLK_calculated[k] = 0; 1277 } else { 1278 mode_lib->vba.DPPCLK_calculated[k] = mode_lib->vba.DPPCLKUsingSingleDPP[k] 1279 / mode_lib->vba.DPPPerPlane[k] 1280 * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100); 1281 } 1282 mode_lib->vba.GlobalDPPCLK = dml_max( 1283 mode_lib->vba.GlobalDPPCLK, 1284 mode_lib->vba.DPPCLK_calculated[k]); 1285 } 1286 mode_lib->vba.GlobalDPPCLK = RoundToDFSGranularityUp( 1287 mode_lib->vba.GlobalDPPCLK, 1288 mode_lib->vba.DISPCLKDPPCLKVCOSpeed); 1289 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1290 mode_lib->vba.DPPCLK_calculated[k] = mode_lib->vba.GlobalDPPCLK / 255 1291 * dml_ceil( 1292 mode_lib->vba.DPPCLK_calculated[k] * 255 1293 / mode_lib->vba.GlobalDPPCLK, 1294 1); 1295 DTRACE(" dppclk_mhz[%i] (calculated) = %f", k, mode_lib->vba.DPPCLK_calculated[k]); 1296 } 1297 1298 // Urgent Watermark 1299 mode_lib->vba.DCCEnabledAnyPlane = false; 1300 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) 1301 if (mode_lib->vba.DCCEnable[k]) 1302 mode_lib->vba.DCCEnabledAnyPlane = true; 1303 1304 mode_lib->vba.ReturnBandwidthToDCN = dml_min( 1305 mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLK, 1306 mode_lib->vba.FabricAndDRAMBandwidth * 1000) 1307 * mode_lib->vba.PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly / 100; 1308 1309 mode_lib->vba.ReturnBW = mode_lib->vba.ReturnBandwidthToDCN; 1310 mode_lib->vba.ReturnBW = adjust_ReturnBW( 1311 mode_lib, 1312 mode_lib->vba.ReturnBW, 1313 mode_lib->vba.DCCEnabledAnyPlane, 1314 mode_lib->vba.ReturnBandwidthToDCN); 1315 1316 // Let's do this calculation again?? 1317 mode_lib->vba.ReturnBandwidthToDCN = dml_min( 1318 mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLK, 1319 mode_lib->vba.FabricAndDRAMBandwidth * 1000); 1320 mode_lib->vba.ReturnBW = adjust_ReturnBW( 1321 mode_lib, 1322 mode_lib->vba.ReturnBW, 1323 mode_lib->vba.DCCEnabledAnyPlane, 1324 mode_lib->vba.ReturnBandwidthToDCN); 1325 1326 DTRACE(" dcfclk_mhz = %f", mode_lib->vba.DCFCLK); 1327 DTRACE(" return_bw_to_dcn = %f", mode_lib->vba.ReturnBandwidthToDCN); 1328 DTRACE(" return_bus_bw = %f", mode_lib->vba.ReturnBW); 1329 1330 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1331 bool MainPlaneDoesODMCombine = false; 1332 1333 if (mode_lib->vba.SourceScan[k] == dm_horz) 1334 mode_lib->vba.SwathWidthSingleDPPY[k] = mode_lib->vba.ViewportWidth[k]; 1335 else 1336 mode_lib->vba.SwathWidthSingleDPPY[k] = mode_lib->vba.ViewportHeight[k]; 1337 1338 if (mode_lib->vba.ODMCombineEnabled[k] == true) 1339 MainPlaneDoesODMCombine = true; 1340 for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) 1341 if (mode_lib->vba.BlendingAndTiming[k] == j 1342 && mode_lib->vba.ODMCombineEnabled[j] == true) 1343 MainPlaneDoesODMCombine = true; 1344 1345 if (MainPlaneDoesODMCombine == true) 1346 mode_lib->vba.SwathWidthY[k] = dml_min( 1347 (double) mode_lib->vba.SwathWidthSingleDPPY[k], 1348 dml_round( 1349 mode_lib->vba.HActive[k] / 2.0 1350 * mode_lib->vba.HRatio[k])); 1351 else { 1352 if (mode_lib->vba.DPPPerPlane[k] == 0) { 1353 mode_lib->vba.SwathWidthY[k] = 0; 1354 } else { 1355 mode_lib->vba.SwathWidthY[k] = mode_lib->vba.SwathWidthSingleDPPY[k] 1356 / mode_lib->vba.DPPPerPlane[k]; 1357 } 1358 } 1359 } 1360 1361 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1362 if (mode_lib->vba.SourcePixelFormat[k] == dm_444_64) { 1363 mode_lib->vba.BytePerPixelDETY[k] = 8; 1364 mode_lib->vba.BytePerPixelDETC[k] = 0; 1365 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_32) { 1366 mode_lib->vba.BytePerPixelDETY[k] = 4; 1367 mode_lib->vba.BytePerPixelDETC[k] = 0; 1368 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_16) { 1369 mode_lib->vba.BytePerPixelDETY[k] = 2; 1370 mode_lib->vba.BytePerPixelDETC[k] = 0; 1371 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_8) { 1372 mode_lib->vba.BytePerPixelDETY[k] = 1; 1373 mode_lib->vba.BytePerPixelDETC[k] = 0; 1374 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8) { 1375 mode_lib->vba.BytePerPixelDETY[k] = 1; 1376 mode_lib->vba.BytePerPixelDETC[k] = 2; 1377 } else { // dm_420_10 1378 mode_lib->vba.BytePerPixelDETY[k] = 4.0 / 3.0; 1379 mode_lib->vba.BytePerPixelDETC[k] = 8.0 / 3.0; 1380 } 1381 } 1382 1383 mode_lib->vba.TotalDataReadBandwidth = 0.0; 1384 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1385 mode_lib->vba.ReadBandwidthPlaneLuma[k] = mode_lib->vba.SwathWidthSingleDPPY[k] 1386 * dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1) 1387 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) 1388 * mode_lib->vba.VRatio[k]; 1389 mode_lib->vba.ReadBandwidthPlaneChroma[k] = mode_lib->vba.SwathWidthSingleDPPY[k] 1390 / 2 * dml_ceil(mode_lib->vba.BytePerPixelDETC[k], 2) 1391 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) 1392 * mode_lib->vba.VRatio[k] / 2; 1393 DTRACE( 1394 " read_bw[%i] = %fBps", 1395 k, 1396 mode_lib->vba.ReadBandwidthPlaneLuma[k] 1397 + mode_lib->vba.ReadBandwidthPlaneChroma[k]); 1398 mode_lib->vba.TotalDataReadBandwidth += mode_lib->vba.ReadBandwidthPlaneLuma[k] 1399 + mode_lib->vba.ReadBandwidthPlaneChroma[k]; 1400 } 1401 1402 mode_lib->vba.TotalDCCActiveDPP = 0; 1403 mode_lib->vba.TotalActiveDPP = 0; 1404 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1405 mode_lib->vba.TotalActiveDPP = mode_lib->vba.TotalActiveDPP 1406 + mode_lib->vba.DPPPerPlane[k]; 1407 if (mode_lib->vba.DCCEnable[k]) 1408 mode_lib->vba.TotalDCCActiveDPP = mode_lib->vba.TotalDCCActiveDPP 1409 + mode_lib->vba.DPPPerPlane[k]; 1410 } 1411 1412 mode_lib->vba.UrgentRoundTripAndOutOfOrderLatency = 1413 (mode_lib->vba.RoundTripPingLatencyCycles + 32) / mode_lib->vba.DCFCLK 1414 + mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelDataOnly 1415 * mode_lib->vba.NumberOfChannels 1416 / mode_lib->vba.ReturnBW; 1417 1418 mode_lib->vba.LastPixelOfLineExtraWatermark = 0; 1419 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1420 double DataFabricLineDeliveryTimeLuma, DataFabricLineDeliveryTimeChroma; 1421 1422 if (mode_lib->vba.VRatio[k] <= 1.0) 1423 mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k] = 1424 (double) mode_lib->vba.SwathWidthY[k] 1425 * mode_lib->vba.DPPPerPlane[k] 1426 / mode_lib->vba.HRatio[k] 1427 / mode_lib->vba.PixelClock[k]; 1428 else 1429 mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k] = 1430 (double) mode_lib->vba.SwathWidthY[k] 1431 / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] 1432 / mode_lib->vba.DPPCLK[k]; 1433 1434 DataFabricLineDeliveryTimeLuma = mode_lib->vba.SwathWidthSingleDPPY[k] 1435 * mode_lib->vba.SwathHeightY[k] 1436 * dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1) 1437 / (mode_lib->vba.ReturnBW * mode_lib->vba.ReadBandwidthPlaneLuma[k] 1438 / mode_lib->vba.TotalDataReadBandwidth); 1439 mode_lib->vba.LastPixelOfLineExtraWatermark = dml_max( 1440 mode_lib->vba.LastPixelOfLineExtraWatermark, 1441 DataFabricLineDeliveryTimeLuma 1442 - mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k]); 1443 1444 if (mode_lib->vba.BytePerPixelDETC[k] == 0) 1445 mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k] = 0.0; 1446 else if (mode_lib->vba.VRatio[k] / 2.0 <= 1.0) 1447 mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k] = 1448 mode_lib->vba.SwathWidthY[k] / 2.0 1449 * mode_lib->vba.DPPPerPlane[k] 1450 / (mode_lib->vba.HRatio[k] / 2.0) 1451 / mode_lib->vba.PixelClock[k]; 1452 else 1453 mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k] = 1454 mode_lib->vba.SwathWidthY[k] / 2.0 1455 / mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] 1456 / mode_lib->vba.DPPCLK[k]; 1457 1458 DataFabricLineDeliveryTimeChroma = mode_lib->vba.SwathWidthSingleDPPY[k] / 2.0 1459 * mode_lib->vba.SwathHeightC[k] 1460 * dml_ceil(mode_lib->vba.BytePerPixelDETC[k], 2) 1461 / (mode_lib->vba.ReturnBW 1462 * mode_lib->vba.ReadBandwidthPlaneChroma[k] 1463 / mode_lib->vba.TotalDataReadBandwidth); 1464 mode_lib->vba.LastPixelOfLineExtraWatermark = 1465 dml_max( 1466 mode_lib->vba.LastPixelOfLineExtraWatermark, 1467 DataFabricLineDeliveryTimeChroma 1468 - mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k]); 1469 } 1470 1471 mode_lib->vba.UrgentExtraLatency = mode_lib->vba.UrgentRoundTripAndOutOfOrderLatency 1472 + (mode_lib->vba.TotalActiveDPP * mode_lib->vba.PixelChunkSizeInKByte 1473 + mode_lib->vba.TotalDCCActiveDPP 1474 * mode_lib->vba.MetaChunkSize) * 1024.0 1475 / mode_lib->vba.ReturnBW; 1476 1477 if (mode_lib->vba.GPUVMEnable) 1478 mode_lib->vba.UrgentExtraLatency += mode_lib->vba.TotalActiveDPP 1479 * mode_lib->vba.PTEGroupSize / mode_lib->vba.ReturnBW; 1480 1481 mode_lib->vba.UrgentWatermark = mode_lib->vba.UrgentLatencyPixelDataOnly 1482 + mode_lib->vba.LastPixelOfLineExtraWatermark 1483 + mode_lib->vba.UrgentExtraLatency; 1484 1485 DTRACE(" urgent_extra_latency = %fus", mode_lib->vba.UrgentExtraLatency); 1486 DTRACE(" wm_urgent = %fus", mode_lib->vba.UrgentWatermark); 1487 1488 mode_lib->vba.UrgentLatency = mode_lib->vba.UrgentLatencyPixelDataOnly; 1489 1490 mode_lib->vba.TotalActiveWriteback = 0; 1491 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1492 if (mode_lib->vba.WritebackEnable[k]) 1493 mode_lib->vba.TotalActiveWriteback = mode_lib->vba.TotalActiveWriteback + mode_lib->vba.ActiveWritebacksPerPlane[k]; 1494 } 1495 1496 if (mode_lib->vba.TotalActiveWriteback <= 1) 1497 mode_lib->vba.WritebackUrgentWatermark = mode_lib->vba.WritebackLatency; 1498 else 1499 mode_lib->vba.WritebackUrgentWatermark = mode_lib->vba.WritebackLatency 1500 + mode_lib->vba.WritebackChunkSize * 1024.0 / 32 1501 / mode_lib->vba.SOCCLK; 1502 1503 DTRACE(" wm_wb_urgent = %fus", mode_lib->vba.WritebackUrgentWatermark); 1504 1505 // NB P-State/DRAM Clock Change Watermark 1506 mode_lib->vba.DRAMClockChangeWatermark = mode_lib->vba.DRAMClockChangeLatency 1507 + mode_lib->vba.UrgentWatermark; 1508 1509 DTRACE(" wm_pstate_change = %fus", mode_lib->vba.DRAMClockChangeWatermark); 1510 1511 DTRACE(" calculating wb pstate watermark"); 1512 DTRACE(" total wb outputs %d", mode_lib->vba.TotalActiveWriteback); 1513 DTRACE(" socclk frequency %f Mhz", mode_lib->vba.SOCCLK); 1514 1515 if (mode_lib->vba.TotalActiveWriteback <= 1) 1516 mode_lib->vba.WritebackDRAMClockChangeWatermark = 1517 mode_lib->vba.DRAMClockChangeLatency 1518 + mode_lib->vba.WritebackLatency; 1519 else 1520 mode_lib->vba.WritebackDRAMClockChangeWatermark = 1521 mode_lib->vba.DRAMClockChangeLatency 1522 + mode_lib->vba.WritebackLatency 1523 + mode_lib->vba.WritebackChunkSize * 1024.0 / 32 1524 / mode_lib->vba.SOCCLK; 1525 1526 DTRACE(" wm_wb_pstate %fus", mode_lib->vba.WritebackDRAMClockChangeWatermark); 1527 1528 // Stutter Efficiency 1529 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1530 mode_lib->vba.LinesInDETY[k] = mode_lib->vba.DETBufferSizeY[k] 1531 / mode_lib->vba.BytePerPixelDETY[k] / mode_lib->vba.SwathWidthY[k]; 1532 mode_lib->vba.LinesInDETYRoundedDownToSwath[k] = dml_floor( 1533 mode_lib->vba.LinesInDETY[k], 1534 mode_lib->vba.SwathHeightY[k]); 1535 mode_lib->vba.FullDETBufferingTimeY[k] = 1536 mode_lib->vba.LinesInDETYRoundedDownToSwath[k] 1537 * (mode_lib->vba.HTotal[k] 1538 / mode_lib->vba.PixelClock[k]) 1539 / mode_lib->vba.VRatio[k]; 1540 if (mode_lib->vba.BytePerPixelDETC[k] > 0) { 1541 mode_lib->vba.LinesInDETC[k] = mode_lib->vba.DETBufferSizeC[k] 1542 / mode_lib->vba.BytePerPixelDETC[k] 1543 / (mode_lib->vba.SwathWidthY[k] / 2); 1544 mode_lib->vba.LinesInDETCRoundedDownToSwath[k] = dml_floor( 1545 mode_lib->vba.LinesInDETC[k], 1546 mode_lib->vba.SwathHeightC[k]); 1547 mode_lib->vba.FullDETBufferingTimeC[k] = 1548 mode_lib->vba.LinesInDETCRoundedDownToSwath[k] 1549 * (mode_lib->vba.HTotal[k] 1550 / mode_lib->vba.PixelClock[k]) 1551 / (mode_lib->vba.VRatio[k] / 2); 1552 } else { 1553 mode_lib->vba.LinesInDETC[k] = 0; 1554 mode_lib->vba.LinesInDETCRoundedDownToSwath[k] = 0; 1555 mode_lib->vba.FullDETBufferingTimeC[k] = 999999; 1556 } 1557 } 1558 1559 mode_lib->vba.MinFullDETBufferingTime = 999999.0; 1560 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1561 if (mode_lib->vba.FullDETBufferingTimeY[k] 1562 < mode_lib->vba.MinFullDETBufferingTime) { 1563 mode_lib->vba.MinFullDETBufferingTime = 1564 mode_lib->vba.FullDETBufferingTimeY[k]; 1565 mode_lib->vba.FrameTimeForMinFullDETBufferingTime = 1566 (double) mode_lib->vba.VTotal[k] * mode_lib->vba.HTotal[k] 1567 / mode_lib->vba.PixelClock[k]; 1568 } 1569 if (mode_lib->vba.FullDETBufferingTimeC[k] 1570 < mode_lib->vba.MinFullDETBufferingTime) { 1571 mode_lib->vba.MinFullDETBufferingTime = 1572 mode_lib->vba.FullDETBufferingTimeC[k]; 1573 mode_lib->vba.FrameTimeForMinFullDETBufferingTime = 1574 (double) mode_lib->vba.VTotal[k] * mode_lib->vba.HTotal[k] 1575 / mode_lib->vba.PixelClock[k]; 1576 } 1577 } 1578 1579 mode_lib->vba.AverageReadBandwidthGBytePerSecond = 0.0; 1580 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1581 if (mode_lib->vba.DCCEnable[k]) { 1582 mode_lib->vba.AverageReadBandwidthGBytePerSecond = 1583 mode_lib->vba.AverageReadBandwidthGBytePerSecond 1584 + mode_lib->vba.ReadBandwidthPlaneLuma[k] 1585 / mode_lib->vba.DCCRate[k] 1586 / 1000 1587 + mode_lib->vba.ReadBandwidthPlaneChroma[k] 1588 / mode_lib->vba.DCCRate[k] 1589 / 1000; 1590 } else { 1591 mode_lib->vba.AverageReadBandwidthGBytePerSecond = 1592 mode_lib->vba.AverageReadBandwidthGBytePerSecond 1593 + mode_lib->vba.ReadBandwidthPlaneLuma[k] 1594 / 1000 1595 + mode_lib->vba.ReadBandwidthPlaneChroma[k] 1596 / 1000; 1597 } 1598 if (mode_lib->vba.DCCEnable[k]) { 1599 mode_lib->vba.AverageReadBandwidthGBytePerSecond = 1600 mode_lib->vba.AverageReadBandwidthGBytePerSecond 1601 + mode_lib->vba.ReadBandwidthPlaneLuma[k] 1602 / 1000 / 256 1603 + mode_lib->vba.ReadBandwidthPlaneChroma[k] 1604 / 1000 / 256; 1605 } 1606 if (mode_lib->vba.GPUVMEnable) { 1607 mode_lib->vba.AverageReadBandwidthGBytePerSecond = 1608 mode_lib->vba.AverageReadBandwidthGBytePerSecond 1609 + mode_lib->vba.ReadBandwidthPlaneLuma[k] 1610 / 1000 / 512 1611 + mode_lib->vba.ReadBandwidthPlaneChroma[k] 1612 / 1000 / 512; 1613 } 1614 } 1615 1616 mode_lib->vba.PartOfBurstThatFitsInROB = 1617 dml_min( 1618 mode_lib->vba.MinFullDETBufferingTime 1619 * mode_lib->vba.TotalDataReadBandwidth, 1620 mode_lib->vba.ROBBufferSizeInKByte * 1024 1621 * mode_lib->vba.TotalDataReadBandwidth 1622 / (mode_lib->vba.AverageReadBandwidthGBytePerSecond 1623 * 1000)); 1624 mode_lib->vba.StutterBurstTime = mode_lib->vba.PartOfBurstThatFitsInROB 1625 * (mode_lib->vba.AverageReadBandwidthGBytePerSecond * 1000) 1626 / mode_lib->vba.TotalDataReadBandwidth / mode_lib->vba.ReturnBW 1627 + (mode_lib->vba.MinFullDETBufferingTime 1628 * mode_lib->vba.TotalDataReadBandwidth 1629 - mode_lib->vba.PartOfBurstThatFitsInROB) 1630 / (mode_lib->vba.DCFCLK * 64); 1631 if (mode_lib->vba.TotalActiveWriteback == 0) { 1632 mode_lib->vba.StutterEfficiencyNotIncludingVBlank = (1 1633 - (mode_lib->vba.SRExitTime + mode_lib->vba.StutterBurstTime) 1634 / mode_lib->vba.MinFullDETBufferingTime) * 100; 1635 } else { 1636 mode_lib->vba.StutterEfficiencyNotIncludingVBlank = 0; 1637 } 1638 1639 mode_lib->vba.SmallestVBlank = 999999; 1640 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1641 if (mode_lib->vba.SynchronizedVBlank || mode_lib->vba.NumberOfActivePlanes == 1) { 1642 mode_lib->vba.VBlankTime = (double) (mode_lib->vba.VTotal[k] 1643 - mode_lib->vba.VActive[k]) * mode_lib->vba.HTotal[k] 1644 / mode_lib->vba.PixelClock[k]; 1645 } else { 1646 mode_lib->vba.VBlankTime = 0; 1647 } 1648 mode_lib->vba.SmallestVBlank = dml_min( 1649 mode_lib->vba.SmallestVBlank, 1650 mode_lib->vba.VBlankTime); 1651 } 1652 1653 mode_lib->vba.StutterEfficiency = (mode_lib->vba.StutterEfficiencyNotIncludingVBlank / 100 1654 * (mode_lib->vba.FrameTimeForMinFullDETBufferingTime 1655 - mode_lib->vba.SmallestVBlank) 1656 + mode_lib->vba.SmallestVBlank) 1657 / mode_lib->vba.FrameTimeForMinFullDETBufferingTime * 100; 1658 1659 // dml_ml->vba.DCFCLK Deep Sleep 1660 mode_lib->vba.DCFCLKDeepSleep = 8.0; 1661 1662 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; k++) { 1663 if (mode_lib->vba.BytePerPixelDETC[k] > 0) { 1664 mode_lib->vba.DCFCLKDeepSleepPerPlane[k] = 1665 dml_max( 1666 1.1 * mode_lib->vba.SwathWidthY[k] 1667 * dml_ceil( 1668 mode_lib->vba.BytePerPixelDETY[k], 1669 1) / 32 1670 / mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k], 1671 1.1 * mode_lib->vba.SwathWidthY[k] / 2.0 1672 * dml_ceil( 1673 mode_lib->vba.BytePerPixelDETC[k], 1674 2) / 32 1675 / mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k]); 1676 } else 1677 mode_lib->vba.DCFCLKDeepSleepPerPlane[k] = 1.1 * mode_lib->vba.SwathWidthY[k] 1678 * dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1) / 64.0 1679 / mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k]; 1680 mode_lib->vba.DCFCLKDeepSleepPerPlane[k] = dml_max( 1681 mode_lib->vba.DCFCLKDeepSleepPerPlane[k], 1682 mode_lib->vba.PixelClock[k] / 16.0); 1683 mode_lib->vba.DCFCLKDeepSleep = dml_max( 1684 mode_lib->vba.DCFCLKDeepSleep, 1685 mode_lib->vba.DCFCLKDeepSleepPerPlane[k]); 1686 1687 DTRACE( 1688 " dcfclk_deepsleep_per_plane[%i] = %fMHz", 1689 k, 1690 mode_lib->vba.DCFCLKDeepSleepPerPlane[k]); 1691 } 1692 1693 DTRACE(" dcfclk_deepsleep_mhz = %fMHz", mode_lib->vba.DCFCLKDeepSleep); 1694 1695 // Stutter Watermark 1696 mode_lib->vba.StutterExitWatermark = mode_lib->vba.SRExitTime 1697 + mode_lib->vba.LastPixelOfLineExtraWatermark 1698 + mode_lib->vba.UrgentExtraLatency + 10 / mode_lib->vba.DCFCLKDeepSleep; 1699 mode_lib->vba.StutterEnterPlusExitWatermark = mode_lib->vba.SREnterPlusExitTime 1700 + mode_lib->vba.LastPixelOfLineExtraWatermark 1701 + mode_lib->vba.UrgentExtraLatency; 1702 1703 DTRACE(" wm_cstate_exit = %fus", mode_lib->vba.StutterExitWatermark); 1704 DTRACE(" wm_cstate_enter_exit = %fus", mode_lib->vba.StutterEnterPlusExitWatermark); 1705 1706 // Urgent Latency Supported 1707 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1708 mode_lib->vba.EffectiveDETPlusLBLinesLuma = 1709 dml_floor( 1710 mode_lib->vba.LinesInDETY[k] 1711 + dml_min( 1712 mode_lib->vba.LinesInDETY[k] 1713 * mode_lib->vba.DPPCLK[k] 1714 * mode_lib->vba.BytePerPixelDETY[k] 1715 * mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] 1716 / (mode_lib->vba.ReturnBW 1717 / mode_lib->vba.DPPPerPlane[k]), 1718 (double) mode_lib->vba.EffectiveLBLatencyHidingSourceLinesLuma), 1719 mode_lib->vba.SwathHeightY[k]); 1720 1721 mode_lib->vba.UrgentLatencySupportUsLuma = mode_lib->vba.EffectiveDETPlusLBLinesLuma 1722 * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) 1723 / mode_lib->vba.VRatio[k] 1724 - mode_lib->vba.EffectiveDETPlusLBLinesLuma 1725 * mode_lib->vba.SwathWidthY[k] 1726 * mode_lib->vba.BytePerPixelDETY[k] 1727 / (mode_lib->vba.ReturnBW 1728 / mode_lib->vba.DPPPerPlane[k]); 1729 1730 if (mode_lib->vba.BytePerPixelDETC[k] > 0) { 1731 mode_lib->vba.EffectiveDETPlusLBLinesChroma = 1732 dml_floor( 1733 mode_lib->vba.LinesInDETC[k] 1734 + dml_min( 1735 mode_lib->vba.LinesInDETC[k] 1736 * mode_lib->vba.DPPCLK[k] 1737 * mode_lib->vba.BytePerPixelDETC[k] 1738 * mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] 1739 / (mode_lib->vba.ReturnBW 1740 / mode_lib->vba.DPPPerPlane[k]), 1741 (double) mode_lib->vba.EffectiveLBLatencyHidingSourceLinesChroma), 1742 mode_lib->vba.SwathHeightC[k]); 1743 mode_lib->vba.UrgentLatencySupportUsChroma = 1744 mode_lib->vba.EffectiveDETPlusLBLinesChroma 1745 * (mode_lib->vba.HTotal[k] 1746 / mode_lib->vba.PixelClock[k]) 1747 / (mode_lib->vba.VRatio[k] / 2) 1748 - mode_lib->vba.EffectiveDETPlusLBLinesChroma 1749 * (mode_lib->vba.SwathWidthY[k] 1750 / 2) 1751 * mode_lib->vba.BytePerPixelDETC[k] 1752 / (mode_lib->vba.ReturnBW 1753 / mode_lib->vba.DPPPerPlane[k]); 1754 mode_lib->vba.UrgentLatencySupportUs[k] = dml_min( 1755 mode_lib->vba.UrgentLatencySupportUsLuma, 1756 mode_lib->vba.UrgentLatencySupportUsChroma); 1757 } else { 1758 mode_lib->vba.UrgentLatencySupportUs[k] = 1759 mode_lib->vba.UrgentLatencySupportUsLuma; 1760 } 1761 } 1762 1763 mode_lib->vba.MinUrgentLatencySupportUs = 999999; 1764 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1765 mode_lib->vba.MinUrgentLatencySupportUs = dml_min( 1766 mode_lib->vba.MinUrgentLatencySupportUs, 1767 mode_lib->vba.UrgentLatencySupportUs[k]); 1768 } 1769 1770 // Non-Urgent Latency Tolerance 1771 mode_lib->vba.NonUrgentLatencyTolerance = mode_lib->vba.MinUrgentLatencySupportUs 1772 - mode_lib->vba.UrgentWatermark; 1773 1774 // DSCCLK 1775 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1776 if ((mode_lib->vba.BlendingAndTiming[k] != k) || !mode_lib->vba.DSCEnabled[k]) { 1777 mode_lib->vba.DSCCLK_calculated[k] = 0.0; 1778 } else { 1779 if (mode_lib->vba.OutputFormat[k] == dm_420 1780 || mode_lib->vba.OutputFormat[k] == dm_n422) 1781 mode_lib->vba.DSCFormatFactor = 2; 1782 else 1783 mode_lib->vba.DSCFormatFactor = 1; 1784 if (mode_lib->vba.ODMCombineEnabled[k]) 1785 mode_lib->vba.DSCCLK_calculated[k] = 1786 mode_lib->vba.PixelClockBackEnd[k] / 6 1787 / mode_lib->vba.DSCFormatFactor 1788 / (1 1789 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading 1790 / 100); 1791 else 1792 mode_lib->vba.DSCCLK_calculated[k] = 1793 mode_lib->vba.PixelClockBackEnd[k] / 3 1794 / mode_lib->vba.DSCFormatFactor 1795 / (1 1796 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading 1797 / 100); 1798 } 1799 } 1800 1801 // DSC Delay 1802 // TODO 1803 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1804 double bpp = mode_lib->vba.OutputBpp[k]; 1805 unsigned int slices = mode_lib->vba.NumberOfDSCSlices[k]; 1806 1807 if (mode_lib->vba.DSCEnabled[k] && bpp != 0) { 1808 if (!mode_lib->vba.ODMCombineEnabled[k]) { 1809 mode_lib->vba.DSCDelay[k] = 1810 dscceComputeDelay( 1811 mode_lib->vba.DSCInputBitPerComponent[k], 1812 bpp, 1813 dml_ceil( 1814 (double) mode_lib->vba.HActive[k] 1815 / mode_lib->vba.NumberOfDSCSlices[k], 1816 1), 1817 slices, 1818 mode_lib->vba.OutputFormat[k]) 1819 + dscComputeDelay( 1820 mode_lib->vba.OutputFormat[k]); 1821 } else { 1822 mode_lib->vba.DSCDelay[k] = 1823 2 1824 * (dscceComputeDelay( 1825 mode_lib->vba.DSCInputBitPerComponent[k], 1826 bpp, 1827 dml_ceil( 1828 (double) mode_lib->vba.HActive[k] 1829 / mode_lib->vba.NumberOfDSCSlices[k], 1830 1), 1831 slices / 2.0, 1832 mode_lib->vba.OutputFormat[k]) 1833 + dscComputeDelay( 1834 mode_lib->vba.OutputFormat[k])); 1835 } 1836 mode_lib->vba.DSCDelay[k] = mode_lib->vba.DSCDelay[k] 1837 * mode_lib->vba.PixelClock[k] 1838 / mode_lib->vba.PixelClockBackEnd[k]; 1839 } else { 1840 mode_lib->vba.DSCDelay[k] = 0; 1841 } 1842 } 1843 1844 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) 1845 for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) // NumberOfPlanes 1846 if (j != k && mode_lib->vba.BlendingAndTiming[k] == j 1847 && mode_lib->vba.DSCEnabled[j]) 1848 mode_lib->vba.DSCDelay[k] = mode_lib->vba.DSCDelay[j]; 1849 1850 // Prefetch 1851 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1852 unsigned int PDEAndMetaPTEBytesFrameY; 1853 unsigned int PixelPTEBytesPerRowY; 1854 unsigned int MetaRowByteY; 1855 unsigned int MetaRowByteC; 1856 unsigned int PDEAndMetaPTEBytesFrameC; 1857 unsigned int PixelPTEBytesPerRowC; 1858 1859 Calculate256BBlockSizes( 1860 mode_lib->vba.SourcePixelFormat[k], 1861 mode_lib->vba.SurfaceTiling[k], 1862 dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1), 1863 dml_ceil(mode_lib->vba.BytePerPixelDETC[k], 2), 1864 &mode_lib->vba.BlockHeight256BytesY[k], 1865 &mode_lib->vba.BlockHeight256BytesC[k], 1866 &mode_lib->vba.BlockWidth256BytesY[k], 1867 &mode_lib->vba.BlockWidth256BytesC[k]); 1868 PDEAndMetaPTEBytesFrameY = CalculateVMAndRowBytes( 1869 mode_lib, 1870 mode_lib->vba.DCCEnable[k], 1871 mode_lib->vba.BlockHeight256BytesY[k], 1872 mode_lib->vba.BlockWidth256BytesY[k], 1873 mode_lib->vba.SourcePixelFormat[k], 1874 mode_lib->vba.SurfaceTiling[k], 1875 dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1), 1876 mode_lib->vba.SourceScan[k], 1877 mode_lib->vba.ViewportWidth[k], 1878 mode_lib->vba.ViewportHeight[k], 1879 mode_lib->vba.SwathWidthY[k], 1880 mode_lib->vba.GPUVMEnable, 1881 mode_lib->vba.VMMPageSize, 1882 mode_lib->vba.PTEBufferSizeInRequestsLuma, 1883 mode_lib->vba.PDEProcessingBufIn64KBReqs, 1884 mode_lib->vba.PitchY[k], 1885 mode_lib->vba.DCCMetaPitchY[k], 1886 &mode_lib->vba.MacroTileWidthY[k], 1887 &MetaRowByteY, 1888 &PixelPTEBytesPerRowY, 1889 &mode_lib->vba.PTEBufferSizeNotExceeded[mode_lib->vba.VoltageLevel][0], 1890 &mode_lib->vba.dpte_row_height[k], 1891 &mode_lib->vba.meta_row_height[k]); 1892 mode_lib->vba.PrefetchSourceLinesY[k] = CalculatePrefetchSourceLines( 1893 mode_lib, 1894 mode_lib->vba.VRatio[k], 1895 mode_lib->vba.vtaps[k], 1896 mode_lib->vba.Interlace[k], 1897 mode_lib->vba.ProgressiveToInterlaceUnitInOPP, 1898 mode_lib->vba.SwathHeightY[k], 1899 mode_lib->vba.ViewportYStartY[k], 1900 &mode_lib->vba.VInitPreFillY[k], 1901 &mode_lib->vba.MaxNumSwathY[k]); 1902 1903 if ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64 1904 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32 1905 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16 1906 && mode_lib->vba.SourcePixelFormat[k] != dm_444_8)) { 1907 PDEAndMetaPTEBytesFrameC = 1908 CalculateVMAndRowBytes( 1909 mode_lib, 1910 mode_lib->vba.DCCEnable[k], 1911 mode_lib->vba.BlockHeight256BytesC[k], 1912 mode_lib->vba.BlockWidth256BytesC[k], 1913 mode_lib->vba.SourcePixelFormat[k], 1914 mode_lib->vba.SurfaceTiling[k], 1915 dml_ceil( 1916 mode_lib->vba.BytePerPixelDETC[k], 1917 2), 1918 mode_lib->vba.SourceScan[k], 1919 mode_lib->vba.ViewportWidth[k] / 2, 1920 mode_lib->vba.ViewportHeight[k] / 2, 1921 mode_lib->vba.SwathWidthY[k] / 2, 1922 mode_lib->vba.GPUVMEnable, 1923 mode_lib->vba.VMMPageSize, 1924 mode_lib->vba.PTEBufferSizeInRequestsLuma, 1925 mode_lib->vba.PDEProcessingBufIn64KBReqs, 1926 mode_lib->vba.PitchC[k], 1927 0, 1928 &mode_lib->vba.MacroTileWidthC[k], 1929 &MetaRowByteC, 1930 &PixelPTEBytesPerRowC, 1931 &mode_lib->vba.PTEBufferSizeNotExceeded[mode_lib->vba.VoltageLevel][0], 1932 &mode_lib->vba.dpte_row_height_chroma[k], 1933 &mode_lib->vba.meta_row_height_chroma[k]); 1934 mode_lib->vba.PrefetchSourceLinesC[k] = CalculatePrefetchSourceLines( 1935 mode_lib, 1936 mode_lib->vba.VRatio[k] / 2, 1937 mode_lib->vba.VTAPsChroma[k], 1938 mode_lib->vba.Interlace[k], 1939 mode_lib->vba.ProgressiveToInterlaceUnitInOPP, 1940 mode_lib->vba.SwathHeightC[k], 1941 mode_lib->vba.ViewportYStartC[k], 1942 &mode_lib->vba.VInitPreFillC[k], 1943 &mode_lib->vba.MaxNumSwathC[k]); 1944 } else { 1945 PixelPTEBytesPerRowC = 0; 1946 PDEAndMetaPTEBytesFrameC = 0; 1947 MetaRowByteC = 0; 1948 mode_lib->vba.MaxNumSwathC[k] = 0; 1949 mode_lib->vba.PrefetchSourceLinesC[k] = 0; 1950 } 1951 1952 mode_lib->vba.PixelPTEBytesPerRow[k] = PixelPTEBytesPerRowY + PixelPTEBytesPerRowC; 1953 mode_lib->vba.PDEAndMetaPTEBytesFrame[k] = PDEAndMetaPTEBytesFrameY 1954 + PDEAndMetaPTEBytesFrameC; 1955 mode_lib->vba.MetaRowByte[k] = MetaRowByteY + MetaRowByteC; 1956 1957 CalculateActiveRowBandwidth( 1958 mode_lib->vba.GPUVMEnable, 1959 mode_lib->vba.SourcePixelFormat[k], 1960 mode_lib->vba.VRatio[k], 1961 mode_lib->vba.DCCEnable[k], 1962 mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k], 1963 MetaRowByteY, 1964 MetaRowByteC, 1965 mode_lib->vba.meta_row_height[k], 1966 mode_lib->vba.meta_row_height_chroma[k], 1967 PixelPTEBytesPerRowY, 1968 PixelPTEBytesPerRowC, 1969 mode_lib->vba.dpte_row_height[k], 1970 mode_lib->vba.dpte_row_height_chroma[k], 1971 &mode_lib->vba.meta_row_bw[k], 1972 &mode_lib->vba.dpte_row_bw[k], 1973 &mode_lib->vba.qual_row_bw[k]); 1974 } 1975 1976 mode_lib->vba.TCalc = 24.0 / mode_lib->vba.DCFCLKDeepSleep; 1977 1978 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 1979 if (mode_lib->vba.BlendingAndTiming[k] == k) { 1980 if (mode_lib->vba.WritebackEnable[k] == true) { 1981 mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] = 1982 mode_lib->vba.WritebackLatency 1983 + CalculateWriteBackDelay( 1984 mode_lib->vba.WritebackPixelFormat[k], 1985 mode_lib->vba.WritebackHRatio[k], 1986 mode_lib->vba.WritebackVRatio[k], 1987 mode_lib->vba.WritebackLumaHTaps[k], 1988 mode_lib->vba.WritebackLumaVTaps[k], 1989 mode_lib->vba.WritebackChromaHTaps[k], 1990 mode_lib->vba.WritebackChromaVTaps[k], 1991 mode_lib->vba.WritebackDestinationWidth[k]) 1992 / mode_lib->vba.DISPCLK; 1993 } else 1994 mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] = 0; 1995 for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) { 1996 if (mode_lib->vba.BlendingAndTiming[j] == k 1997 && mode_lib->vba.WritebackEnable[j] == true) { 1998 mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] = 1999 dml_max( 2000 mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k], 2001 mode_lib->vba.WritebackLatency 2002 + CalculateWriteBackDelay( 2003 mode_lib->vba.WritebackPixelFormat[j], 2004 mode_lib->vba.WritebackHRatio[j], 2005 mode_lib->vba.WritebackVRatio[j], 2006 mode_lib->vba.WritebackLumaHTaps[j], 2007 mode_lib->vba.WritebackLumaVTaps[j], 2008 mode_lib->vba.WritebackChromaHTaps[j], 2009 mode_lib->vba.WritebackChromaVTaps[j], 2010 mode_lib->vba.WritebackDestinationWidth[j]) 2011 / mode_lib->vba.DISPCLK); 2012 } 2013 } 2014 } 2015 } 2016 2017 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) 2018 for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) 2019 if (mode_lib->vba.BlendingAndTiming[k] == j) 2020 mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] = 2021 mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][j]; 2022 2023 mode_lib->vba.VStartupLines = 13; 2024 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2025 mode_lib->vba.MaxVStartupLines[k] = 2026 mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k] 2027 - dml_max( 2028 1.0, 2029 dml_ceil( 2030 mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] 2031 / (mode_lib->vba.HTotal[k] 2032 / mode_lib->vba.PixelClock[k]), 2033 1)); 2034 } 2035 2036 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) 2037 mode_lib->vba.MaximumMaxVStartupLines = dml_max( 2038 mode_lib->vba.MaximumMaxVStartupLines, 2039 mode_lib->vba.MaxVStartupLines[k]); 2040 2041 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2042 mode_lib->vba.cursor_bw[k] = 0.0; 2043 for (j = 0; j < mode_lib->vba.NumberOfCursors[k]; ++j) 2044 mode_lib->vba.cursor_bw[k] += mode_lib->vba.CursorWidth[k][j] 2045 * mode_lib->vba.CursorBPP[k][j] / 8.0 2046 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) 2047 * mode_lib->vba.VRatio[k]; 2048 } 2049 2050 do { 2051 double MaxTotalRDBandwidth = 0; 2052 bool DestinationLineTimesForPrefetchLessThan2 = false; 2053 bool VRatioPrefetchMoreThan4 = false; 2054 bool prefetch_vm_bw_valid = true; 2055 bool prefetch_row_bw_valid = true; 2056 double TWait = CalculateTWait( 2057 mode_lib->vba.PrefetchMode[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb], 2058 mode_lib->vba.DRAMClockChangeLatency, 2059 mode_lib->vba.UrgentLatencyPixelDataOnly, 2060 mode_lib->vba.SREnterPlusExitTime); 2061 2062 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2063 if (mode_lib->vba.XFCEnabled[k] == true) { 2064 mode_lib->vba.XFCRemoteSurfaceFlipDelay = 2065 CalculateRemoteSurfaceFlipDelay( 2066 mode_lib, 2067 mode_lib->vba.VRatio[k], 2068 mode_lib->vba.SwathWidthY[k], 2069 dml_ceil( 2070 mode_lib->vba.BytePerPixelDETY[k], 2071 1), 2072 mode_lib->vba.HTotal[k] 2073 / mode_lib->vba.PixelClock[k], 2074 mode_lib->vba.XFCTSlvVupdateOffset, 2075 mode_lib->vba.XFCTSlvVupdateWidth, 2076 mode_lib->vba.XFCTSlvVreadyOffset, 2077 mode_lib->vba.XFCXBUFLatencyTolerance, 2078 mode_lib->vba.XFCFillBWOverhead, 2079 mode_lib->vba.XFCSlvChunkSize, 2080 mode_lib->vba.XFCBusTransportTime, 2081 mode_lib->vba.TCalc, 2082 TWait, 2083 &mode_lib->vba.SrcActiveDrainRate, 2084 &mode_lib->vba.TInitXFill, 2085 &mode_lib->vba.TslvChk); 2086 } else { 2087 mode_lib->vba.XFCRemoteSurfaceFlipDelay = 0; 2088 } 2089 mode_lib->vba.ErrorResult[k] = 2090 CalculatePrefetchSchedule( 2091 mode_lib, 2092 mode_lib->vba.DPPCLK[k], 2093 mode_lib->vba.DISPCLK, 2094 mode_lib->vba.PixelClock[k], 2095 mode_lib->vba.DCFCLKDeepSleep, 2096 mode_lib->vba.DSCDelay[k], 2097 mode_lib->vba.DPPPerPlane[k], 2098 mode_lib->vba.ScalerEnabled[k], 2099 mode_lib->vba.NumberOfCursors[k], 2100 mode_lib->vba.DPPCLKDelaySubtotal, 2101 mode_lib->vba.DPPCLKDelaySCL, 2102 mode_lib->vba.DPPCLKDelaySCLLBOnly, 2103 mode_lib->vba.DPPCLKDelayCNVCFormater, 2104 mode_lib->vba.DPPCLKDelayCNVCCursor, 2105 mode_lib->vba.DISPCLKDelaySubtotal, 2106 (unsigned int) (mode_lib->vba.SwathWidthY[k] 2107 / mode_lib->vba.HRatio[k]), 2108 mode_lib->vba.OutputFormat[k], 2109 mode_lib->vba.VTotal[k] 2110 - mode_lib->vba.VActive[k], 2111 mode_lib->vba.HTotal[k], 2112 mode_lib->vba.MaxInterDCNTileRepeaters, 2113 dml_min( 2114 mode_lib->vba.VStartupLines, 2115 mode_lib->vba.MaxVStartupLines[k]), 2116 mode_lib->vba.GPUVMMaxPageTableLevels, 2117 mode_lib->vba.GPUVMEnable, 2118 mode_lib->vba.DynamicMetadataEnable[k], 2119 mode_lib->vba.DynamicMetadataLinesBeforeActiveRequired[k], 2120 mode_lib->vba.DynamicMetadataTransmittedBytes[k], 2121 mode_lib->vba.DCCEnable[k], 2122 mode_lib->vba.UrgentLatencyPixelDataOnly, 2123 mode_lib->vba.UrgentExtraLatency, 2124 mode_lib->vba.TCalc, 2125 mode_lib->vba.PDEAndMetaPTEBytesFrame[k], 2126 mode_lib->vba.MetaRowByte[k], 2127 mode_lib->vba.PixelPTEBytesPerRow[k], 2128 mode_lib->vba.PrefetchSourceLinesY[k], 2129 mode_lib->vba.SwathWidthY[k], 2130 mode_lib->vba.BytePerPixelDETY[k], 2131 mode_lib->vba.VInitPreFillY[k], 2132 mode_lib->vba.MaxNumSwathY[k], 2133 mode_lib->vba.PrefetchSourceLinesC[k], 2134 mode_lib->vba.BytePerPixelDETC[k], 2135 mode_lib->vba.VInitPreFillC[k], 2136 mode_lib->vba.MaxNumSwathC[k], 2137 mode_lib->vba.SwathHeightY[k], 2138 mode_lib->vba.SwathHeightC[k], 2139 TWait, 2140 mode_lib->vba.XFCEnabled[k], 2141 mode_lib->vba.XFCRemoteSurfaceFlipDelay, 2142 mode_lib->vba.Interlace[k], 2143 mode_lib->vba.ProgressiveToInterlaceUnitInOPP, 2144 &mode_lib->vba.DSTXAfterScaler[k], 2145 &mode_lib->vba.DSTYAfterScaler[k], 2146 &mode_lib->vba.DestinationLinesForPrefetch[k], 2147 &mode_lib->vba.PrefetchBandwidth[k], 2148 &mode_lib->vba.DestinationLinesToRequestVMInVBlank[k], 2149 &mode_lib->vba.DestinationLinesToRequestRowInVBlank[k], 2150 &mode_lib->vba.VRatioPrefetchY[k], 2151 &mode_lib->vba.VRatioPrefetchC[k], 2152 &mode_lib->vba.RequiredPrefetchPixDataBWLuma[k], 2153 &mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata, 2154 &mode_lib->vba.Tno_bw[k], 2155 &mode_lib->vba.VUpdateOffsetPix[k], 2156 &mode_lib->vba.VUpdateWidthPix[k], 2157 &mode_lib->vba.VReadyOffsetPix[k]); 2158 if (mode_lib->vba.BlendingAndTiming[k] == k) { 2159 mode_lib->vba.VStartup[k] = dml_min( 2160 mode_lib->vba.VStartupLines, 2161 mode_lib->vba.MaxVStartupLines[k]); 2162 if (mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata 2163 != 0) { 2164 mode_lib->vba.VStartup[k] = 2165 mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata; 2166 } 2167 } else { 2168 mode_lib->vba.VStartup[k] = 2169 dml_min( 2170 mode_lib->vba.VStartupLines, 2171 mode_lib->vba.MaxVStartupLines[mode_lib->vba.BlendingAndTiming[k]]); 2172 } 2173 } 2174 2175 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2176 2177 if (mode_lib->vba.PDEAndMetaPTEBytesFrame[k] == 0) 2178 mode_lib->vba.prefetch_vm_bw[k] = 0; 2179 else if (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k] > 0) { 2180 mode_lib->vba.prefetch_vm_bw[k] = 2181 (double) mode_lib->vba.PDEAndMetaPTEBytesFrame[k] 2182 / (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k] 2183 * mode_lib->vba.HTotal[k] 2184 / mode_lib->vba.PixelClock[k]); 2185 } else { 2186 mode_lib->vba.prefetch_vm_bw[k] = 0; 2187 prefetch_vm_bw_valid = false; 2188 } 2189 if (mode_lib->vba.MetaRowByte[k] + mode_lib->vba.PixelPTEBytesPerRow[k] 2190 == 0) 2191 mode_lib->vba.prefetch_row_bw[k] = 0; 2192 else if (mode_lib->vba.DestinationLinesToRequestRowInVBlank[k] > 0) { 2193 mode_lib->vba.prefetch_row_bw[k] = 2194 (double) (mode_lib->vba.MetaRowByte[k] 2195 + mode_lib->vba.PixelPTEBytesPerRow[k]) 2196 / (mode_lib->vba.DestinationLinesToRequestRowInVBlank[k] 2197 * mode_lib->vba.HTotal[k] 2198 / mode_lib->vba.PixelClock[k]); 2199 } else { 2200 mode_lib->vba.prefetch_row_bw[k] = 0; 2201 prefetch_row_bw_valid = false; 2202 } 2203 2204 MaxTotalRDBandwidth = 2205 MaxTotalRDBandwidth + mode_lib->vba.cursor_bw[k] 2206 + dml_max( 2207 mode_lib->vba.prefetch_vm_bw[k], 2208 dml_max( 2209 mode_lib->vba.prefetch_row_bw[k], 2210 dml_max( 2211 mode_lib->vba.ReadBandwidthPlaneLuma[k] 2212 + mode_lib->vba.ReadBandwidthPlaneChroma[k], 2213 mode_lib->vba.RequiredPrefetchPixDataBWLuma[k]) 2214 + mode_lib->vba.meta_row_bw[k] 2215 + mode_lib->vba.dpte_row_bw[k])); 2216 2217 if (mode_lib->vba.DestinationLinesForPrefetch[k] < 2) 2218 DestinationLineTimesForPrefetchLessThan2 = true; 2219 if (mode_lib->vba.VRatioPrefetchY[k] > 4 2220 || mode_lib->vba.VRatioPrefetchC[k] > 4) 2221 VRatioPrefetchMoreThan4 = true; 2222 } 2223 2224 if (MaxTotalRDBandwidth <= mode_lib->vba.ReturnBW && prefetch_vm_bw_valid 2225 && prefetch_row_bw_valid && !VRatioPrefetchMoreThan4 2226 && !DestinationLineTimesForPrefetchLessThan2) 2227 mode_lib->vba.PrefetchModeSupported = true; 2228 else { 2229 mode_lib->vba.PrefetchModeSupported = false; 2230 dml_print( 2231 "DML: CalculatePrefetchSchedule ***failed***. Bandwidth violation. Results are NOT valid\n"); 2232 } 2233 2234 if (mode_lib->vba.PrefetchModeSupported == true) { 2235 double final_flip_bw[DC__NUM_DPP__MAX]; 2236 unsigned int ImmediateFlipBytes[DC__NUM_DPP__MAX]; 2237 double total_dcn_read_bw_with_flip = 0; 2238 2239 mode_lib->vba.BandwidthAvailableForImmediateFlip = mode_lib->vba.ReturnBW; 2240 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2241 mode_lib->vba.BandwidthAvailableForImmediateFlip = 2242 mode_lib->vba.BandwidthAvailableForImmediateFlip 2243 - mode_lib->vba.cursor_bw[k] 2244 - dml_max( 2245 mode_lib->vba.ReadBandwidthPlaneLuma[k] 2246 + mode_lib->vba.ReadBandwidthPlaneChroma[k] 2247 + mode_lib->vba.qual_row_bw[k], 2248 mode_lib->vba.PrefetchBandwidth[k]); 2249 } 2250 2251 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2252 ImmediateFlipBytes[k] = 0; 2253 if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8 2254 && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) { 2255 ImmediateFlipBytes[k] = 2256 mode_lib->vba.PDEAndMetaPTEBytesFrame[k] 2257 + mode_lib->vba.MetaRowByte[k] 2258 + mode_lib->vba.PixelPTEBytesPerRow[k]; 2259 } 2260 } 2261 mode_lib->vba.TotImmediateFlipBytes = 0; 2262 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2263 if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8 2264 && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) { 2265 mode_lib->vba.TotImmediateFlipBytes = 2266 mode_lib->vba.TotImmediateFlipBytes 2267 + ImmediateFlipBytes[k]; 2268 } 2269 } 2270 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2271 CalculateFlipSchedule( 2272 mode_lib, 2273 mode_lib->vba.UrgentExtraLatency, 2274 mode_lib->vba.UrgentLatencyPixelDataOnly, 2275 mode_lib->vba.GPUVMMaxPageTableLevels, 2276 mode_lib->vba.GPUVMEnable, 2277 mode_lib->vba.BandwidthAvailableForImmediateFlip, 2278 mode_lib->vba.TotImmediateFlipBytes, 2279 mode_lib->vba.SourcePixelFormat[k], 2280 ImmediateFlipBytes[k], 2281 mode_lib->vba.HTotal[k] 2282 / mode_lib->vba.PixelClock[k], 2283 mode_lib->vba.VRatio[k], 2284 mode_lib->vba.Tno_bw[k], 2285 mode_lib->vba.PDEAndMetaPTEBytesFrame[k], 2286 mode_lib->vba.MetaRowByte[k], 2287 mode_lib->vba.PixelPTEBytesPerRow[k], 2288 mode_lib->vba.DCCEnable[k], 2289 mode_lib->vba.dpte_row_height[k], 2290 mode_lib->vba.meta_row_height[k], 2291 mode_lib->vba.qual_row_bw[k], 2292 &mode_lib->vba.DestinationLinesToRequestVMInImmediateFlip[k], 2293 &mode_lib->vba.DestinationLinesToRequestRowInImmediateFlip[k], 2294 &final_flip_bw[k], 2295 &mode_lib->vba.ImmediateFlipSupportedForPipe[k]); 2296 } 2297 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2298 total_dcn_read_bw_with_flip = 2299 total_dcn_read_bw_with_flip 2300 + mode_lib->vba.cursor_bw[k] 2301 + dml_max( 2302 mode_lib->vba.prefetch_vm_bw[k], 2303 dml_max( 2304 mode_lib->vba.prefetch_row_bw[k], 2305 final_flip_bw[k] 2306 + dml_max( 2307 mode_lib->vba.ReadBandwidthPlaneLuma[k] 2308 + mode_lib->vba.ReadBandwidthPlaneChroma[k], 2309 mode_lib->vba.RequiredPrefetchPixDataBWLuma[k]))); 2310 } 2311 mode_lib->vba.ImmediateFlipSupported = true; 2312 if (total_dcn_read_bw_with_flip > mode_lib->vba.ReturnBW) { 2313 mode_lib->vba.ImmediateFlipSupported = false; 2314 } 2315 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2316 if (mode_lib->vba.ImmediateFlipSupportedForPipe[k] == false) { 2317 mode_lib->vba.ImmediateFlipSupported = false; 2318 } 2319 } 2320 } else { 2321 mode_lib->vba.ImmediateFlipSupported = false; 2322 } 2323 2324 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2325 if (mode_lib->vba.ErrorResult[k]) { 2326 mode_lib->vba.PrefetchModeSupported = false; 2327 dml_print( 2328 "DML: CalculatePrefetchSchedule ***failed***. Prefetch schedule violation. Results are NOT valid\n"); 2329 } 2330 } 2331 2332 mode_lib->vba.VStartupLines = mode_lib->vba.VStartupLines + 1; 2333 } while (!((mode_lib->vba.PrefetchModeSupported 2334 && (!mode_lib->vba.ImmediateFlipSupport 2335 || mode_lib->vba.ImmediateFlipSupported)) 2336 || mode_lib->vba.MaximumMaxVStartupLines < mode_lib->vba.VStartupLines)); 2337 2338 //Display Pipeline Delivery Time in Prefetch 2339 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2340 if (mode_lib->vba.VRatioPrefetchY[k] <= 1) { 2341 mode_lib->vba.DisplayPipeLineDeliveryTimeLumaPrefetch[k] = 2342 mode_lib->vba.SwathWidthY[k] * mode_lib->vba.DPPPerPlane[k] 2343 / mode_lib->vba.HRatio[k] 2344 / mode_lib->vba.PixelClock[k]; 2345 } else { 2346 mode_lib->vba.DisplayPipeLineDeliveryTimeLumaPrefetch[k] = 2347 mode_lib->vba.SwathWidthY[k] 2348 / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] 2349 / mode_lib->vba.DPPCLK[k]; 2350 } 2351 if (mode_lib->vba.BytePerPixelDETC[k] == 0) { 2352 mode_lib->vba.DisplayPipeLineDeliveryTimeChromaPrefetch[k] = 0; 2353 } else { 2354 if (mode_lib->vba.VRatioPrefetchC[k] <= 1) { 2355 mode_lib->vba.DisplayPipeLineDeliveryTimeChromaPrefetch[k] = 2356 mode_lib->vba.SwathWidthY[k] 2357 * mode_lib->vba.DPPPerPlane[k] 2358 / mode_lib->vba.HRatio[k] 2359 / mode_lib->vba.PixelClock[k]; 2360 } else { 2361 mode_lib->vba.DisplayPipeLineDeliveryTimeChromaPrefetch[k] = 2362 mode_lib->vba.SwathWidthY[k] 2363 / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] 2364 / mode_lib->vba.DPPCLK[k]; 2365 } 2366 } 2367 } 2368 2369 // Min TTUVBlank 2370 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2371 if (mode_lib->vba.PrefetchMode[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb] == 0) { 2372 mode_lib->vba.AllowDRAMClockChangeDuringVBlank[k] = true; 2373 mode_lib->vba.AllowDRAMSelfRefreshDuringVBlank[k] = true; 2374 mode_lib->vba.MinTTUVBlank[k] = dml_max( 2375 mode_lib->vba.DRAMClockChangeWatermark, 2376 dml_max( 2377 mode_lib->vba.StutterEnterPlusExitWatermark, 2378 mode_lib->vba.UrgentWatermark)); 2379 } else if (mode_lib->vba.PrefetchMode[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb] == 1) { 2380 mode_lib->vba.AllowDRAMClockChangeDuringVBlank[k] = false; 2381 mode_lib->vba.AllowDRAMSelfRefreshDuringVBlank[k] = true; 2382 mode_lib->vba.MinTTUVBlank[k] = dml_max( 2383 mode_lib->vba.StutterEnterPlusExitWatermark, 2384 mode_lib->vba.UrgentWatermark); 2385 } else { 2386 mode_lib->vba.AllowDRAMClockChangeDuringVBlank[k] = false; 2387 mode_lib->vba.AllowDRAMSelfRefreshDuringVBlank[k] = false; 2388 mode_lib->vba.MinTTUVBlank[k] = mode_lib->vba.UrgentWatermark; 2389 } 2390 if (!mode_lib->vba.DynamicMetadataEnable[k]) 2391 mode_lib->vba.MinTTUVBlank[k] = mode_lib->vba.TCalc 2392 + mode_lib->vba.MinTTUVBlank[k]; 2393 } 2394 2395 // DCC Configuration 2396 mode_lib->vba.ActiveDPPs = 0; 2397 // NB P-State/DRAM Clock Change Support 2398 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2399 mode_lib->vba.ActiveDPPs = mode_lib->vba.ActiveDPPs + mode_lib->vba.DPPPerPlane[k]; 2400 } 2401 2402 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2403 double EffectiveLBLatencyHidingY; 2404 double EffectiveLBLatencyHidingC; 2405 double DPPOutputBufferLinesY; 2406 double DPPOutputBufferLinesC; 2407 double DPPOPPBufferingY; 2408 double MaxDETBufferingTimeY; 2409 double ActiveDRAMClockChangeLatencyMarginY; 2410 2411 mode_lib->vba.LBLatencyHidingSourceLinesY = 2412 dml_min( 2413 mode_lib->vba.MaxLineBufferLines, 2414 (unsigned int) dml_floor( 2415 (double) mode_lib->vba.LineBufferSize 2416 / mode_lib->vba.LBBitPerPixel[k] 2417 / (mode_lib->vba.SwathWidthY[k] 2418 / dml_max( 2419 mode_lib->vba.HRatio[k], 2420 1.0)), 2421 1)) - (mode_lib->vba.vtaps[k] - 1); 2422 2423 mode_lib->vba.LBLatencyHidingSourceLinesC = 2424 dml_min( 2425 mode_lib->vba.MaxLineBufferLines, 2426 (unsigned int) dml_floor( 2427 (double) mode_lib->vba.LineBufferSize 2428 / mode_lib->vba.LBBitPerPixel[k] 2429 / (mode_lib->vba.SwathWidthY[k] 2430 / 2.0 2431 / dml_max( 2432 mode_lib->vba.HRatio[k] 2433 / 2, 2434 1.0)), 2435 1)) 2436 - (mode_lib->vba.VTAPsChroma[k] - 1); 2437 2438 EffectiveLBLatencyHidingY = mode_lib->vba.LBLatencyHidingSourceLinesY 2439 / mode_lib->vba.VRatio[k] 2440 * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]); 2441 2442 EffectiveLBLatencyHidingC = mode_lib->vba.LBLatencyHidingSourceLinesC 2443 / (mode_lib->vba.VRatio[k] / 2) 2444 * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]); 2445 2446 if (mode_lib->vba.SwathWidthY[k] > 2 * mode_lib->vba.DPPOutputBufferPixels) { 2447 DPPOutputBufferLinesY = mode_lib->vba.DPPOutputBufferPixels 2448 / mode_lib->vba.SwathWidthY[k]; 2449 } else if (mode_lib->vba.SwathWidthY[k] > mode_lib->vba.DPPOutputBufferPixels) { 2450 DPPOutputBufferLinesY = 0.5; 2451 } else { 2452 DPPOutputBufferLinesY = 1; 2453 } 2454 2455 if (mode_lib->vba.SwathWidthY[k] / 2 > 2 * mode_lib->vba.DPPOutputBufferPixels) { 2456 DPPOutputBufferLinesC = mode_lib->vba.DPPOutputBufferPixels 2457 / (mode_lib->vba.SwathWidthY[k] / 2); 2458 } else if (mode_lib->vba.SwathWidthY[k] / 2 > mode_lib->vba.DPPOutputBufferPixels) { 2459 DPPOutputBufferLinesC = 0.5; 2460 } else { 2461 DPPOutputBufferLinesC = 1; 2462 } 2463 2464 DPPOPPBufferingY = (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) 2465 * (DPPOutputBufferLinesY + mode_lib->vba.OPPOutputBufferLines); 2466 MaxDETBufferingTimeY = mode_lib->vba.FullDETBufferingTimeY[k] 2467 + (mode_lib->vba.LinesInDETY[k] 2468 - mode_lib->vba.LinesInDETYRoundedDownToSwath[k]) 2469 / mode_lib->vba.SwathHeightY[k] 2470 * (mode_lib->vba.HTotal[k] 2471 / mode_lib->vba.PixelClock[k]); 2472 2473 ActiveDRAMClockChangeLatencyMarginY = DPPOPPBufferingY + EffectiveLBLatencyHidingY 2474 + MaxDETBufferingTimeY - mode_lib->vba.DRAMClockChangeWatermark; 2475 2476 if (mode_lib->vba.ActiveDPPs > 1) { 2477 ActiveDRAMClockChangeLatencyMarginY = 2478 ActiveDRAMClockChangeLatencyMarginY 2479 - (1 - 1 / (mode_lib->vba.ActiveDPPs - 1)) 2480 * mode_lib->vba.SwathHeightY[k] 2481 * (mode_lib->vba.HTotal[k] 2482 / mode_lib->vba.PixelClock[k]); 2483 } 2484 2485 if (mode_lib->vba.BytePerPixelDETC[k] > 0) { 2486 double DPPOPPBufferingC = (mode_lib->vba.HTotal[k] 2487 / mode_lib->vba.PixelClock[k]) 2488 * (DPPOutputBufferLinesC 2489 + mode_lib->vba.OPPOutputBufferLines); 2490 double MaxDETBufferingTimeC = 2491 mode_lib->vba.FullDETBufferingTimeC[k] 2492 + (mode_lib->vba.LinesInDETC[k] 2493 - mode_lib->vba.LinesInDETCRoundedDownToSwath[k]) 2494 / mode_lib->vba.SwathHeightC[k] 2495 * (mode_lib->vba.HTotal[k] 2496 / mode_lib->vba.PixelClock[k]); 2497 double ActiveDRAMClockChangeLatencyMarginC = DPPOPPBufferingC 2498 + EffectiveLBLatencyHidingC + MaxDETBufferingTimeC 2499 - mode_lib->vba.DRAMClockChangeWatermark; 2500 2501 if (mode_lib->vba.ActiveDPPs > 1) { 2502 ActiveDRAMClockChangeLatencyMarginC = 2503 ActiveDRAMClockChangeLatencyMarginC 2504 - (1 2505 - 1 2506 / (mode_lib->vba.ActiveDPPs 2507 - 1)) 2508 * mode_lib->vba.SwathHeightC[k] 2509 * (mode_lib->vba.HTotal[k] 2510 / mode_lib->vba.PixelClock[k]); 2511 } 2512 mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = dml_min( 2513 ActiveDRAMClockChangeLatencyMarginY, 2514 ActiveDRAMClockChangeLatencyMarginC); 2515 } else { 2516 mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = 2517 ActiveDRAMClockChangeLatencyMarginY; 2518 } 2519 2520 if (mode_lib->vba.WritebackEnable[k]) { 2521 double WritebackDRAMClockChangeLatencyMargin; 2522 2523 if (mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) { 2524 WritebackDRAMClockChangeLatencyMargin = 2525 (double) (mode_lib->vba.WritebackInterfaceLumaBufferSize 2526 + mode_lib->vba.WritebackInterfaceChromaBufferSize) 2527 / (mode_lib->vba.WritebackDestinationWidth[k] 2528 * mode_lib->vba.WritebackDestinationHeight[k] 2529 / (mode_lib->vba.WritebackSourceHeight[k] 2530 * mode_lib->vba.HTotal[k] 2531 / mode_lib->vba.PixelClock[k]) 2532 * 4) 2533 - mode_lib->vba.WritebackDRAMClockChangeWatermark; 2534 } else if (mode_lib->vba.WritebackPixelFormat[k] == dm_420_10) { 2535 WritebackDRAMClockChangeLatencyMargin = 2536 dml_min( 2537 (double) mode_lib->vba.WritebackInterfaceLumaBufferSize 2538 * 8.0 / 10, 2539 2.0 2540 * mode_lib->vba.WritebackInterfaceChromaBufferSize 2541 * 8 / 10) 2542 / (mode_lib->vba.WritebackDestinationWidth[k] 2543 * mode_lib->vba.WritebackDestinationHeight[k] 2544 / (mode_lib->vba.WritebackSourceHeight[k] 2545 * mode_lib->vba.HTotal[k] 2546 / mode_lib->vba.PixelClock[k])) 2547 - mode_lib->vba.WritebackDRAMClockChangeWatermark; 2548 } else { 2549 WritebackDRAMClockChangeLatencyMargin = 2550 dml_min( 2551 (double) mode_lib->vba.WritebackInterfaceLumaBufferSize, 2552 2.0 2553 * mode_lib->vba.WritebackInterfaceChromaBufferSize) 2554 / (mode_lib->vba.WritebackDestinationWidth[k] 2555 * mode_lib->vba.WritebackDestinationHeight[k] 2556 / (mode_lib->vba.WritebackSourceHeight[k] 2557 * mode_lib->vba.HTotal[k] 2558 / mode_lib->vba.PixelClock[k])) 2559 - mode_lib->vba.WritebackDRAMClockChangeWatermark; 2560 } 2561 mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = dml_min( 2562 mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k], 2563 WritebackDRAMClockChangeLatencyMargin); 2564 } 2565 } 2566 2567 mode_lib->vba.MinActiveDRAMClockChangeMargin = 999999; 2568 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2569 if (mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] 2570 < mode_lib->vba.MinActiveDRAMClockChangeMargin) { 2571 mode_lib->vba.MinActiveDRAMClockChangeMargin = 2572 mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k]; 2573 } 2574 } 2575 2576 mode_lib->vba.MinActiveDRAMClockChangeLatencySupported = 2577 mode_lib->vba.MinActiveDRAMClockChangeMargin 2578 + mode_lib->vba.DRAMClockChangeLatency; 2579 2580 if (mode_lib->vba.MinActiveDRAMClockChangeMargin > 50) { 2581 mode_lib->vba.DRAMClockChangeWatermark += 25; 2582 mode_lib->vba.DRAMClockChangeSupport[0][0] = dm_dram_clock_change_vactive; 2583 } else { 2584 if (mode_lib->vba.SynchronizedVBlank || mode_lib->vba.NumberOfActivePlanes == 1) { 2585 mode_lib->vba.DRAMClockChangeSupport[0][0] = dm_dram_clock_change_vblank; 2586 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2587 if (!mode_lib->vba.AllowDRAMClockChangeDuringVBlank[k]) { 2588 mode_lib->vba.DRAMClockChangeSupport[0][0] = 2589 dm_dram_clock_change_unsupported; 2590 } 2591 } 2592 } else { 2593 mode_lib->vba.DRAMClockChangeSupport[0][0] = dm_dram_clock_change_unsupported; 2594 } 2595 } 2596 for (k = 0; k <= mode_lib->vba.soc.num_states; k++) 2597 for (j = 0; j < 2; j++) 2598 mode_lib->vba.DRAMClockChangeSupport[k][j] = mode_lib->vba.DRAMClockChangeSupport[0][0]; 2599 2600 //XFC Parameters: 2601 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2602 if (mode_lib->vba.XFCEnabled[k] == true) { 2603 double TWait; 2604 2605 mode_lib->vba.XFCSlaveVUpdateOffset[k] = mode_lib->vba.XFCTSlvVupdateOffset; 2606 mode_lib->vba.XFCSlaveVupdateWidth[k] = mode_lib->vba.XFCTSlvVupdateWidth; 2607 mode_lib->vba.XFCSlaveVReadyOffset[k] = mode_lib->vba.XFCTSlvVreadyOffset; 2608 TWait = CalculateTWait( 2609 mode_lib->vba.PrefetchMode[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb], 2610 mode_lib->vba.DRAMClockChangeLatency, 2611 mode_lib->vba.UrgentLatencyPixelDataOnly, 2612 mode_lib->vba.SREnterPlusExitTime); 2613 mode_lib->vba.XFCRemoteSurfaceFlipDelay = CalculateRemoteSurfaceFlipDelay( 2614 mode_lib, 2615 mode_lib->vba.VRatio[k], 2616 mode_lib->vba.SwathWidthY[k], 2617 dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1), 2618 mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k], 2619 mode_lib->vba.XFCTSlvVupdateOffset, 2620 mode_lib->vba.XFCTSlvVupdateWidth, 2621 mode_lib->vba.XFCTSlvVreadyOffset, 2622 mode_lib->vba.XFCXBUFLatencyTolerance, 2623 mode_lib->vba.XFCFillBWOverhead, 2624 mode_lib->vba.XFCSlvChunkSize, 2625 mode_lib->vba.XFCBusTransportTime, 2626 mode_lib->vba.TCalc, 2627 TWait, 2628 &mode_lib->vba.SrcActiveDrainRate, 2629 &mode_lib->vba.TInitXFill, 2630 &mode_lib->vba.TslvChk); 2631 mode_lib->vba.XFCRemoteSurfaceFlipLatency[k] = 2632 dml_floor( 2633 mode_lib->vba.XFCRemoteSurfaceFlipDelay 2634 / (mode_lib->vba.HTotal[k] 2635 / mode_lib->vba.PixelClock[k]), 2636 1); 2637 mode_lib->vba.XFCTransferDelay[k] = 2638 dml_ceil( 2639 mode_lib->vba.XFCBusTransportTime 2640 / (mode_lib->vba.HTotal[k] 2641 / mode_lib->vba.PixelClock[k]), 2642 1); 2643 mode_lib->vba.XFCPrechargeDelay[k] = 2644 dml_ceil( 2645 (mode_lib->vba.XFCBusTransportTime 2646 + mode_lib->vba.TInitXFill 2647 + mode_lib->vba.TslvChk) 2648 / (mode_lib->vba.HTotal[k] 2649 / mode_lib->vba.PixelClock[k]), 2650 1); 2651 mode_lib->vba.InitFillLevel = mode_lib->vba.XFCXBUFLatencyTolerance 2652 * mode_lib->vba.SrcActiveDrainRate; 2653 mode_lib->vba.FinalFillMargin = 2654 (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k] 2655 + mode_lib->vba.DestinationLinesToRequestRowInVBlank[k]) 2656 * mode_lib->vba.HTotal[k] 2657 / mode_lib->vba.PixelClock[k] 2658 * mode_lib->vba.SrcActiveDrainRate 2659 + mode_lib->vba.XFCFillConstant; 2660 mode_lib->vba.FinalFillLevel = mode_lib->vba.XFCRemoteSurfaceFlipDelay 2661 * mode_lib->vba.SrcActiveDrainRate 2662 + mode_lib->vba.FinalFillMargin; 2663 mode_lib->vba.RemainingFillLevel = dml_max( 2664 0.0, 2665 mode_lib->vba.FinalFillLevel - mode_lib->vba.InitFillLevel); 2666 mode_lib->vba.TFinalxFill = mode_lib->vba.RemainingFillLevel 2667 / (mode_lib->vba.SrcActiveDrainRate 2668 * mode_lib->vba.XFCFillBWOverhead / 100); 2669 mode_lib->vba.XFCPrefetchMargin[k] = 2670 mode_lib->vba.XFCRemoteSurfaceFlipDelay 2671 + mode_lib->vba.TFinalxFill 2672 + (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k] 2673 + mode_lib->vba.DestinationLinesToRequestRowInVBlank[k]) 2674 * mode_lib->vba.HTotal[k] 2675 / mode_lib->vba.PixelClock[k]; 2676 } else { 2677 mode_lib->vba.XFCSlaveVUpdateOffset[k] = 0; 2678 mode_lib->vba.XFCSlaveVupdateWidth[k] = 0; 2679 mode_lib->vba.XFCSlaveVReadyOffset[k] = 0; 2680 mode_lib->vba.XFCRemoteSurfaceFlipLatency[k] = 0; 2681 mode_lib->vba.XFCPrechargeDelay[k] = 0; 2682 mode_lib->vba.XFCTransferDelay[k] = 0; 2683 mode_lib->vba.XFCPrefetchMargin[k] = 0; 2684 } 2685 } 2686 { 2687 unsigned int VStartupMargin = 0; 2688 bool FirstMainPlane = true; 2689 2690 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2691 if (mode_lib->vba.BlendingAndTiming[k] == k) { 2692 unsigned int Margin = (mode_lib->vba.MaxVStartupLines[k] - mode_lib->vba.VStartup[k]) 2693 * mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]; 2694 2695 if (FirstMainPlane) { 2696 VStartupMargin = Margin; 2697 FirstMainPlane = false; 2698 } else 2699 VStartupMargin = dml_min(VStartupMargin, Margin); 2700 } 2701 2702 if (mode_lib->vba.UseMaximumVStartup) { 2703 if (mode_lib->vba.VTotal_Max[k] == mode_lib->vba.VTotal[k]) { 2704 //only use max vstart if it is not drr or lateflip. 2705 mode_lib->vba.VStartup[k] = mode_lib->vba.MaxVStartupLines[mode_lib->vba.BlendingAndTiming[k]]; 2706 } 2707 } 2708 } 2709 } 2710 } 2711 2712 static void dml20_DisplayPipeConfiguration(struct display_mode_lib *mode_lib) 2713 { 2714 double BytePerPixDETY; 2715 double BytePerPixDETC; 2716 double Read256BytesBlockHeightY; 2717 double Read256BytesBlockHeightC; 2718 double Read256BytesBlockWidthY; 2719 double Read256BytesBlockWidthC; 2720 double MaximumSwathHeightY; 2721 double MaximumSwathHeightC; 2722 double MinimumSwathHeightY; 2723 double MinimumSwathHeightC; 2724 double SwathWidth; 2725 double SwathWidthGranularityY; 2726 double SwathWidthGranularityC; 2727 double RoundedUpMaxSwathSizeBytesY; 2728 double RoundedUpMaxSwathSizeBytesC; 2729 unsigned int j, k; 2730 2731 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 2732 bool MainPlaneDoesODMCombine = false; 2733 2734 if (mode_lib->vba.SourcePixelFormat[k] == dm_444_64) { 2735 BytePerPixDETY = 8; 2736 BytePerPixDETC = 0; 2737 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_32) { 2738 BytePerPixDETY = 4; 2739 BytePerPixDETC = 0; 2740 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_16) { 2741 BytePerPixDETY = 2; 2742 BytePerPixDETC = 0; 2743 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_8) { 2744 BytePerPixDETY = 1; 2745 BytePerPixDETC = 0; 2746 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8) { 2747 BytePerPixDETY = 1; 2748 BytePerPixDETC = 2; 2749 } else { 2750 BytePerPixDETY = 4.0 / 3.0; 2751 BytePerPixDETC = 8.0 / 3.0; 2752 } 2753 2754 if ((mode_lib->vba.SourcePixelFormat[k] == dm_444_64 2755 || mode_lib->vba.SourcePixelFormat[k] == dm_444_32 2756 || mode_lib->vba.SourcePixelFormat[k] == dm_444_16 2757 || mode_lib->vba.SourcePixelFormat[k] == dm_444_8)) { 2758 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) { 2759 Read256BytesBlockHeightY = 1; 2760 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_64) { 2761 Read256BytesBlockHeightY = 4; 2762 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_32 2763 || mode_lib->vba.SourcePixelFormat[k] == dm_444_16) { 2764 Read256BytesBlockHeightY = 8; 2765 } else { 2766 Read256BytesBlockHeightY = 16; 2767 } 2768 Read256BytesBlockWidthY = 256 / dml_ceil(BytePerPixDETY, 1) 2769 / Read256BytesBlockHeightY; 2770 Read256BytesBlockHeightC = 0; 2771 Read256BytesBlockWidthC = 0; 2772 } else { 2773 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) { 2774 Read256BytesBlockHeightY = 1; 2775 Read256BytesBlockHeightC = 1; 2776 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8) { 2777 Read256BytesBlockHeightY = 16; 2778 Read256BytesBlockHeightC = 8; 2779 } else { 2780 Read256BytesBlockHeightY = 8; 2781 Read256BytesBlockHeightC = 8; 2782 } 2783 Read256BytesBlockWidthY = 256 / dml_ceil(BytePerPixDETY, 1) 2784 / Read256BytesBlockHeightY; 2785 Read256BytesBlockWidthC = 256 / dml_ceil(BytePerPixDETC, 2) 2786 / Read256BytesBlockHeightC; 2787 } 2788 2789 if (mode_lib->vba.SourceScan[k] == dm_horz) { 2790 MaximumSwathHeightY = Read256BytesBlockHeightY; 2791 MaximumSwathHeightC = Read256BytesBlockHeightC; 2792 } else { 2793 MaximumSwathHeightY = Read256BytesBlockWidthY; 2794 MaximumSwathHeightC = Read256BytesBlockWidthC; 2795 } 2796 2797 if ((mode_lib->vba.SourcePixelFormat[k] == dm_444_64 2798 || mode_lib->vba.SourcePixelFormat[k] == dm_444_32 2799 || mode_lib->vba.SourcePixelFormat[k] == dm_444_16 2800 || mode_lib->vba.SourcePixelFormat[k] == dm_444_8)) { 2801 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear 2802 || (mode_lib->vba.SourcePixelFormat[k] == dm_444_64 2803 && (mode_lib->vba.SurfaceTiling[k] 2804 == dm_sw_4kb_s 2805 || mode_lib->vba.SurfaceTiling[k] 2806 == dm_sw_4kb_s_x 2807 || mode_lib->vba.SurfaceTiling[k] 2808 == dm_sw_64kb_s 2809 || mode_lib->vba.SurfaceTiling[k] 2810 == dm_sw_64kb_s_t 2811 || mode_lib->vba.SurfaceTiling[k] 2812 == dm_sw_64kb_s_x 2813 || mode_lib->vba.SurfaceTiling[k] 2814 == dm_sw_var_s 2815 || mode_lib->vba.SurfaceTiling[k] 2816 == dm_sw_var_s_x) 2817 && mode_lib->vba.SourceScan[k] == dm_horz)) { 2818 MinimumSwathHeightY = MaximumSwathHeightY; 2819 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_8 2820 && mode_lib->vba.SourceScan[k] != dm_horz) { 2821 MinimumSwathHeightY = MaximumSwathHeightY; 2822 } else { 2823 MinimumSwathHeightY = MaximumSwathHeightY / 2.0; 2824 } 2825 MinimumSwathHeightC = MaximumSwathHeightC; 2826 } else { 2827 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) { 2828 MinimumSwathHeightY = MaximumSwathHeightY; 2829 MinimumSwathHeightC = MaximumSwathHeightC; 2830 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8 2831 && mode_lib->vba.SourceScan[k] == dm_horz) { 2832 MinimumSwathHeightY = MaximumSwathHeightY / 2.0; 2833 MinimumSwathHeightC = MaximumSwathHeightC; 2834 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10 2835 && mode_lib->vba.SourceScan[k] == dm_horz) { 2836 MinimumSwathHeightC = MaximumSwathHeightC / 2.0; 2837 MinimumSwathHeightY = MaximumSwathHeightY; 2838 } else { 2839 MinimumSwathHeightY = MaximumSwathHeightY; 2840 MinimumSwathHeightC = MaximumSwathHeightC; 2841 } 2842 } 2843 2844 if (mode_lib->vba.SourceScan[k] == dm_horz) { 2845 SwathWidth = mode_lib->vba.ViewportWidth[k]; 2846 } else { 2847 SwathWidth = mode_lib->vba.ViewportHeight[k]; 2848 } 2849 2850 if (mode_lib->vba.ODMCombineEnabled[k] == true) { 2851 MainPlaneDoesODMCombine = true; 2852 } 2853 for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) { 2854 if (mode_lib->vba.BlendingAndTiming[k] == j 2855 && mode_lib->vba.ODMCombineEnabled[j] == true) { 2856 MainPlaneDoesODMCombine = true; 2857 } 2858 } 2859 2860 if (MainPlaneDoesODMCombine == true) { 2861 SwathWidth = dml_min( 2862 SwathWidth, 2863 mode_lib->vba.HActive[k] / 2.0 * mode_lib->vba.HRatio[k]); 2864 } else { 2865 if (mode_lib->vba.DPPPerPlane[k] == 0) 2866 SwathWidth = 0; 2867 else 2868 SwathWidth = SwathWidth / mode_lib->vba.DPPPerPlane[k]; 2869 } 2870 2871 SwathWidthGranularityY = 256 / dml_ceil(BytePerPixDETY, 1) / MaximumSwathHeightY; 2872 RoundedUpMaxSwathSizeBytesY = (dml_ceil( 2873 (double) (SwathWidth - 1), 2874 SwathWidthGranularityY) + SwathWidthGranularityY) * BytePerPixDETY 2875 * MaximumSwathHeightY; 2876 if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10) { 2877 RoundedUpMaxSwathSizeBytesY = dml_ceil(RoundedUpMaxSwathSizeBytesY, 256) 2878 + 256; 2879 } 2880 if (MaximumSwathHeightC > 0) { 2881 SwathWidthGranularityC = 256.0 / dml_ceil(BytePerPixDETC, 2) 2882 / MaximumSwathHeightC; 2883 RoundedUpMaxSwathSizeBytesC = (dml_ceil( 2884 (double) (SwathWidth / 2.0 - 1), 2885 SwathWidthGranularityC) + SwathWidthGranularityC) 2886 * BytePerPixDETC * MaximumSwathHeightC; 2887 if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10) { 2888 RoundedUpMaxSwathSizeBytesC = dml_ceil( 2889 RoundedUpMaxSwathSizeBytesC, 2890 256) + 256; 2891 } 2892 } else 2893 RoundedUpMaxSwathSizeBytesC = 0.0; 2894 2895 if (RoundedUpMaxSwathSizeBytesY + RoundedUpMaxSwathSizeBytesC 2896 <= mode_lib->vba.DETBufferSizeInKByte * 1024.0 / 2.0) { 2897 mode_lib->vba.SwathHeightY[k] = MaximumSwathHeightY; 2898 mode_lib->vba.SwathHeightC[k] = MaximumSwathHeightC; 2899 } else { 2900 mode_lib->vba.SwathHeightY[k] = MinimumSwathHeightY; 2901 mode_lib->vba.SwathHeightC[k] = MinimumSwathHeightC; 2902 } 2903 2904 if (mode_lib->vba.SwathHeightC[k] == 0) { 2905 mode_lib->vba.DETBufferSizeY[k] = mode_lib->vba.DETBufferSizeInKByte * 1024; 2906 mode_lib->vba.DETBufferSizeC[k] = 0; 2907 } else if (mode_lib->vba.SwathHeightY[k] <= mode_lib->vba.SwathHeightC[k]) { 2908 mode_lib->vba.DETBufferSizeY[k] = mode_lib->vba.DETBufferSizeInKByte 2909 * 1024.0 / 2; 2910 mode_lib->vba.DETBufferSizeC[k] = mode_lib->vba.DETBufferSizeInKByte 2911 * 1024.0 / 2; 2912 } else { 2913 mode_lib->vba.DETBufferSizeY[k] = mode_lib->vba.DETBufferSizeInKByte 2914 * 1024.0 * 2 / 3; 2915 mode_lib->vba.DETBufferSizeC[k] = mode_lib->vba.DETBufferSizeInKByte 2916 * 1024.0 / 3; 2917 } 2918 } 2919 } 2920 2921 static double CalculateTWait( 2922 unsigned int PrefetchMode, 2923 double DRAMClockChangeLatency, 2924 double UrgentLatencyPixelDataOnly, 2925 double SREnterPlusExitTime) 2926 { 2927 if (PrefetchMode == 0) { 2928 return dml_max( 2929 DRAMClockChangeLatency + UrgentLatencyPixelDataOnly, 2930 dml_max(SREnterPlusExitTime, UrgentLatencyPixelDataOnly)); 2931 } else if (PrefetchMode == 1) { 2932 return dml_max(SREnterPlusExitTime, UrgentLatencyPixelDataOnly); 2933 } else { 2934 return UrgentLatencyPixelDataOnly; 2935 } 2936 } 2937 2938 static double CalculateRemoteSurfaceFlipDelay( 2939 struct display_mode_lib *mode_lib, 2940 double VRatio, 2941 double SwathWidth, 2942 double Bpp, 2943 double LineTime, 2944 double XFCTSlvVupdateOffset, 2945 double XFCTSlvVupdateWidth, 2946 double XFCTSlvVreadyOffset, 2947 double XFCXBUFLatencyTolerance, 2948 double XFCFillBWOverhead, 2949 double XFCSlvChunkSize, 2950 double XFCBusTransportTime, 2951 double TCalc, 2952 double TWait, 2953 double *SrcActiveDrainRate, 2954 double *TInitXFill, 2955 double *TslvChk) 2956 { 2957 double TSlvSetup, AvgfillRate, result; 2958 2959 *SrcActiveDrainRate = VRatio * SwathWidth * Bpp / LineTime; 2960 TSlvSetup = XFCTSlvVupdateOffset + XFCTSlvVupdateWidth + XFCTSlvVreadyOffset; 2961 *TInitXFill = XFCXBUFLatencyTolerance / (1 + XFCFillBWOverhead / 100); 2962 AvgfillRate = *SrcActiveDrainRate * (1 + XFCFillBWOverhead / 100); 2963 *TslvChk = XFCSlvChunkSize / AvgfillRate; 2964 dml_print( 2965 "DML::CalculateRemoteSurfaceFlipDelay: SrcActiveDrainRate: %f\n", 2966 *SrcActiveDrainRate); 2967 dml_print("DML::CalculateRemoteSurfaceFlipDelay: TSlvSetup: %f\n", TSlvSetup); 2968 dml_print("DML::CalculateRemoteSurfaceFlipDelay: TInitXFill: %f\n", *TInitXFill); 2969 dml_print("DML::CalculateRemoteSurfaceFlipDelay: AvgfillRate: %f\n", AvgfillRate); 2970 dml_print("DML::CalculateRemoteSurfaceFlipDelay: TslvChk: %f\n", *TslvChk); 2971 result = 2 * XFCBusTransportTime + TSlvSetup + TCalc + TWait + *TslvChk + *TInitXFill; // TODO: This doesn't seem to match programming guide 2972 dml_print("DML::CalculateRemoteSurfaceFlipDelay: RemoteSurfaceFlipDelay: %f\n", result); 2973 return result; 2974 } 2975 2976 static double CalculateWriteBackDelay( 2977 enum source_format_class WritebackPixelFormat, 2978 double WritebackHRatio, 2979 double WritebackVRatio, 2980 unsigned int WritebackLumaHTaps, 2981 unsigned int WritebackLumaVTaps, 2982 unsigned int WritebackChromaHTaps, 2983 unsigned int WritebackChromaVTaps, 2984 unsigned int WritebackDestinationWidth) 2985 { 2986 double CalculateWriteBackDelay = 2987 dml_max( 2988 dml_ceil(WritebackLumaHTaps / 4.0, 1) / WritebackHRatio, 2989 WritebackLumaVTaps * dml_ceil(1.0 / WritebackVRatio, 1) 2990 * dml_ceil( 2991 WritebackDestinationWidth 2992 / 4.0, 2993 1) 2994 + dml_ceil(1.0 / WritebackVRatio, 1) 2995 * (dml_ceil( 2996 WritebackLumaVTaps 2997 / 4.0, 2998 1) + 4)); 2999 3000 if (WritebackPixelFormat != dm_444_32) { 3001 CalculateWriteBackDelay = 3002 dml_max( 3003 CalculateWriteBackDelay, 3004 dml_max( 3005 dml_ceil( 3006 WritebackChromaHTaps 3007 / 2.0, 3008 1) 3009 / (2 3010 * WritebackHRatio), 3011 WritebackChromaVTaps 3012 * dml_ceil( 3013 1 3014 / (2 3015 * WritebackVRatio), 3016 1) 3017 * dml_ceil( 3018 WritebackDestinationWidth 3019 / 2.0 3020 / 2.0, 3021 1) 3022 + dml_ceil( 3023 1 3024 / (2 3025 * WritebackVRatio), 3026 1) 3027 * (dml_ceil( 3028 WritebackChromaVTaps 3029 / 4.0, 3030 1) 3031 + 4))); 3032 } 3033 return CalculateWriteBackDelay; 3034 } 3035 3036 static void CalculateActiveRowBandwidth( 3037 bool GPUVMEnable, 3038 enum source_format_class SourcePixelFormat, 3039 double VRatio, 3040 bool DCCEnable, 3041 double LineTime, 3042 unsigned int MetaRowByteLuma, 3043 unsigned int MetaRowByteChroma, 3044 unsigned int meta_row_height_luma, 3045 unsigned int meta_row_height_chroma, 3046 unsigned int PixelPTEBytesPerRowLuma, 3047 unsigned int PixelPTEBytesPerRowChroma, 3048 unsigned int dpte_row_height_luma, 3049 unsigned int dpte_row_height_chroma, 3050 double *meta_row_bw, 3051 double *dpte_row_bw, 3052 double *qual_row_bw) 3053 { 3054 if (DCCEnable != true) { 3055 *meta_row_bw = 0; 3056 } else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10) { 3057 *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime) 3058 + VRatio / 2 * MetaRowByteChroma 3059 / (meta_row_height_chroma * LineTime); 3060 } else { 3061 *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime); 3062 } 3063 3064 if (GPUVMEnable != true) { 3065 *dpte_row_bw = 0; 3066 } else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10) { 3067 *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime) 3068 + VRatio / 2 * PixelPTEBytesPerRowChroma 3069 / (dpte_row_height_chroma * LineTime); 3070 } else { 3071 *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime); 3072 } 3073 3074 if ((SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10)) { 3075 *qual_row_bw = *meta_row_bw + *dpte_row_bw; 3076 } else { 3077 *qual_row_bw = 0; 3078 } 3079 } 3080 3081 static void CalculateFlipSchedule( 3082 struct display_mode_lib *mode_lib, 3083 double UrgentExtraLatency, 3084 double UrgentLatencyPixelDataOnly, 3085 unsigned int GPUVMMaxPageTableLevels, 3086 bool GPUVMEnable, 3087 double BandwidthAvailableForImmediateFlip, 3088 unsigned int TotImmediateFlipBytes, 3089 enum source_format_class SourcePixelFormat, 3090 unsigned int ImmediateFlipBytes, 3091 double LineTime, 3092 double VRatio, 3093 double Tno_bw, 3094 double PDEAndMetaPTEBytesFrame, 3095 unsigned int MetaRowByte, 3096 unsigned int PixelPTEBytesPerRow, 3097 bool DCCEnable, 3098 unsigned int dpte_row_height, 3099 unsigned int meta_row_height, 3100 double qual_row_bw, 3101 double *DestinationLinesToRequestVMInImmediateFlip, 3102 double *DestinationLinesToRequestRowInImmediateFlip, 3103 double *final_flip_bw, 3104 bool *ImmediateFlipSupportedForPipe) 3105 { 3106 double min_row_time = 0.0; 3107 3108 if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10) { 3109 *DestinationLinesToRequestVMInImmediateFlip = 0.0; 3110 *DestinationLinesToRequestRowInImmediateFlip = 0.0; 3111 *final_flip_bw = qual_row_bw; 3112 *ImmediateFlipSupportedForPipe = true; 3113 } else { 3114 double TimeForFetchingMetaPTEImmediateFlip; 3115 double TimeForFetchingRowInVBlankImmediateFlip; 3116 3117 if (GPUVMEnable == true) { 3118 mode_lib->vba.ImmediateFlipBW[0] = BandwidthAvailableForImmediateFlip 3119 * ImmediateFlipBytes / TotImmediateFlipBytes; 3120 TimeForFetchingMetaPTEImmediateFlip = 3121 dml_max( 3122 Tno_bw 3123 + PDEAndMetaPTEBytesFrame 3124 / mode_lib->vba.ImmediateFlipBW[0], 3125 dml_max( 3126 UrgentExtraLatency 3127 + UrgentLatencyPixelDataOnly 3128 * (GPUVMMaxPageTableLevels 3129 - 1), 3130 LineTime / 4.0)); 3131 } else { 3132 TimeForFetchingMetaPTEImmediateFlip = 0; 3133 } 3134 3135 *DestinationLinesToRequestVMInImmediateFlip = dml_floor( 3136 4.0 * (TimeForFetchingMetaPTEImmediateFlip / LineTime + 0.125), 3137 1) / 4.0; 3138 3139 if ((GPUVMEnable == true || DCCEnable == true)) { 3140 mode_lib->vba.ImmediateFlipBW[0] = BandwidthAvailableForImmediateFlip 3141 * ImmediateFlipBytes / TotImmediateFlipBytes; 3142 TimeForFetchingRowInVBlankImmediateFlip = dml_max( 3143 (MetaRowByte + PixelPTEBytesPerRow) 3144 / mode_lib->vba.ImmediateFlipBW[0], 3145 dml_max(UrgentLatencyPixelDataOnly, LineTime / 4.0)); 3146 } else { 3147 TimeForFetchingRowInVBlankImmediateFlip = 0; 3148 } 3149 3150 *DestinationLinesToRequestRowInImmediateFlip = dml_floor( 3151 4.0 * (TimeForFetchingRowInVBlankImmediateFlip / LineTime + 0.125), 3152 1) / 4.0; 3153 3154 if (GPUVMEnable == true) { 3155 *final_flip_bw = 3156 dml_max( 3157 PDEAndMetaPTEBytesFrame 3158 / (*DestinationLinesToRequestVMInImmediateFlip 3159 * LineTime), 3160 (MetaRowByte + PixelPTEBytesPerRow) 3161 / (TimeForFetchingRowInVBlankImmediateFlip 3162 * LineTime)); 3163 } else if (MetaRowByte + PixelPTEBytesPerRow > 0) { 3164 *final_flip_bw = (MetaRowByte + PixelPTEBytesPerRow) 3165 / (TimeForFetchingRowInVBlankImmediateFlip * LineTime); 3166 } else { 3167 *final_flip_bw = 0; 3168 } 3169 3170 if (GPUVMEnable && !DCCEnable) 3171 min_row_time = dpte_row_height * LineTime / VRatio; 3172 else if (!GPUVMEnable && DCCEnable) 3173 min_row_time = meta_row_height * LineTime / VRatio; 3174 else 3175 min_row_time = dml_min(dpte_row_height, meta_row_height) * LineTime 3176 / VRatio; 3177 3178 if (*DestinationLinesToRequestVMInImmediateFlip >= 8 3179 || *DestinationLinesToRequestRowInImmediateFlip >= 16 3180 || TimeForFetchingMetaPTEImmediateFlip 3181 + 2 * TimeForFetchingRowInVBlankImmediateFlip 3182 > min_row_time) 3183 *ImmediateFlipSupportedForPipe = false; 3184 else 3185 *ImmediateFlipSupportedForPipe = true; 3186 } 3187 } 3188 3189 static unsigned int TruncToValidBPP( 3190 double DecimalBPP, 3191 bool DSCEnabled, 3192 enum output_encoder_class Output, 3193 enum output_format_class Format, 3194 unsigned int DSCInputBitPerComponent) 3195 { 3196 if (Output == dm_hdmi) { 3197 if (Format == dm_420) { 3198 if (DecimalBPP >= 18) 3199 return 18; 3200 else if (DecimalBPP >= 15) 3201 return 15; 3202 else if (DecimalBPP >= 12) 3203 return 12; 3204 else 3205 return BPP_INVALID; 3206 } else if (Format == dm_444) { 3207 if (DecimalBPP >= 36) 3208 return 36; 3209 else if (DecimalBPP >= 30) 3210 return 30; 3211 else if (DecimalBPP >= 24) 3212 return 24; 3213 else if (DecimalBPP >= 18) 3214 return 18; 3215 else 3216 return BPP_INVALID; 3217 } else { 3218 if (DecimalBPP / 1.5 >= 24) 3219 return 24; 3220 else if (DecimalBPP / 1.5 >= 20) 3221 return 20; 3222 else if (DecimalBPP / 1.5 >= 16) 3223 return 16; 3224 else 3225 return BPP_INVALID; 3226 } 3227 } else { 3228 if (DSCEnabled) { 3229 if (Format == dm_420) { 3230 if (DecimalBPP < 6) 3231 return BPP_INVALID; 3232 else if (DecimalBPP >= 1.5 * DSCInputBitPerComponent - 1 / 16) 3233 return 1.5 * DSCInputBitPerComponent - 1 / 16; 3234 else 3235 return dml_floor(16 * DecimalBPP, 1) / 16; 3236 } else if (Format == dm_n422) { 3237 if (DecimalBPP < 7) 3238 return BPP_INVALID; 3239 else if (DecimalBPP >= 2 * DSCInputBitPerComponent - 1 / 16) 3240 return 2 * DSCInputBitPerComponent - 1 / 16; 3241 else 3242 return dml_floor(16 * DecimalBPP, 1) / 16; 3243 } else { 3244 if (DecimalBPP < 8) 3245 return BPP_INVALID; 3246 else if (DecimalBPP >= 3 * DSCInputBitPerComponent - 1 / 16) 3247 return 3 * DSCInputBitPerComponent - 1 / 16; 3248 else 3249 return dml_floor(16 * DecimalBPP, 1) / 16; 3250 } 3251 } else if (Format == dm_420) { 3252 if (DecimalBPP >= 18) 3253 return 18; 3254 else if (DecimalBPP >= 15) 3255 return 15; 3256 else if (DecimalBPP >= 12) 3257 return 12; 3258 else 3259 return BPP_INVALID; 3260 } else if (Format == dm_s422 || Format == dm_n422) { 3261 if (DecimalBPP >= 24) 3262 return 24; 3263 else if (DecimalBPP >= 20) 3264 return 20; 3265 else if (DecimalBPP >= 16) 3266 return 16; 3267 else 3268 return BPP_INVALID; 3269 } else { 3270 if (DecimalBPP >= 36) 3271 return 36; 3272 else if (DecimalBPP >= 30) 3273 return 30; 3274 else if (DecimalBPP >= 24) 3275 return 24; 3276 else if (DecimalBPP >= 18) 3277 return 18; 3278 else 3279 return BPP_INVALID; 3280 } 3281 } 3282 } 3283 3284 void dml20_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_lib) 3285 { 3286 struct vba_vars_st *locals = &mode_lib->vba; 3287 3288 int i; 3289 unsigned int j, k, m; 3290 3291 /*MODE SUPPORT, VOLTAGE STATE AND SOC CONFIGURATION*/ 3292 3293 /*Scale Ratio, taps Support Check*/ 3294 3295 mode_lib->vba.ScaleRatioAndTapsSupport = true; 3296 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 3297 if (mode_lib->vba.ScalerEnabled[k] == false 3298 && ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64 3299 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32 3300 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16 3301 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16 3302 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8) 3303 || mode_lib->vba.HRatio[k] != 1.0 3304 || mode_lib->vba.htaps[k] != 1.0 3305 || mode_lib->vba.VRatio[k] != 1.0 3306 || mode_lib->vba.vtaps[k] != 1.0)) { 3307 mode_lib->vba.ScaleRatioAndTapsSupport = false; 3308 } else if (mode_lib->vba.vtaps[k] < 1.0 || mode_lib->vba.vtaps[k] > 8.0 3309 || mode_lib->vba.htaps[k] < 1.0 || mode_lib->vba.htaps[k] > 8.0 3310 || (mode_lib->vba.htaps[k] > 1.0 3311 && (mode_lib->vba.htaps[k] % 2) == 1) 3312 || mode_lib->vba.HRatio[k] > mode_lib->vba.MaxHSCLRatio 3313 || mode_lib->vba.VRatio[k] > mode_lib->vba.MaxVSCLRatio 3314 || mode_lib->vba.HRatio[k] > mode_lib->vba.htaps[k] 3315 || mode_lib->vba.VRatio[k] > mode_lib->vba.vtaps[k] 3316 || (mode_lib->vba.SourcePixelFormat[k] != dm_444_64 3317 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32 3318 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16 3319 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16 3320 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8 3321 && (mode_lib->vba.HRatio[k] / 2.0 3322 > mode_lib->vba.HTAPsChroma[k] 3323 || mode_lib->vba.VRatio[k] / 2.0 3324 > mode_lib->vba.VTAPsChroma[k]))) { 3325 mode_lib->vba.ScaleRatioAndTapsSupport = false; 3326 } 3327 } 3328 /*Source Format, Pixel Format and Scan Support Check*/ 3329 3330 mode_lib->vba.SourceFormatPixelAndScanSupport = true; 3331 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 3332 if ((mode_lib->vba.SurfaceTiling[k] == dm_sw_linear 3333 && mode_lib->vba.SourceScan[k] != dm_horz) 3334 || ((mode_lib->vba.SurfaceTiling[k] == dm_sw_4kb_d 3335 || mode_lib->vba.SurfaceTiling[k] == dm_sw_4kb_d_x 3336 || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d 3337 || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d_t 3338 || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d_x 3339 || mode_lib->vba.SurfaceTiling[k] == dm_sw_var_d 3340 || mode_lib->vba.SurfaceTiling[k] == dm_sw_var_d_x) 3341 && mode_lib->vba.SourcePixelFormat[k] != dm_444_64) 3342 || (mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_r_x 3343 && (mode_lib->vba.SourcePixelFormat[k] == dm_mono_8 3344 || mode_lib->vba.SourcePixelFormat[k] 3345 == dm_420_8 3346 || mode_lib->vba.SourcePixelFormat[k] 3347 == dm_420_10)) 3348 || (((mode_lib->vba.SurfaceTiling[k] == dm_sw_gfx7_2d_thin_gl 3349 || mode_lib->vba.SurfaceTiling[k] 3350 == dm_sw_gfx7_2d_thin_lvp) 3351 && !((mode_lib->vba.SourcePixelFormat[k] 3352 == dm_444_64 3353 || mode_lib->vba.SourcePixelFormat[k] 3354 == dm_444_32) 3355 && mode_lib->vba.SourceScan[k] 3356 == dm_horz 3357 && mode_lib->vba.SupportGFX7CompatibleTilingIn32bppAnd64bpp 3358 == true 3359 && mode_lib->vba.DCCEnable[k] 3360 == false)) 3361 || (mode_lib->vba.DCCEnable[k] == true 3362 && (mode_lib->vba.SurfaceTiling[k] 3363 == dm_sw_linear 3364 || mode_lib->vba.SourcePixelFormat[k] 3365 == dm_420_8 3366 || mode_lib->vba.SourcePixelFormat[k] 3367 == dm_420_10)))) { 3368 mode_lib->vba.SourceFormatPixelAndScanSupport = false; 3369 } 3370 } 3371 /*Bandwidth Support Check*/ 3372 3373 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 3374 if (mode_lib->vba.SourcePixelFormat[k] == dm_444_64) { 3375 locals->BytePerPixelInDETY[k] = 8.0; 3376 locals->BytePerPixelInDETC[k] = 0.0; 3377 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_32) { 3378 locals->BytePerPixelInDETY[k] = 4.0; 3379 locals->BytePerPixelInDETC[k] = 0.0; 3380 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_16 3381 || mode_lib->vba.SourcePixelFormat[k] == dm_mono_16) { 3382 locals->BytePerPixelInDETY[k] = 2.0; 3383 locals->BytePerPixelInDETC[k] = 0.0; 3384 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_mono_8) { 3385 locals->BytePerPixelInDETY[k] = 1.0; 3386 locals->BytePerPixelInDETC[k] = 0.0; 3387 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8) { 3388 locals->BytePerPixelInDETY[k] = 1.0; 3389 locals->BytePerPixelInDETC[k] = 2.0; 3390 } else { 3391 locals->BytePerPixelInDETY[k] = 4.0 / 3; 3392 locals->BytePerPixelInDETC[k] = 8.0 / 3; 3393 } 3394 if (mode_lib->vba.SourceScan[k] == dm_horz) { 3395 locals->SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportWidth[k]; 3396 } else { 3397 locals->SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportHeight[k]; 3398 } 3399 } 3400 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 3401 locals->ReadBandwidthLuma[k] = locals->SwathWidthYSingleDPP[k] * dml_ceil(locals->BytePerPixelInDETY[k], 1.0) 3402 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k]; 3403 locals->ReadBandwidthChroma[k] = locals->SwathWidthYSingleDPP[k] / 2 * dml_ceil(locals->BytePerPixelInDETC[k], 2.0) 3404 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k] / 2.0; 3405 locals->ReadBandwidth[k] = locals->ReadBandwidthLuma[k] + locals->ReadBandwidthChroma[k]; 3406 } 3407 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 3408 if (mode_lib->vba.WritebackEnable[k] == true 3409 && mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) { 3410 locals->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k] 3411 * mode_lib->vba.WritebackDestinationHeight[k] 3412 / (mode_lib->vba.WritebackSourceHeight[k] 3413 * mode_lib->vba.HTotal[k] 3414 / mode_lib->vba.PixelClock[k]) * 4.0; 3415 } else if (mode_lib->vba.WritebackEnable[k] == true 3416 && mode_lib->vba.WritebackPixelFormat[k] == dm_420_10) { 3417 locals->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k] 3418 * mode_lib->vba.WritebackDestinationHeight[k] 3419 / (mode_lib->vba.WritebackSourceHeight[k] 3420 * mode_lib->vba.HTotal[k] 3421 / mode_lib->vba.PixelClock[k]) * 3.0; 3422 } else if (mode_lib->vba.WritebackEnable[k] == true) { 3423 locals->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k] 3424 * mode_lib->vba.WritebackDestinationHeight[k] 3425 / (mode_lib->vba.WritebackSourceHeight[k] 3426 * mode_lib->vba.HTotal[k] 3427 / mode_lib->vba.PixelClock[k]) * 1.5; 3428 } else { 3429 locals->WriteBandwidth[k] = 0.0; 3430 } 3431 } 3432 mode_lib->vba.DCCEnabledInAnyPlane = false; 3433 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 3434 if (mode_lib->vba.DCCEnable[k] == true) { 3435 mode_lib->vba.DCCEnabledInAnyPlane = true; 3436 } 3437 } 3438 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) { 3439 locals->FabricAndDRAMBandwidthPerState[i] = dml_min( 3440 mode_lib->vba.DRAMSpeedPerState[i] * mode_lib->vba.NumberOfChannels 3441 * mode_lib->vba.DRAMChannelWidth, 3442 mode_lib->vba.FabricClockPerState[i] 3443 * mode_lib->vba.FabricDatapathToDCNDataReturn) / 1000; 3444 locals->ReturnBWToDCNPerState = dml_min(locals->ReturnBusWidth * locals->DCFCLKPerState[i], 3445 locals->FabricAndDRAMBandwidthPerState[i] * 1000) 3446 * locals->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly / 100; 3447 3448 locals->ReturnBWPerState[i] = locals->ReturnBWToDCNPerState; 3449 3450 if (locals->DCCEnabledInAnyPlane == true && locals->ReturnBWToDCNPerState > locals->DCFCLKPerState[i] * locals->ReturnBusWidth / 4) { 3451 locals->ReturnBWPerState[i] = dml_min(locals->ReturnBWPerState[i], 3452 locals->ReturnBWToDCNPerState * 4 * (1 - locals->UrgentLatency / 3453 ((locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024 3454 / (locals->ReturnBWToDCNPerState - locals->DCFCLKPerState[i] 3455 * locals->ReturnBusWidth / 4) + locals->UrgentLatency))); 3456 } 3457 locals->CriticalPoint = 2 * locals->ReturnBusWidth * locals->DCFCLKPerState[i] * 3458 locals->UrgentLatency / (locals->ReturnBWToDCNPerState * locals->UrgentLatency 3459 + (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024); 3460 3461 if (locals->DCCEnabledInAnyPlane && locals->CriticalPoint > 1 && locals->CriticalPoint < 4) { 3462 locals->ReturnBWPerState[i] = dml_min(locals->ReturnBWPerState[i], 3463 4 * locals->ReturnBWToDCNPerState * 3464 (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024 3465 * locals->ReturnBusWidth * locals->DCFCLKPerState[i] * locals->UrgentLatency / 3466 dml_pow((locals->ReturnBWToDCNPerState * locals->UrgentLatency 3467 + (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024), 2)); 3468 } 3469 3470 locals->ReturnBWToDCNPerState = dml_min(locals->ReturnBusWidth * 3471 locals->DCFCLKPerState[i], locals->FabricAndDRAMBandwidthPerState[i] * 1000); 3472 3473 if (locals->DCCEnabledInAnyPlane == true && locals->ReturnBWToDCNPerState > locals->DCFCLKPerState[i] * locals->ReturnBusWidth / 4) { 3474 locals->ReturnBWPerState[i] = dml_min(locals->ReturnBWPerState[i], 3475 locals->ReturnBWToDCNPerState * 4 * (1 - locals->UrgentLatency / 3476 ((locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024 3477 / (locals->ReturnBWToDCNPerState - locals->DCFCLKPerState[i] 3478 * locals->ReturnBusWidth / 4) + locals->UrgentLatency))); 3479 } 3480 locals->CriticalPoint = 2 * locals->ReturnBusWidth * locals->DCFCLKPerState[i] * 3481 locals->UrgentLatency / (locals->ReturnBWToDCNPerState * locals->UrgentLatency 3482 + (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024); 3483 3484 if (locals->DCCEnabledInAnyPlane && locals->CriticalPoint > 1 && locals->CriticalPoint < 4) { 3485 locals->ReturnBWPerState[i] = dml_min(locals->ReturnBWPerState[i], 3486 4 * locals->ReturnBWToDCNPerState * 3487 (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024 3488 * locals->ReturnBusWidth * locals->DCFCLKPerState[i] * locals->UrgentLatency / 3489 dml_pow((locals->ReturnBWToDCNPerState * locals->UrgentLatency 3490 + (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024), 2)); 3491 } 3492 } 3493 /*Writeback Latency support check*/ 3494 3495 mode_lib->vba.WritebackLatencySupport = true; 3496 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 3497 if (mode_lib->vba.WritebackEnable[k] == true) { 3498 if (mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) { 3499 if (locals->WriteBandwidth[k] 3500 > (mode_lib->vba.WritebackInterfaceLumaBufferSize 3501 + mode_lib->vba.WritebackInterfaceChromaBufferSize) 3502 / mode_lib->vba.WritebackLatency) { 3503 mode_lib->vba.WritebackLatencySupport = false; 3504 } 3505 } else { 3506 if (locals->WriteBandwidth[k] 3507 > 1.5 3508 * dml_min( 3509 mode_lib->vba.WritebackInterfaceLumaBufferSize, 3510 2.0 3511 * mode_lib->vba.WritebackInterfaceChromaBufferSize) 3512 / mode_lib->vba.WritebackLatency) { 3513 mode_lib->vba.WritebackLatencySupport = false; 3514 } 3515 } 3516 } 3517 } 3518 /*Re-ordering Buffer Support Check*/ 3519 3520 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) { 3521 locals->UrgentRoundTripAndOutOfOrderLatencyPerState[i] = 3522 (mode_lib->vba.RoundTripPingLatencyCycles + 32.0) / mode_lib->vba.DCFCLKPerState[i] 3523 + locals->UrgentOutOfOrderReturnPerChannel * mode_lib->vba.NumberOfChannels / locals->ReturnBWPerState[i]; 3524 if ((mode_lib->vba.ROBBufferSizeInKByte - mode_lib->vba.PixelChunkSizeInKByte) * 1024.0 / locals->ReturnBWPerState[i] 3525 > locals->UrgentRoundTripAndOutOfOrderLatencyPerState[i]) { 3526 locals->ROBSupport[i] = true; 3527 } else { 3528 locals->ROBSupport[i] = false; 3529 } 3530 } 3531 /*Writeback Mode Support Check*/ 3532 3533 mode_lib->vba.TotalNumberOfActiveWriteback = 0; 3534 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 3535 if (mode_lib->vba.WritebackEnable[k] == true) { 3536 if (mode_lib->vba.ActiveWritebacksPerPlane[k] == 0) 3537 mode_lib->vba.ActiveWritebacksPerPlane[k] = 1; 3538 mode_lib->vba.TotalNumberOfActiveWriteback = 3539 mode_lib->vba.TotalNumberOfActiveWriteback 3540 + mode_lib->vba.ActiveWritebacksPerPlane[k]; 3541 } 3542 } 3543 mode_lib->vba.WritebackModeSupport = true; 3544 if (mode_lib->vba.TotalNumberOfActiveWriteback > mode_lib->vba.MaxNumWriteback) { 3545 mode_lib->vba.WritebackModeSupport = false; 3546 } 3547 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 3548 if (mode_lib->vba.WritebackEnable[k] == true 3549 && mode_lib->vba.Writeback10bpc420Supported != true 3550 && mode_lib->vba.WritebackPixelFormat[k] == dm_420_10) { 3551 mode_lib->vba.WritebackModeSupport = false; 3552 } 3553 } 3554 /*Writeback Scale Ratio and Taps Support Check*/ 3555 3556 mode_lib->vba.WritebackScaleRatioAndTapsSupport = true; 3557 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 3558 if (mode_lib->vba.WritebackEnable[k] == true) { 3559 if (mode_lib->vba.WritebackLumaAndChromaScalingSupported == false 3560 && (mode_lib->vba.WritebackHRatio[k] != 1.0 3561 || mode_lib->vba.WritebackVRatio[k] != 1.0)) { 3562 mode_lib->vba.WritebackScaleRatioAndTapsSupport = false; 3563 } 3564 if (mode_lib->vba.WritebackHRatio[k] > mode_lib->vba.WritebackMaxHSCLRatio 3565 || mode_lib->vba.WritebackVRatio[k] 3566 > mode_lib->vba.WritebackMaxVSCLRatio 3567 || mode_lib->vba.WritebackHRatio[k] 3568 < mode_lib->vba.WritebackMinHSCLRatio 3569 || mode_lib->vba.WritebackVRatio[k] 3570 < mode_lib->vba.WritebackMinVSCLRatio 3571 || mode_lib->vba.WritebackLumaHTaps[k] 3572 > mode_lib->vba.WritebackMaxHSCLTaps 3573 || mode_lib->vba.WritebackLumaVTaps[k] 3574 > mode_lib->vba.WritebackMaxVSCLTaps 3575 || mode_lib->vba.WritebackHRatio[k] 3576 > mode_lib->vba.WritebackLumaHTaps[k] 3577 || mode_lib->vba.WritebackVRatio[k] 3578 > mode_lib->vba.WritebackLumaVTaps[k] 3579 || (mode_lib->vba.WritebackLumaHTaps[k] > 2.0 3580 && ((mode_lib->vba.WritebackLumaHTaps[k] % 2) 3581 == 1)) 3582 || (mode_lib->vba.WritebackPixelFormat[k] != dm_444_32 3583 && (mode_lib->vba.WritebackChromaHTaps[k] 3584 > mode_lib->vba.WritebackMaxHSCLTaps 3585 || mode_lib->vba.WritebackChromaVTaps[k] 3586 > mode_lib->vba.WritebackMaxVSCLTaps 3587 || 2.0 3588 * mode_lib->vba.WritebackHRatio[k] 3589 > mode_lib->vba.WritebackChromaHTaps[k] 3590 || 2.0 3591 * mode_lib->vba.WritebackVRatio[k] 3592 > mode_lib->vba.WritebackChromaVTaps[k] 3593 || (mode_lib->vba.WritebackChromaHTaps[k] > 2.0 3594 && ((mode_lib->vba.WritebackChromaHTaps[k] % 2) == 1))))) { 3595 mode_lib->vba.WritebackScaleRatioAndTapsSupport = false; 3596 } 3597 if (mode_lib->vba.WritebackVRatio[k] < 1.0) { 3598 mode_lib->vba.WritebackLumaVExtra = 3599 dml_max(1.0 - 2.0 / dml_ceil(1.0 / mode_lib->vba.WritebackVRatio[k], 1.0), 0.0); 3600 } else { 3601 mode_lib->vba.WritebackLumaVExtra = -1; 3602 } 3603 if ((mode_lib->vba.WritebackPixelFormat[k] == dm_444_32 3604 && mode_lib->vba.WritebackLumaVTaps[k] 3605 > (mode_lib->vba.WritebackLineBufferLumaBufferSize 3606 + mode_lib->vba.WritebackLineBufferChromaBufferSize) 3607 / 3.0 3608 / mode_lib->vba.WritebackDestinationWidth[k] 3609 - mode_lib->vba.WritebackLumaVExtra) 3610 || (mode_lib->vba.WritebackPixelFormat[k] == dm_420_8 3611 && mode_lib->vba.WritebackLumaVTaps[k] 3612 > mode_lib->vba.WritebackLineBufferLumaBufferSize 3613 * 8.0 / 10.0 / mode_lib->vba.WritebackDestinationWidth[k] 3614 - mode_lib->vba.WritebackLumaVExtra) 3615 || (mode_lib->vba.WritebackPixelFormat[k] == dm_420_10 3616 && mode_lib->vba.WritebackLumaVTaps[k] 3617 > mode_lib->vba.WritebackLineBufferLumaBufferSize 3618 * 8.0 / 10.0 3619 / mode_lib->vba.WritebackDestinationWidth[k] 3620 - mode_lib->vba.WritebackLumaVExtra)) { 3621 mode_lib->vba.WritebackScaleRatioAndTapsSupport = false; 3622 } 3623 if (2.0 * mode_lib->vba.WritebackVRatio[k] < 1) { 3624 mode_lib->vba.WritebackChromaVExtra = 0.0; 3625 } else { 3626 mode_lib->vba.WritebackChromaVExtra = -1; 3627 } 3628 if ((mode_lib->vba.WritebackPixelFormat[k] == dm_420_8 3629 && mode_lib->vba.WritebackChromaVTaps[k] 3630 > mode_lib->vba.WritebackLineBufferChromaBufferSize 3631 * 8.0 / 10.0 / mode_lib->vba.WritebackDestinationWidth[k] 3632 - mode_lib->vba.WritebackChromaVExtra) 3633 || (mode_lib->vba.WritebackPixelFormat[k] == dm_420_10 3634 && mode_lib->vba.WritebackChromaVTaps[k] 3635 > mode_lib->vba.WritebackLineBufferChromaBufferSize 3636 * 8.0 / 10.0 3637 / mode_lib->vba.WritebackDestinationWidth[k] 3638 - mode_lib->vba.WritebackChromaVExtra)) { 3639 mode_lib->vba.WritebackScaleRatioAndTapsSupport = false; 3640 } 3641 } 3642 } 3643 /*Maximum DISPCLK/DPPCLK Support check*/ 3644 3645 mode_lib->vba.WritebackRequiredDISPCLK = 0.0; 3646 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 3647 if (mode_lib->vba.WritebackEnable[k] == true) { 3648 mode_lib->vba.WritebackRequiredDISPCLK = 3649 dml_max( 3650 mode_lib->vba.WritebackRequiredDISPCLK, 3651 CalculateWriteBackDISPCLK( 3652 mode_lib->vba.WritebackPixelFormat[k], 3653 mode_lib->vba.PixelClock[k], 3654 mode_lib->vba.WritebackHRatio[k], 3655 mode_lib->vba.WritebackVRatio[k], 3656 mode_lib->vba.WritebackLumaHTaps[k], 3657 mode_lib->vba.WritebackLumaVTaps[k], 3658 mode_lib->vba.WritebackChromaHTaps[k], 3659 mode_lib->vba.WritebackChromaVTaps[k], 3660 mode_lib->vba.WritebackDestinationWidth[k], 3661 mode_lib->vba.HTotal[k], 3662 mode_lib->vba.WritebackChromaLineBufferWidth)); 3663 } 3664 } 3665 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 3666 if (mode_lib->vba.HRatio[k] > 1.0) { 3667 locals->PSCL_FACTOR[k] = dml_min( 3668 mode_lib->vba.MaxDCHUBToPSCLThroughput, 3669 mode_lib->vba.MaxPSCLToLBThroughput 3670 * mode_lib->vba.HRatio[k] 3671 / dml_ceil( 3672 mode_lib->vba.htaps[k] 3673 / 6.0, 3674 1.0)); 3675 } else { 3676 locals->PSCL_FACTOR[k] = dml_min( 3677 mode_lib->vba.MaxDCHUBToPSCLThroughput, 3678 mode_lib->vba.MaxPSCLToLBThroughput); 3679 } 3680 if (locals->BytePerPixelInDETC[k] == 0.0) { 3681 locals->PSCL_FACTOR_CHROMA[k] = 0.0; 3682 locals->MinDPPCLKUsingSingleDPP[k] = 3683 mode_lib->vba.PixelClock[k] 3684 * dml_max3( 3685 mode_lib->vba.vtaps[k] / 6.0 3686 * dml_min( 3687 1.0, 3688 mode_lib->vba.HRatio[k]), 3689 mode_lib->vba.HRatio[k] 3690 * mode_lib->vba.VRatio[k] 3691 / locals->PSCL_FACTOR[k], 3692 1.0); 3693 if ((mode_lib->vba.htaps[k] > 6.0 || mode_lib->vba.vtaps[k] > 6.0) 3694 && locals->MinDPPCLKUsingSingleDPP[k] 3695 < 2.0 * mode_lib->vba.PixelClock[k]) { 3696 locals->MinDPPCLKUsingSingleDPP[k] = 2.0 3697 * mode_lib->vba.PixelClock[k]; 3698 } 3699 } else { 3700 if (mode_lib->vba.HRatio[k] / 2.0 > 1.0) { 3701 locals->PSCL_FACTOR_CHROMA[k] = 3702 dml_min( 3703 mode_lib->vba.MaxDCHUBToPSCLThroughput, 3704 mode_lib->vba.MaxPSCLToLBThroughput 3705 * mode_lib->vba.HRatio[k] 3706 / 2.0 3707 / dml_ceil( 3708 mode_lib->vba.HTAPsChroma[k] 3709 / 6.0, 3710 1.0)); 3711 } else { 3712 locals->PSCL_FACTOR_CHROMA[k] = dml_min( 3713 mode_lib->vba.MaxDCHUBToPSCLThroughput, 3714 mode_lib->vba.MaxPSCLToLBThroughput); 3715 } 3716 locals->MinDPPCLKUsingSingleDPP[k] = 3717 mode_lib->vba.PixelClock[k] 3718 * dml_max5( 3719 mode_lib->vba.vtaps[k] / 6.0 3720 * dml_min( 3721 1.0, 3722 mode_lib->vba.HRatio[k]), 3723 mode_lib->vba.HRatio[k] 3724 * mode_lib->vba.VRatio[k] 3725 / locals->PSCL_FACTOR[k], 3726 mode_lib->vba.VTAPsChroma[k] 3727 / 6.0 3728 * dml_min( 3729 1.0, 3730 mode_lib->vba.HRatio[k] 3731 / 2.0), 3732 mode_lib->vba.HRatio[k] 3733 * mode_lib->vba.VRatio[k] 3734 / 4.0 3735 / locals->PSCL_FACTOR_CHROMA[k], 3736 1.0); 3737 if ((mode_lib->vba.htaps[k] > 6.0 || mode_lib->vba.vtaps[k] > 6.0 3738 || mode_lib->vba.HTAPsChroma[k] > 6.0 3739 || mode_lib->vba.VTAPsChroma[k] > 6.0) 3740 && locals->MinDPPCLKUsingSingleDPP[k] 3741 < 2.0 * mode_lib->vba.PixelClock[k]) { 3742 locals->MinDPPCLKUsingSingleDPP[k] = 2.0 3743 * mode_lib->vba.PixelClock[k]; 3744 } 3745 } 3746 } 3747 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 3748 Calculate256BBlockSizes( 3749 mode_lib->vba.SourcePixelFormat[k], 3750 mode_lib->vba.SurfaceTiling[k], 3751 dml_ceil(locals->BytePerPixelInDETY[k], 1.0), 3752 dml_ceil(locals->BytePerPixelInDETC[k], 2.0), 3753 &locals->Read256BlockHeightY[k], 3754 &locals->Read256BlockHeightC[k], 3755 &locals->Read256BlockWidthY[k], 3756 &locals->Read256BlockWidthC[k]); 3757 if (mode_lib->vba.SourceScan[k] == dm_horz) { 3758 locals->MaxSwathHeightY[k] = locals->Read256BlockHeightY[k]; 3759 locals->MaxSwathHeightC[k] = locals->Read256BlockHeightC[k]; 3760 } else { 3761 locals->MaxSwathHeightY[k] = locals->Read256BlockWidthY[k]; 3762 locals->MaxSwathHeightC[k] = locals->Read256BlockWidthC[k]; 3763 } 3764 if ((mode_lib->vba.SourcePixelFormat[k] == dm_444_64 3765 || mode_lib->vba.SourcePixelFormat[k] == dm_444_32 3766 || mode_lib->vba.SourcePixelFormat[k] == dm_444_16 3767 || mode_lib->vba.SourcePixelFormat[k] == dm_mono_16 3768 || mode_lib->vba.SourcePixelFormat[k] == dm_mono_8)) { 3769 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear 3770 || (mode_lib->vba.SourcePixelFormat[k] == dm_444_64 3771 && (mode_lib->vba.SurfaceTiling[k] 3772 == dm_sw_4kb_s 3773 || mode_lib->vba.SurfaceTiling[k] 3774 == dm_sw_4kb_s_x 3775 || mode_lib->vba.SurfaceTiling[k] 3776 == dm_sw_64kb_s 3777 || mode_lib->vba.SurfaceTiling[k] 3778 == dm_sw_64kb_s_t 3779 || mode_lib->vba.SurfaceTiling[k] 3780 == dm_sw_64kb_s_x 3781 || mode_lib->vba.SurfaceTiling[k] 3782 == dm_sw_var_s 3783 || mode_lib->vba.SurfaceTiling[k] 3784 == dm_sw_var_s_x) 3785 && mode_lib->vba.SourceScan[k] == dm_horz)) { 3786 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k]; 3787 } else { 3788 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k] 3789 / 2.0; 3790 } 3791 locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k]; 3792 } else { 3793 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) { 3794 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k]; 3795 locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k]; 3796 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8 3797 && mode_lib->vba.SourceScan[k] == dm_horz) { 3798 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k] 3799 / 2.0; 3800 locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k]; 3801 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10 3802 && mode_lib->vba.SourceScan[k] == dm_horz) { 3803 locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k] 3804 / 2.0; 3805 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k]; 3806 } else { 3807 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k]; 3808 locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k]; 3809 } 3810 } 3811 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) { 3812 mode_lib->vba.MaximumSwathWidthSupport = 8192.0; 3813 } else { 3814 mode_lib->vba.MaximumSwathWidthSupport = 5120.0; 3815 } 3816 mode_lib->vba.MaximumSwathWidthInDETBuffer = 3817 dml_min( 3818 mode_lib->vba.MaximumSwathWidthSupport, 3819 mode_lib->vba.DETBufferSizeInKByte * 1024.0 / 2.0 3820 / (locals->BytePerPixelInDETY[k] 3821 * locals->MinSwathHeightY[k] 3822 + locals->BytePerPixelInDETC[k] 3823 / 2.0 3824 * locals->MinSwathHeightC[k])); 3825 if (locals->BytePerPixelInDETC[k] == 0.0) { 3826 mode_lib->vba.MaximumSwathWidthInLineBuffer = 3827 mode_lib->vba.LineBufferSize 3828 * dml_max(mode_lib->vba.HRatio[k], 1.0) 3829 / mode_lib->vba.LBBitPerPixel[k] 3830 / (mode_lib->vba.vtaps[k] 3831 + dml_max( 3832 dml_ceil( 3833 mode_lib->vba.VRatio[k], 3834 1.0) 3835 - 2, 3836 0.0)); 3837 } else { 3838 mode_lib->vba.MaximumSwathWidthInLineBuffer = 3839 dml_min( 3840 mode_lib->vba.LineBufferSize 3841 * dml_max( 3842 mode_lib->vba.HRatio[k], 3843 1.0) 3844 / mode_lib->vba.LBBitPerPixel[k] 3845 / (mode_lib->vba.vtaps[k] 3846 + dml_max( 3847 dml_ceil( 3848 mode_lib->vba.VRatio[k], 3849 1.0) 3850 - 2, 3851 0.0)), 3852 2.0 * mode_lib->vba.LineBufferSize 3853 * dml_max( 3854 mode_lib->vba.HRatio[k] 3855 / 2.0, 3856 1.0) 3857 / mode_lib->vba.LBBitPerPixel[k] 3858 / (mode_lib->vba.VTAPsChroma[k] 3859 + dml_max( 3860 dml_ceil( 3861 mode_lib->vba.VRatio[k] 3862 / 2.0, 3863 1.0) 3864 - 2, 3865 0.0))); 3866 } 3867 locals->MaximumSwathWidth[k] = dml_min( 3868 mode_lib->vba.MaximumSwathWidthInDETBuffer, 3869 mode_lib->vba.MaximumSwathWidthInLineBuffer); 3870 } 3871 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) { 3872 for (j = 0; j < 2; j++) { 3873 mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity = RoundToDFSGranularityDown( 3874 mode_lib->vba.MaxDispclk[i], 3875 mode_lib->vba.DISPCLKDPPCLKVCOSpeed); 3876 mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity = RoundToDFSGranularityDown( 3877 mode_lib->vba.MaxDppclk[i], 3878 mode_lib->vba.DISPCLKDPPCLKVCOSpeed); 3879 locals->RequiredDISPCLK[i][j] = 0.0; 3880 locals->DISPCLK_DPPCLK_Support[i][j] = true; 3881 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 3882 mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine = 3883 mode_lib->vba.PixelClock[k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) 3884 * (1.0 + mode_lib->vba.DISPCLKRampingMargin / 100.0); 3885 if (mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine >= mode_lib->vba.MaxDispclk[i] 3886 && i == mode_lib->vba.soc.num_states) 3887 mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine = mode_lib->vba.PixelClock[k] 3888 * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0); 3889 3890 mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine = mode_lib->vba.PixelClock[k] / 2 3891 * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * (1 + mode_lib->vba.DISPCLKRampingMargin / 100.0); 3892 if (mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine >= mode_lib->vba.MaxDispclk[i] 3893 && i == mode_lib->vba.soc.num_states) 3894 mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine = mode_lib->vba.PixelClock[k] / 2 3895 * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0); 3896 if (mode_lib->vba.ODMCapability == false || mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine <= mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity) { 3897 locals->ODMCombineEnablePerState[i][k] = false; 3898 mode_lib->vba.PlaneRequiredDISPCLK = mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine; 3899 } else { 3900 locals->ODMCombineEnablePerState[i][k] = true; 3901 mode_lib->vba.PlaneRequiredDISPCLK = mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine; 3902 } 3903 if (locals->MinDPPCLKUsingSingleDPP[k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) <= mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity 3904 && locals->SwathWidthYSingleDPP[k] <= locals->MaximumSwathWidth[k] 3905 && locals->ODMCombineEnablePerState[i][k] == false) { 3906 locals->NoOfDPP[i][j][k] = 1; 3907 locals->RequiredDPPCLK[i][j][k] = 3908 locals->MinDPPCLKUsingSingleDPP[k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0); 3909 } else { 3910 locals->NoOfDPP[i][j][k] = 2; 3911 locals->RequiredDPPCLK[i][j][k] = 3912 locals->MinDPPCLKUsingSingleDPP[k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 2.0; 3913 } 3914 locals->RequiredDISPCLK[i][j] = dml_max( 3915 locals->RequiredDISPCLK[i][j], 3916 mode_lib->vba.PlaneRequiredDISPCLK); 3917 if ((locals->MinDPPCLKUsingSingleDPP[k] / locals->NoOfDPP[i][j][k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) 3918 > mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity) 3919 || (mode_lib->vba.PlaneRequiredDISPCLK > mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity)) { 3920 locals->DISPCLK_DPPCLK_Support[i][j] = false; 3921 } 3922 } 3923 locals->TotalNumberOfActiveDPP[i][j] = 0.0; 3924 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) 3925 locals->TotalNumberOfActiveDPP[i][j] = locals->TotalNumberOfActiveDPP[i][j] + locals->NoOfDPP[i][j][k]; 3926 if (j == 1) { 3927 while (locals->TotalNumberOfActiveDPP[i][j] < mode_lib->vba.MaxNumDPP 3928 && locals->TotalNumberOfActiveDPP[i][j] < 2 * mode_lib->vba.NumberOfActivePlanes) { 3929 double BWOfNonSplitPlaneOfMaximumBandwidth; 3930 unsigned int NumberOfNonSplitPlaneOfMaximumBandwidth; 3931 3932 BWOfNonSplitPlaneOfMaximumBandwidth = 0; 3933 NumberOfNonSplitPlaneOfMaximumBandwidth = 0; 3934 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) { 3935 if (locals->ReadBandwidth[k] > BWOfNonSplitPlaneOfMaximumBandwidth && locals->NoOfDPP[i][j][k] == 1) { 3936 BWOfNonSplitPlaneOfMaximumBandwidth = locals->ReadBandwidth[k]; 3937 NumberOfNonSplitPlaneOfMaximumBandwidth = k; 3938 } 3939 } 3940 locals->NoOfDPP[i][j][NumberOfNonSplitPlaneOfMaximumBandwidth] = 2; 3941 locals->RequiredDPPCLK[i][j][NumberOfNonSplitPlaneOfMaximumBandwidth] = 3942 locals->MinDPPCLKUsingSingleDPP[NumberOfNonSplitPlaneOfMaximumBandwidth] 3943 * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100) / 2; 3944 locals->TotalNumberOfActiveDPP[i][j] = locals->TotalNumberOfActiveDPP[i][j] + 1; 3945 } 3946 } 3947 if (locals->TotalNumberOfActiveDPP[i][j] > mode_lib->vba.MaxNumDPP) { 3948 locals->RequiredDISPCLK[i][j] = 0.0; 3949 locals->DISPCLK_DPPCLK_Support[i][j] = true; 3950 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 3951 locals->ODMCombineEnablePerState[i][k] = false; 3952 if (locals->SwathWidthYSingleDPP[k] <= locals->MaximumSwathWidth[k]) { 3953 locals->NoOfDPP[i][j][k] = 1; 3954 locals->RequiredDPPCLK[i][j][k] = locals->MinDPPCLKUsingSingleDPP[k] 3955 * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0); 3956 } else { 3957 locals->NoOfDPP[i][j][k] = 2; 3958 locals->RequiredDPPCLK[i][j][k] = locals->MinDPPCLKUsingSingleDPP[k] 3959 * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 2.0; 3960 } 3961 if (i != mode_lib->vba.soc.num_states) { 3962 mode_lib->vba.PlaneRequiredDISPCLK = 3963 mode_lib->vba.PixelClock[k] 3964 * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) 3965 * (1.0 + mode_lib->vba.DISPCLKRampingMargin / 100.0); 3966 } else { 3967 mode_lib->vba.PlaneRequiredDISPCLK = mode_lib->vba.PixelClock[k] 3968 * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0); 3969 } 3970 locals->RequiredDISPCLK[i][j] = dml_max( 3971 locals->RequiredDISPCLK[i][j], 3972 mode_lib->vba.PlaneRequiredDISPCLK); 3973 if (locals->MinDPPCLKUsingSingleDPP[k] / locals->NoOfDPP[i][j][k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) 3974 > mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity 3975 || mode_lib->vba.PlaneRequiredDISPCLK > mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity) 3976 locals->DISPCLK_DPPCLK_Support[i][j] = false; 3977 } 3978 locals->TotalNumberOfActiveDPP[i][j] = 0.0; 3979 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) 3980 locals->TotalNumberOfActiveDPP[i][j] = locals->TotalNumberOfActiveDPP[i][j] + locals->NoOfDPP[i][j][k]; 3981 } 3982 locals->RequiredDISPCLK[i][j] = dml_max( 3983 locals->RequiredDISPCLK[i][j], 3984 mode_lib->vba.WritebackRequiredDISPCLK); 3985 if (mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity 3986 < mode_lib->vba.WritebackRequiredDISPCLK) { 3987 locals->DISPCLK_DPPCLK_Support[i][j] = false; 3988 } 3989 } 3990 } 3991 /*Viewport Size Check*/ 3992 3993 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) { 3994 locals->ViewportSizeSupport[i] = true; 3995 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 3996 if (locals->ODMCombineEnablePerState[i][k] == true) { 3997 if (dml_min(locals->SwathWidthYSingleDPP[k], dml_round(mode_lib->vba.HActive[k] / 2.0 * mode_lib->vba.HRatio[k])) 3998 > locals->MaximumSwathWidth[k]) { 3999 locals->ViewportSizeSupport[i] = false; 4000 } 4001 } else { 4002 if (locals->SwathWidthYSingleDPP[k] / 2.0 > locals->MaximumSwathWidth[k]) { 4003 locals->ViewportSizeSupport[i] = false; 4004 } 4005 } 4006 } 4007 } 4008 /*Total Available Pipes Support Check*/ 4009 4010 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) { 4011 for (j = 0; j < 2; j++) { 4012 if (locals->TotalNumberOfActiveDPP[i][j] <= mode_lib->vba.MaxNumDPP) 4013 locals->TotalAvailablePipesSupport[i][j] = true; 4014 else 4015 locals->TotalAvailablePipesSupport[i][j] = false; 4016 } 4017 } 4018 /*Total Available OTG Support Check*/ 4019 4020 mode_lib->vba.TotalNumberOfActiveOTG = 0.0; 4021 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4022 if (mode_lib->vba.BlendingAndTiming[k] == k) { 4023 mode_lib->vba.TotalNumberOfActiveOTG = mode_lib->vba.TotalNumberOfActiveOTG 4024 + 1.0; 4025 } 4026 } 4027 if (mode_lib->vba.TotalNumberOfActiveOTG <= mode_lib->vba.MaxNumOTG) { 4028 mode_lib->vba.NumberOfOTGSupport = true; 4029 } else { 4030 mode_lib->vba.NumberOfOTGSupport = false; 4031 } 4032 /*Display IO and DSC Support Check*/ 4033 4034 mode_lib->vba.NonsupportedDSCInputBPC = false; 4035 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4036 if (!(mode_lib->vba.DSCInputBitPerComponent[k] == 12.0 4037 || mode_lib->vba.DSCInputBitPerComponent[k] == 10.0 4038 || mode_lib->vba.DSCInputBitPerComponent[k] == 8.0)) { 4039 mode_lib->vba.NonsupportedDSCInputBPC = true; 4040 } 4041 } 4042 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) { 4043 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4044 locals->RequiresDSC[i][k] = 0; 4045 locals->RequiresFEC[i][k] = 0; 4046 if (mode_lib->vba.BlendingAndTiming[k] == k) { 4047 if (mode_lib->vba.Output[k] == dm_hdmi) { 4048 locals->RequiresDSC[i][k] = 0; 4049 locals->RequiresFEC[i][k] = 0; 4050 locals->OutputBppPerState[i][k] = TruncToValidBPP( 4051 dml_min(600.0, mode_lib->vba.PHYCLKPerState[i]) / mode_lib->vba.PixelClockBackEnd[k] * 24, 4052 false, 4053 mode_lib->vba.Output[k], 4054 mode_lib->vba.OutputFormat[k], 4055 mode_lib->vba.DSCInputBitPerComponent[k]); 4056 } else if (mode_lib->vba.Output[k] == dm_dp 4057 || mode_lib->vba.Output[k] == dm_edp) { 4058 if (mode_lib->vba.Output[k] == dm_edp) { 4059 mode_lib->vba.EffectiveFECOverhead = 0.0; 4060 } else { 4061 mode_lib->vba.EffectiveFECOverhead = 4062 mode_lib->vba.FECOverhead; 4063 } 4064 if (mode_lib->vba.PHYCLKPerState[i] >= 270.0) { 4065 mode_lib->vba.Outbpp = TruncToValidBPP( 4066 (1.0 - mode_lib->vba.Downspreading / 100.0) * 270.0 4067 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0, 4068 false, 4069 mode_lib->vba.Output[k], 4070 mode_lib->vba.OutputFormat[k], 4071 mode_lib->vba.DSCInputBitPerComponent[k]); 4072 mode_lib->vba.OutbppDSC = TruncToValidBPP( 4073 (1.0 - mode_lib->vba.Downspreading / 100.0) * (1.0 - mode_lib->vba.EffectiveFECOverhead / 100.0) * 270.0 4074 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0, 4075 true, 4076 mode_lib->vba.Output[k], 4077 mode_lib->vba.OutputFormat[k], 4078 mode_lib->vba.DSCInputBitPerComponent[k]); 4079 if (mode_lib->vba.DSCEnabled[k] == true) { 4080 locals->RequiresDSC[i][k] = true; 4081 if (mode_lib->vba.Output[k] == dm_dp) { 4082 locals->RequiresFEC[i][k] = true; 4083 } else { 4084 locals->RequiresFEC[i][k] = false; 4085 } 4086 mode_lib->vba.Outbpp = mode_lib->vba.OutbppDSC; 4087 } else { 4088 locals->RequiresDSC[i][k] = false; 4089 locals->RequiresFEC[i][k] = false; 4090 } 4091 locals->OutputBppPerState[i][k] = mode_lib->vba.Outbpp; 4092 } 4093 if (mode_lib->vba.Outbpp == BPP_INVALID && mode_lib->vba.PHYCLKPerState[i] >= 540.0) { 4094 mode_lib->vba.Outbpp = TruncToValidBPP( 4095 (1.0 - mode_lib->vba.Downspreading / 100.0) * 540.0 4096 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0, 4097 false, 4098 mode_lib->vba.Output[k], 4099 mode_lib->vba.OutputFormat[k], 4100 mode_lib->vba.DSCInputBitPerComponent[k]); 4101 mode_lib->vba.OutbppDSC = TruncToValidBPP( 4102 (1.0 - mode_lib->vba.Downspreading / 100.0) * (1.0 - mode_lib->vba.EffectiveFECOverhead / 100.0) * 540.0 4103 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0, 4104 true, 4105 mode_lib->vba.Output[k], 4106 mode_lib->vba.OutputFormat[k], 4107 mode_lib->vba.DSCInputBitPerComponent[k]); 4108 if (mode_lib->vba.DSCEnabled[k] == true) { 4109 locals->RequiresDSC[i][k] = true; 4110 if (mode_lib->vba.Output[k] == dm_dp) { 4111 locals->RequiresFEC[i][k] = true; 4112 } else { 4113 locals->RequiresFEC[i][k] = false; 4114 } 4115 mode_lib->vba.Outbpp = mode_lib->vba.OutbppDSC; 4116 } else { 4117 locals->RequiresDSC[i][k] = false; 4118 locals->RequiresFEC[i][k] = false; 4119 } 4120 locals->OutputBppPerState[i][k] = mode_lib->vba.Outbpp; 4121 } 4122 if (mode_lib->vba.Outbpp == BPP_INVALID 4123 && mode_lib->vba.PHYCLKPerState[i] 4124 >= 810.0) { 4125 mode_lib->vba.Outbpp = TruncToValidBPP( 4126 (1.0 - mode_lib->vba.Downspreading / 100.0) * 810.0 4127 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0, 4128 false, 4129 mode_lib->vba.Output[k], 4130 mode_lib->vba.OutputFormat[k], 4131 mode_lib->vba.DSCInputBitPerComponent[k]); 4132 mode_lib->vba.OutbppDSC = TruncToValidBPP( 4133 (1.0 - mode_lib->vba.Downspreading / 100.0) * (1.0 - mode_lib->vba.EffectiveFECOverhead / 100.0) * 810.0 4134 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0, 4135 true, 4136 mode_lib->vba.Output[k], 4137 mode_lib->vba.OutputFormat[k], 4138 mode_lib->vba.DSCInputBitPerComponent[k]); 4139 if (mode_lib->vba.DSCEnabled[k] == true || mode_lib->vba.Outbpp == BPP_INVALID) { 4140 locals->RequiresDSC[i][k] = true; 4141 if (mode_lib->vba.Output[k] == dm_dp) { 4142 locals->RequiresFEC[i][k] = true; 4143 } else { 4144 locals->RequiresFEC[i][k] = false; 4145 } 4146 mode_lib->vba.Outbpp = mode_lib->vba.OutbppDSC; 4147 } else { 4148 locals->RequiresDSC[i][k] = false; 4149 locals->RequiresFEC[i][k] = false; 4150 } 4151 locals->OutputBppPerState[i][k] = 4152 mode_lib->vba.Outbpp; 4153 } 4154 } 4155 } else { 4156 locals->OutputBppPerState[i][k] = BPP_BLENDED_PIPE; 4157 } 4158 } 4159 } 4160 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) { 4161 locals->DIOSupport[i] = true; 4162 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4163 if (locals->OutputBppPerState[i][k] == BPP_INVALID 4164 || (mode_lib->vba.OutputFormat[k] == dm_420 4165 && mode_lib->vba.Interlace[k] == true 4166 && mode_lib->vba.ProgressiveToInterlaceUnitInOPP == true)) { 4167 locals->DIOSupport[i] = false; 4168 } 4169 } 4170 } 4171 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) { 4172 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4173 locals->DSCCLKRequiredMoreThanSupported[i] = false; 4174 if (mode_lib->vba.BlendingAndTiming[k] == k) { 4175 if ((mode_lib->vba.Output[k] == dm_dp 4176 || mode_lib->vba.Output[k] == dm_edp)) { 4177 if (mode_lib->vba.OutputFormat[k] == dm_420 4178 || mode_lib->vba.OutputFormat[k] 4179 == dm_n422) { 4180 mode_lib->vba.DSCFormatFactor = 2; 4181 } else { 4182 mode_lib->vba.DSCFormatFactor = 1; 4183 } 4184 if (locals->RequiresDSC[i][k] == true) { 4185 if (locals->ODMCombineEnablePerState[i][k] 4186 == true) { 4187 if (mode_lib->vba.PixelClockBackEnd[k] / 6.0 / mode_lib->vba.DSCFormatFactor 4188 > (1.0 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * mode_lib->vba.MaxDSCCLK[i]) { 4189 locals->DSCCLKRequiredMoreThanSupported[i] = 4190 true; 4191 } 4192 } else { 4193 if (mode_lib->vba.PixelClockBackEnd[k] / 3.0 / mode_lib->vba.DSCFormatFactor 4194 > (1.0 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * mode_lib->vba.MaxDSCCLK[i]) { 4195 locals->DSCCLKRequiredMoreThanSupported[i] = 4196 true; 4197 } 4198 } 4199 } 4200 } 4201 } 4202 } 4203 } 4204 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) { 4205 locals->NotEnoughDSCUnits[i] = false; 4206 mode_lib->vba.TotalDSCUnitsRequired = 0.0; 4207 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4208 if (locals->RequiresDSC[i][k] == true) { 4209 if (locals->ODMCombineEnablePerState[i][k] == true) { 4210 mode_lib->vba.TotalDSCUnitsRequired = 4211 mode_lib->vba.TotalDSCUnitsRequired + 2.0; 4212 } else { 4213 mode_lib->vba.TotalDSCUnitsRequired = 4214 mode_lib->vba.TotalDSCUnitsRequired + 1.0; 4215 } 4216 } 4217 } 4218 if (mode_lib->vba.TotalDSCUnitsRequired > mode_lib->vba.NumberOfDSC) { 4219 locals->NotEnoughDSCUnits[i] = true; 4220 } 4221 } 4222 /*DSC Delay per state*/ 4223 4224 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) { 4225 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4226 if (mode_lib->vba.BlendingAndTiming[k] != k) { 4227 mode_lib->vba.slices = 0; 4228 } else if (locals->RequiresDSC[i][k] == 0 4229 || locals->RequiresDSC[i][k] == false) { 4230 mode_lib->vba.slices = 0; 4231 } else if (mode_lib->vba.PixelClockBackEnd[k] > 3200.0) { 4232 mode_lib->vba.slices = dml_ceil( 4233 mode_lib->vba.PixelClockBackEnd[k] / 400.0, 4234 4.0); 4235 } else if (mode_lib->vba.PixelClockBackEnd[k] > 1360.0) { 4236 mode_lib->vba.slices = 8.0; 4237 } else if (mode_lib->vba.PixelClockBackEnd[k] > 680.0) { 4238 mode_lib->vba.slices = 4.0; 4239 } else if (mode_lib->vba.PixelClockBackEnd[k] > 340.0) { 4240 mode_lib->vba.slices = 2.0; 4241 } else { 4242 mode_lib->vba.slices = 1.0; 4243 } 4244 if (locals->OutputBppPerState[i][k] == BPP_BLENDED_PIPE 4245 || locals->OutputBppPerState[i][k] == BPP_INVALID) { 4246 mode_lib->vba.bpp = 0.0; 4247 } else { 4248 mode_lib->vba.bpp = locals->OutputBppPerState[i][k]; 4249 } 4250 if (locals->RequiresDSC[i][k] == true && mode_lib->vba.bpp != 0.0) { 4251 if (locals->ODMCombineEnablePerState[i][k] == false) { 4252 locals->DSCDelayPerState[i][k] = 4253 dscceComputeDelay( 4254 mode_lib->vba.DSCInputBitPerComponent[k], 4255 mode_lib->vba.bpp, 4256 dml_ceil( 4257 mode_lib->vba.HActive[k] 4258 / mode_lib->vba.slices, 4259 1.0), 4260 mode_lib->vba.slices, 4261 mode_lib->vba.OutputFormat[k]) 4262 + dscComputeDelay( 4263 mode_lib->vba.OutputFormat[k]); 4264 } else { 4265 locals->DSCDelayPerState[i][k] = 4266 2.0 * (dscceComputeDelay( 4267 mode_lib->vba.DSCInputBitPerComponent[k], 4268 mode_lib->vba.bpp, 4269 dml_ceil(mode_lib->vba.HActive[k] / mode_lib->vba.slices, 1.0), 4270 mode_lib->vba.slices / 2, 4271 mode_lib->vba.OutputFormat[k]) 4272 + dscComputeDelay(mode_lib->vba.OutputFormat[k])); 4273 } 4274 locals->DSCDelayPerState[i][k] = 4275 locals->DSCDelayPerState[i][k] * mode_lib->vba.PixelClock[k] / mode_lib->vba.PixelClockBackEnd[k]; 4276 } else { 4277 locals->DSCDelayPerState[i][k] = 0.0; 4278 } 4279 } 4280 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4281 for (m = 0; m <= mode_lib->vba.NumberOfActivePlanes - 1; m++) { 4282 for (j = 0; j <= mode_lib->vba.NumberOfActivePlanes - 1; j++) { 4283 if (mode_lib->vba.BlendingAndTiming[k] == m && locals->RequiresDSC[i][m] == true) 4284 locals->DSCDelayPerState[i][k] = locals->DSCDelayPerState[i][m]; 4285 } 4286 } 4287 } 4288 } 4289 4290 //Prefetch Check 4291 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) { 4292 for (j = 0; j < 2; j++) { 4293 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4294 if (locals->ODMCombineEnablePerState[i][k] == true) 4295 locals->SwathWidthYPerState[i][j][k] = dml_min(locals->SwathWidthYSingleDPP[k], dml_round(locals->HActive[k] / 2 * locals->HRatio[k])); 4296 else 4297 locals->SwathWidthYPerState[i][j][k] = locals->SwathWidthYSingleDPP[k] / locals->NoOfDPP[i][j][k]; 4298 locals->SwathWidthGranularityY = 256 / dml_ceil(locals->BytePerPixelInDETY[k], 1) / locals->MaxSwathHeightY[k]; 4299 locals->RoundedUpMaxSwathSizeBytesY = (dml_ceil(locals->SwathWidthYPerState[i][j][k] - 1, locals->SwathWidthGranularityY) 4300 + locals->SwathWidthGranularityY) * locals->BytePerPixelInDETY[k] * locals->MaxSwathHeightY[k]; 4301 if (locals->SourcePixelFormat[k] == dm_420_10) { 4302 locals->RoundedUpMaxSwathSizeBytesY = dml_ceil(locals->RoundedUpMaxSwathSizeBytesY, 256) + 256; 4303 } 4304 if (locals->MaxSwathHeightC[k] > 0) { 4305 locals->SwathWidthGranularityC = 256 / dml_ceil(locals->BytePerPixelInDETC[k], 2) / locals->MaxSwathHeightC[k]; 4306 4307 locals->RoundedUpMaxSwathSizeBytesC = (dml_ceil(locals->SwathWidthYPerState[i][j][k] / 2 - 1, locals->SwathWidthGranularityC) 4308 + locals->SwathWidthGranularityC) * locals->BytePerPixelInDETC[k] * locals->MaxSwathHeightC[k]; 4309 } 4310 if (locals->SourcePixelFormat[k] == dm_420_10) { 4311 locals->RoundedUpMaxSwathSizeBytesC = dml_ceil(locals->RoundedUpMaxSwathSizeBytesC, 256) + 256; 4312 } else { 4313 locals->RoundedUpMaxSwathSizeBytesC = 0; 4314 } 4315 4316 if (locals->RoundedUpMaxSwathSizeBytesY + locals->RoundedUpMaxSwathSizeBytesC <= locals->DETBufferSizeInKByte * 1024 / 2) { 4317 locals->SwathHeightYPerState[i][j][k] = locals->MaxSwathHeightY[k]; 4318 locals->SwathHeightCPerState[i][j][k] = locals->MaxSwathHeightC[k]; 4319 } else { 4320 locals->SwathHeightYPerState[i][j][k] = locals->MinSwathHeightY[k]; 4321 locals->SwathHeightCPerState[i][j][k] = locals->MinSwathHeightC[k]; 4322 } 4323 4324 if (locals->BytePerPixelInDETC[k] == 0) { 4325 locals->LinesInDETLuma = locals->DETBufferSizeInKByte * 1024 / locals->BytePerPixelInDETY[k] / locals->SwathWidthYPerState[i][j][k]; 4326 locals->LinesInDETChroma = 0; 4327 } else if (locals->SwathHeightYPerState[i][j][k] <= locals->SwathHeightCPerState[i][j][k]) { 4328 locals->LinesInDETLuma = locals->DETBufferSizeInKByte * 1024 / 2 / locals->BytePerPixelInDETY[k] / 4329 locals->SwathWidthYPerState[i][j][k]; 4330 locals->LinesInDETChroma = locals->DETBufferSizeInKByte * 1024 / 2 / locals->BytePerPixelInDETC[k] / (locals->SwathWidthYPerState[i][j][k] / 2); 4331 } else { 4332 locals->LinesInDETLuma = locals->DETBufferSizeInKByte * 1024 * 2 / 3 / locals->BytePerPixelInDETY[k] / locals->SwathWidthYPerState[i][j][k]; 4333 locals->LinesInDETChroma = locals->DETBufferSizeInKByte * 1024 / 3 / locals->BytePerPixelInDETY[k] / (locals->SwathWidthYPerState[i][j][k] / 2); 4334 } 4335 4336 locals->EffectiveLBLatencyHidingSourceLinesLuma = dml_min(locals->MaxLineBufferLines, 4337 dml_floor(locals->LineBufferSize / locals->LBBitPerPixel[k] / (locals->SwathWidthYPerState[i][j][k] 4338 / dml_max(locals->HRatio[k], 1)), 1)) - (locals->vtaps[k] - 1); 4339 4340 locals->EffectiveLBLatencyHidingSourceLinesChroma = dml_min(locals->MaxLineBufferLines, 4341 dml_floor(locals->LineBufferSize / locals->LBBitPerPixel[k] 4342 / (locals->SwathWidthYPerState[i][j][k] / 2 4343 / dml_max(locals->HRatio[k] / 2, 1)), 1)) - (locals->VTAPsChroma[k] - 1); 4344 4345 locals->EffectiveDETLBLinesLuma = dml_floor(locals->LinesInDETLuma + dml_min( 4346 locals->LinesInDETLuma * locals->RequiredDISPCLK[i][j] * locals->BytePerPixelInDETY[k] * 4347 locals->PSCL_FACTOR[k] / locals->ReturnBWPerState[i], 4348 locals->EffectiveLBLatencyHidingSourceLinesLuma), 4349 locals->SwathHeightYPerState[i][j][k]); 4350 4351 locals->EffectiveDETLBLinesChroma = dml_floor(locals->LinesInDETChroma + dml_min( 4352 locals->LinesInDETChroma * locals->RequiredDISPCLK[i][j] * locals->BytePerPixelInDETC[k] * 4353 locals->PSCL_FACTOR_CHROMA[k] / locals->ReturnBWPerState[i], 4354 locals->EffectiveLBLatencyHidingSourceLinesChroma), 4355 locals->SwathHeightCPerState[i][j][k]); 4356 4357 if (locals->BytePerPixelInDETC[k] == 0) { 4358 locals->UrgentLatencySupportUsPerState[i][j][k] = locals->EffectiveDETLBLinesLuma * (locals->HTotal[k] / locals->PixelClock[k]) 4359 / locals->VRatio[k] - locals->EffectiveDETLBLinesLuma * locals->SwathWidthYPerState[i][j][k] * 4360 dml_ceil(locals->BytePerPixelInDETY[k], 1) / (locals->ReturnBWPerState[i] / locals->NoOfDPP[i][j][k]); 4361 } else { 4362 locals->UrgentLatencySupportUsPerState[i][j][k] = dml_min( 4363 locals->EffectiveDETLBLinesLuma * (locals->HTotal[k] / locals->PixelClock[k]) 4364 / locals->VRatio[k] - locals->EffectiveDETLBLinesLuma * locals->SwathWidthYPerState[i][j][k] * 4365 dml_ceil(locals->BytePerPixelInDETY[k], 1) / (locals->ReturnBWPerState[i] / locals->NoOfDPP[i][j][k]), 4366 locals->EffectiveDETLBLinesChroma * (locals->HTotal[k] / locals->PixelClock[k]) / (locals->VRatio[k] / 2) - 4367 locals->EffectiveDETLBLinesChroma * locals->SwathWidthYPerState[i][j][k] / 2 * 4368 dml_ceil(locals->BytePerPixelInDETC[k], 2) / (locals->ReturnBWPerState[i] / locals->NoOfDPP[i][j][k])); 4369 } 4370 } 4371 } 4372 } 4373 4374 for (i = 0; i <= locals->soc.num_states; i++) { 4375 for (j = 0; j < 2; j++) { 4376 locals->UrgentLatencySupport[i][j] = true; 4377 for (k = 0; k < locals->NumberOfActivePlanes; k++) { 4378 if (locals->UrgentLatencySupportUsPerState[i][j][k] < locals->UrgentLatency) 4379 locals->UrgentLatencySupport[i][j] = false; 4380 } 4381 } 4382 } 4383 4384 4385 /*Prefetch Check*/ 4386 for (i = 0; i <= locals->soc.num_states; i++) { 4387 for (j = 0; j < 2; j++) { 4388 locals->TotalNumberOfDCCActiveDPP[i][j] = 0; 4389 for (k = 0; k < locals->NumberOfActivePlanes; k++) { 4390 if (locals->DCCEnable[k] == true) { 4391 locals->TotalNumberOfDCCActiveDPP[i][j] = 4392 locals->TotalNumberOfDCCActiveDPP[i][j] + locals->NoOfDPP[i][j][k]; 4393 } 4394 } 4395 } 4396 } 4397 4398 CalculateMinAndMaxPrefetchMode(locals->AllowDRAMSelfRefreshOrDRAMClockChangeInVblank, &locals->MinPrefetchMode, &locals->MaxPrefetchMode); 4399 4400 for (i = 0; i <= locals->soc.num_states; i++) { 4401 for (j = 0; j < 2; j++) { 4402 for (k = 0; k < locals->NumberOfActivePlanes; k++) { 4403 locals->NoOfDPPThisState[k] = locals->NoOfDPP[i][j][k]; 4404 locals->RequiredDPPCLKThisState[k] = locals->RequiredDPPCLK[i][j][k]; 4405 locals->SwathHeightYThisState[k] = locals->SwathHeightYPerState[i][j][k]; 4406 locals->SwathHeightCThisState[k] = locals->SwathHeightCPerState[i][j][k]; 4407 locals->SwathWidthYThisState[k] = locals->SwathWidthYPerState[i][j][k]; 4408 mode_lib->vba.ProjectedDCFCLKDeepSleep = dml_max( 4409 mode_lib->vba.ProjectedDCFCLKDeepSleep, 4410 mode_lib->vba.PixelClock[k] / 16.0); 4411 if (mode_lib->vba.BytePerPixelInDETC[k] == 0.0) { 4412 if (mode_lib->vba.VRatio[k] <= 1.0) { 4413 mode_lib->vba.ProjectedDCFCLKDeepSleep = 4414 dml_max( 4415 mode_lib->vba.ProjectedDCFCLKDeepSleep, 4416 1.1 4417 * dml_ceil( 4418 mode_lib->vba.BytePerPixelInDETY[k], 4419 1.0) 4420 / 64.0 4421 * mode_lib->vba.HRatio[k] 4422 * mode_lib->vba.PixelClock[k] 4423 / mode_lib->vba.NoOfDPP[i][j][k]); 4424 } else { 4425 mode_lib->vba.ProjectedDCFCLKDeepSleep = 4426 dml_max( 4427 mode_lib->vba.ProjectedDCFCLKDeepSleep, 4428 1.1 4429 * dml_ceil( 4430 mode_lib->vba.BytePerPixelInDETY[k], 4431 1.0) 4432 / 64.0 4433 * mode_lib->vba.PSCL_FACTOR[k] 4434 * mode_lib->vba.RequiredDPPCLK[i][j][k]); 4435 } 4436 } else { 4437 if (mode_lib->vba.VRatio[k] <= 1.0) { 4438 mode_lib->vba.ProjectedDCFCLKDeepSleep = 4439 dml_max( 4440 mode_lib->vba.ProjectedDCFCLKDeepSleep, 4441 1.1 4442 * dml_ceil( 4443 mode_lib->vba.BytePerPixelInDETY[k], 4444 1.0) 4445 / 32.0 4446 * mode_lib->vba.HRatio[k] 4447 * mode_lib->vba.PixelClock[k] 4448 / mode_lib->vba.NoOfDPP[i][j][k]); 4449 } else { 4450 mode_lib->vba.ProjectedDCFCLKDeepSleep = 4451 dml_max( 4452 mode_lib->vba.ProjectedDCFCLKDeepSleep, 4453 1.1 4454 * dml_ceil( 4455 mode_lib->vba.BytePerPixelInDETY[k], 4456 1.0) 4457 / 32.0 4458 * mode_lib->vba.PSCL_FACTOR[k] 4459 * mode_lib->vba.RequiredDPPCLK[i][j][k]); 4460 } 4461 if (mode_lib->vba.VRatio[k] / 2.0 <= 1.0) { 4462 mode_lib->vba.ProjectedDCFCLKDeepSleep = 4463 dml_max( 4464 mode_lib->vba.ProjectedDCFCLKDeepSleep, 4465 1.1 4466 * dml_ceil( 4467 mode_lib->vba.BytePerPixelInDETC[k], 4468 2.0) 4469 / 32.0 4470 * mode_lib->vba.HRatio[k] 4471 / 2.0 4472 * mode_lib->vba.PixelClock[k] 4473 / mode_lib->vba.NoOfDPP[i][j][k]); 4474 } else { 4475 mode_lib->vba.ProjectedDCFCLKDeepSleep = 4476 dml_max( 4477 mode_lib->vba.ProjectedDCFCLKDeepSleep, 4478 1.1 4479 * dml_ceil( 4480 mode_lib->vba.BytePerPixelInDETC[k], 4481 2.0) 4482 / 32.0 4483 * mode_lib->vba.PSCL_FACTOR_CHROMA[k] 4484 * mode_lib->vba.RequiredDPPCLK[i][j][k]); 4485 } 4486 } 4487 } 4488 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4489 mode_lib->vba.PDEAndMetaPTEBytesPerFrameY = CalculateVMAndRowBytes( 4490 mode_lib, 4491 mode_lib->vba.DCCEnable[k], 4492 mode_lib->vba.Read256BlockHeightY[k], 4493 mode_lib->vba.Read256BlockWidthY[k], 4494 mode_lib->vba.SourcePixelFormat[k], 4495 mode_lib->vba.SurfaceTiling[k], 4496 dml_ceil(mode_lib->vba.BytePerPixelInDETY[k], 1.0), 4497 mode_lib->vba.SourceScan[k], 4498 mode_lib->vba.ViewportWidth[k], 4499 mode_lib->vba.ViewportHeight[k], 4500 mode_lib->vba.SwathWidthYPerState[i][j][k], 4501 mode_lib->vba.GPUVMEnable, 4502 mode_lib->vba.VMMPageSize, 4503 mode_lib->vba.PTEBufferSizeInRequestsLuma, 4504 mode_lib->vba.PDEProcessingBufIn64KBReqs, 4505 mode_lib->vba.PitchY[k], 4506 mode_lib->vba.DCCMetaPitchY[k], 4507 &mode_lib->vba.MacroTileWidthY[k], 4508 &mode_lib->vba.MetaRowBytesY, 4509 &mode_lib->vba.DPTEBytesPerRowY, 4510 &mode_lib->vba.PTEBufferSizeNotExceededY[i][j][k], 4511 &mode_lib->vba.dpte_row_height[k], 4512 &mode_lib->vba.meta_row_height[k]); 4513 mode_lib->vba.PrefetchLinesY[k] = CalculatePrefetchSourceLines( 4514 mode_lib, 4515 mode_lib->vba.VRatio[k], 4516 mode_lib->vba.vtaps[k], 4517 mode_lib->vba.Interlace[k], 4518 mode_lib->vba.ProgressiveToInterlaceUnitInOPP, 4519 mode_lib->vba.SwathHeightYPerState[i][j][k], 4520 mode_lib->vba.ViewportYStartY[k], 4521 &mode_lib->vba.PrefillY[k], 4522 &mode_lib->vba.MaxNumSwY[k]); 4523 if ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64 4524 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32 4525 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16 4526 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16 4527 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8)) { 4528 mode_lib->vba.PDEAndMetaPTEBytesPerFrameC = CalculateVMAndRowBytes( 4529 mode_lib, 4530 mode_lib->vba.DCCEnable[k], 4531 mode_lib->vba.Read256BlockHeightY[k], 4532 mode_lib->vba.Read256BlockWidthY[k], 4533 mode_lib->vba.SourcePixelFormat[k], 4534 mode_lib->vba.SurfaceTiling[k], 4535 dml_ceil(mode_lib->vba.BytePerPixelInDETC[k], 2.0), 4536 mode_lib->vba.SourceScan[k], 4537 mode_lib->vba.ViewportWidth[k] / 2.0, 4538 mode_lib->vba.ViewportHeight[k] / 2.0, 4539 mode_lib->vba.SwathWidthYPerState[i][j][k] / 2.0, 4540 mode_lib->vba.GPUVMEnable, 4541 mode_lib->vba.VMMPageSize, 4542 mode_lib->vba.PTEBufferSizeInRequestsLuma, 4543 mode_lib->vba.PDEProcessingBufIn64KBReqs, 4544 mode_lib->vba.PitchC[k], 4545 0.0, 4546 &mode_lib->vba.MacroTileWidthC[k], 4547 &mode_lib->vba.MetaRowBytesC, 4548 &mode_lib->vba.DPTEBytesPerRowC, 4549 &mode_lib->vba.PTEBufferSizeNotExceededC[i][j][k], 4550 &mode_lib->vba.dpte_row_height_chroma[k], 4551 &mode_lib->vba.meta_row_height_chroma[k]); 4552 mode_lib->vba.PrefetchLinesC[k] = CalculatePrefetchSourceLines( 4553 mode_lib, 4554 mode_lib->vba.VRatio[k] / 2.0, 4555 mode_lib->vba.VTAPsChroma[k], 4556 mode_lib->vba.Interlace[k], 4557 mode_lib->vba.ProgressiveToInterlaceUnitInOPP, 4558 mode_lib->vba.SwathHeightCPerState[i][j][k], 4559 mode_lib->vba.ViewportYStartC[k], 4560 &mode_lib->vba.PrefillC[k], 4561 &mode_lib->vba.MaxNumSwC[k]); 4562 } else { 4563 mode_lib->vba.PDEAndMetaPTEBytesPerFrameC = 0.0; 4564 mode_lib->vba.MetaRowBytesC = 0.0; 4565 mode_lib->vba.DPTEBytesPerRowC = 0.0; 4566 locals->PrefetchLinesC[k] = 0.0; 4567 locals->PTEBufferSizeNotExceededC[i][j][k] = true; 4568 locals->PTEBufferSizeInRequestsForLuma = mode_lib->vba.PTEBufferSizeInRequestsLuma + mode_lib->vba.PTEBufferSizeInRequestsChroma; 4569 } 4570 locals->PDEAndMetaPTEBytesPerFrame[k] = 4571 mode_lib->vba.PDEAndMetaPTEBytesPerFrameY + mode_lib->vba.PDEAndMetaPTEBytesPerFrameC; 4572 locals->MetaRowBytes[k] = mode_lib->vba.MetaRowBytesY + mode_lib->vba.MetaRowBytesC; 4573 locals->DPTEBytesPerRow[k] = mode_lib->vba.DPTEBytesPerRowY + mode_lib->vba.DPTEBytesPerRowC; 4574 4575 CalculateActiveRowBandwidth( 4576 mode_lib->vba.GPUVMEnable, 4577 mode_lib->vba.SourcePixelFormat[k], 4578 mode_lib->vba.VRatio[k], 4579 mode_lib->vba.DCCEnable[k], 4580 mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k], 4581 mode_lib->vba.MetaRowBytesY, 4582 mode_lib->vba.MetaRowBytesC, 4583 mode_lib->vba.meta_row_height[k], 4584 mode_lib->vba.meta_row_height_chroma[k], 4585 mode_lib->vba.DPTEBytesPerRowY, 4586 mode_lib->vba.DPTEBytesPerRowC, 4587 mode_lib->vba.dpte_row_height[k], 4588 mode_lib->vba.dpte_row_height_chroma[k], 4589 &mode_lib->vba.meta_row_bw[k], 4590 &mode_lib->vba.dpte_row_bw[k], 4591 &mode_lib->vba.qual_row_bw[k]); 4592 } 4593 mode_lib->vba.ExtraLatency = 4594 mode_lib->vba.UrgentRoundTripAndOutOfOrderLatencyPerState[i] 4595 + (mode_lib->vba.TotalNumberOfActiveDPP[i][j] 4596 * mode_lib->vba.PixelChunkSizeInKByte 4597 + mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j] 4598 * mode_lib->vba.MetaChunkSize) 4599 * 1024.0 4600 / mode_lib->vba.ReturnBWPerState[i]; 4601 if (mode_lib->vba.GPUVMEnable == true) { 4602 mode_lib->vba.ExtraLatency = mode_lib->vba.ExtraLatency 4603 + mode_lib->vba.TotalNumberOfActiveDPP[i][j] 4604 * mode_lib->vba.PTEGroupSize 4605 / mode_lib->vba.ReturnBWPerState[i]; 4606 } 4607 mode_lib->vba.TimeCalc = 24.0 / mode_lib->vba.ProjectedDCFCLKDeepSleep; 4608 4609 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4610 if (mode_lib->vba.BlendingAndTiming[k] == k) { 4611 if (mode_lib->vba.WritebackEnable[k] == true) { 4612 locals->WritebackDelay[i][k] = mode_lib->vba.WritebackLatency 4613 + CalculateWriteBackDelay( 4614 mode_lib->vba.WritebackPixelFormat[k], 4615 mode_lib->vba.WritebackHRatio[k], 4616 mode_lib->vba.WritebackVRatio[k], 4617 mode_lib->vba.WritebackLumaHTaps[k], 4618 mode_lib->vba.WritebackLumaVTaps[k], 4619 mode_lib->vba.WritebackChromaHTaps[k], 4620 mode_lib->vba.WritebackChromaVTaps[k], 4621 mode_lib->vba.WritebackDestinationWidth[k]) / locals->RequiredDISPCLK[i][j]; 4622 } else { 4623 locals->WritebackDelay[i][k] = 0.0; 4624 } 4625 for (m = 0; m <= mode_lib->vba.NumberOfActivePlanes - 1; m++) { 4626 if (mode_lib->vba.BlendingAndTiming[m] == k 4627 && mode_lib->vba.WritebackEnable[m] 4628 == true) { 4629 locals->WritebackDelay[i][k] = dml_max(locals->WritebackDelay[i][k], 4630 mode_lib->vba.WritebackLatency + CalculateWriteBackDelay( 4631 mode_lib->vba.WritebackPixelFormat[m], 4632 mode_lib->vba.WritebackHRatio[m], 4633 mode_lib->vba.WritebackVRatio[m], 4634 mode_lib->vba.WritebackLumaHTaps[m], 4635 mode_lib->vba.WritebackLumaVTaps[m], 4636 mode_lib->vba.WritebackChromaHTaps[m], 4637 mode_lib->vba.WritebackChromaVTaps[m], 4638 mode_lib->vba.WritebackDestinationWidth[m]) / locals->RequiredDISPCLK[i][j]); 4639 } 4640 } 4641 } 4642 } 4643 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4644 for (m = 0; m <= mode_lib->vba.NumberOfActivePlanes - 1; m++) { 4645 if (mode_lib->vba.BlendingAndTiming[k] == m) { 4646 locals->WritebackDelay[i][k] = locals->WritebackDelay[i][m]; 4647 } 4648 } 4649 } 4650 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4651 for (m = 0; m < locals->NumberOfCursors[k]; m++) 4652 locals->cursor_bw[k] = locals->NumberOfCursors[k] * locals->CursorWidth[k][m] * locals->CursorBPP[k][m] 4653 / 8 / (locals->HTotal[k] / locals->PixelClock[k]) * locals->VRatio[k]; 4654 } 4655 4656 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4657 locals->MaximumVStartup[k] = mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k] 4658 - dml_max(1.0, dml_ceil(locals->WritebackDelay[i][k] / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]), 1.0)); 4659 } 4660 4661 mode_lib->vba.NextPrefetchMode = mode_lib->vba.MinPrefetchMode; 4662 do { 4663 mode_lib->vba.PrefetchMode[i][j] = mode_lib->vba.NextPrefetchMode; 4664 mode_lib->vba.NextPrefetchMode = mode_lib->vba.NextPrefetchMode + 1; 4665 4666 mode_lib->vba.TWait = CalculateTWait( 4667 mode_lib->vba.PrefetchMode[i][j], 4668 mode_lib->vba.DRAMClockChangeLatency, 4669 mode_lib->vba.UrgentLatency, 4670 mode_lib->vba.SREnterPlusExitTime); 4671 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4672 4673 if (mode_lib->vba.XFCEnabled[k] == true) { 4674 mode_lib->vba.XFCRemoteSurfaceFlipDelay = 4675 CalculateRemoteSurfaceFlipDelay( 4676 mode_lib, 4677 mode_lib->vba.VRatio[k], 4678 locals->SwathWidthYPerState[i][j][k], 4679 dml_ceil(locals->BytePerPixelInDETY[k], 1.0), 4680 mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k], 4681 mode_lib->vba.XFCTSlvVupdateOffset, 4682 mode_lib->vba.XFCTSlvVupdateWidth, 4683 mode_lib->vba.XFCTSlvVreadyOffset, 4684 mode_lib->vba.XFCXBUFLatencyTolerance, 4685 mode_lib->vba.XFCFillBWOverhead, 4686 mode_lib->vba.XFCSlvChunkSize, 4687 mode_lib->vba.XFCBusTransportTime, 4688 mode_lib->vba.TimeCalc, 4689 mode_lib->vba.TWait, 4690 &mode_lib->vba.SrcActiveDrainRate, 4691 &mode_lib->vba.TInitXFill, 4692 &mode_lib->vba.TslvChk); 4693 } else { 4694 mode_lib->vba.XFCRemoteSurfaceFlipDelay = 0.0; 4695 } 4696 mode_lib->vba.IsErrorResult[i][j][k] = 4697 CalculatePrefetchSchedule( 4698 mode_lib, 4699 mode_lib->vba.RequiredDPPCLK[i][j][k], 4700 mode_lib->vba.RequiredDISPCLK[i][j], 4701 mode_lib->vba.PixelClock[k], 4702 mode_lib->vba.ProjectedDCFCLKDeepSleep, 4703 mode_lib->vba.DSCDelayPerState[i][k], 4704 mode_lib->vba.NoOfDPP[i][j][k], 4705 mode_lib->vba.ScalerEnabled[k], 4706 mode_lib->vba.NumberOfCursors[k], 4707 mode_lib->vba.DPPCLKDelaySubtotal, 4708 mode_lib->vba.DPPCLKDelaySCL, 4709 mode_lib->vba.DPPCLKDelaySCLLBOnly, 4710 mode_lib->vba.DPPCLKDelayCNVCFormater, 4711 mode_lib->vba.DPPCLKDelayCNVCCursor, 4712 mode_lib->vba.DISPCLKDelaySubtotal, 4713 mode_lib->vba.SwathWidthYPerState[i][j][k] 4714 / mode_lib->vba.HRatio[k], 4715 mode_lib->vba.OutputFormat[k], 4716 mode_lib->vba.VTotal[k] 4717 - mode_lib->vba.VActive[k], 4718 mode_lib->vba.HTotal[k], 4719 mode_lib->vba.MaxInterDCNTileRepeaters, 4720 mode_lib->vba.MaximumVStartup[k], 4721 mode_lib->vba.GPUVMMaxPageTableLevels, 4722 mode_lib->vba.GPUVMEnable, 4723 mode_lib->vba.DynamicMetadataEnable[k], 4724 mode_lib->vba.DynamicMetadataLinesBeforeActiveRequired[k], 4725 mode_lib->vba.DynamicMetadataTransmittedBytes[k], 4726 mode_lib->vba.DCCEnable[k], 4727 mode_lib->vba.UrgentLatencyPixelDataOnly, 4728 mode_lib->vba.ExtraLatency, 4729 mode_lib->vba.TimeCalc, 4730 mode_lib->vba.PDEAndMetaPTEBytesPerFrame[k], 4731 mode_lib->vba.MetaRowBytes[k], 4732 mode_lib->vba.DPTEBytesPerRow[k], 4733 mode_lib->vba.PrefetchLinesY[k], 4734 mode_lib->vba.SwathWidthYPerState[i][j][k], 4735 mode_lib->vba.BytePerPixelInDETY[k], 4736 mode_lib->vba.PrefillY[k], 4737 mode_lib->vba.MaxNumSwY[k], 4738 mode_lib->vba.PrefetchLinesC[k], 4739 mode_lib->vba.BytePerPixelInDETC[k], 4740 mode_lib->vba.PrefillC[k], 4741 mode_lib->vba.MaxNumSwC[k], 4742 mode_lib->vba.SwathHeightYPerState[i][j][k], 4743 mode_lib->vba.SwathHeightCPerState[i][j][k], 4744 mode_lib->vba.TWait, 4745 mode_lib->vba.XFCEnabled[k], 4746 mode_lib->vba.XFCRemoteSurfaceFlipDelay, 4747 mode_lib->vba.Interlace[k], 4748 mode_lib->vba.ProgressiveToInterlaceUnitInOPP, 4749 mode_lib->vba.DSTXAfterScaler, 4750 mode_lib->vba.DSTYAfterScaler, 4751 &mode_lib->vba.LineTimesForPrefetch[k], 4752 &mode_lib->vba.PrefetchBW[k], 4753 &mode_lib->vba.LinesForMetaPTE[k], 4754 &mode_lib->vba.LinesForMetaAndDPTERow[k], 4755 &mode_lib->vba.VRatioPreY[i][j][k], 4756 &mode_lib->vba.VRatioPreC[i][j][k], 4757 &mode_lib->vba.RequiredPrefetchPixelDataBWLuma[i][j][k], 4758 &mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata, 4759 &mode_lib->vba.Tno_bw[k], 4760 &mode_lib->vba.VUpdateOffsetPix[k], 4761 &mode_lib->vba.VUpdateWidthPix[k], 4762 &mode_lib->vba.VReadyOffsetPix[k]); 4763 } 4764 mode_lib->vba.MaximumReadBandwidthWithoutPrefetch = 0.0; 4765 mode_lib->vba.MaximumReadBandwidthWithPrefetch = 0.0; 4766 locals->prefetch_vm_bw_valid = true; 4767 locals->prefetch_row_bw_valid = true; 4768 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4769 if (locals->PDEAndMetaPTEBytesPerFrame[k] == 0) 4770 locals->prefetch_vm_bw[k] = 0; 4771 else if (locals->LinesForMetaPTE[k] > 0) 4772 locals->prefetch_vm_bw[k] = locals->PDEAndMetaPTEBytesPerFrame[k] 4773 / (locals->LinesForMetaPTE[k] * locals->HTotal[k] / locals->PixelClock[k]); 4774 else { 4775 locals->prefetch_vm_bw[k] = 0; 4776 locals->prefetch_vm_bw_valid = false; 4777 } 4778 if (locals->MetaRowBytes[k] + locals->DPTEBytesPerRow[k] == 0) 4779 locals->prefetch_row_bw[k] = 0; 4780 else if (locals->LinesForMetaAndDPTERow[k] > 0) 4781 locals->prefetch_row_bw[k] = (locals->MetaRowBytes[k] + locals->DPTEBytesPerRow[k]) 4782 / (locals->LinesForMetaAndDPTERow[k] * locals->HTotal[k] / locals->PixelClock[k]); 4783 else { 4784 locals->prefetch_row_bw[k] = 0; 4785 locals->prefetch_row_bw_valid = false; 4786 } 4787 4788 mode_lib->vba.MaximumReadBandwidthWithoutPrefetch = mode_lib->vba.MaximumReadBandwidthWithPrefetch 4789 + mode_lib->vba.cursor_bw[k] + mode_lib->vba.ReadBandwidth[k] + mode_lib->vba.meta_row_bw[k] + mode_lib->vba.dpte_row_bw[k]; 4790 mode_lib->vba.MaximumReadBandwidthWithPrefetch = 4791 mode_lib->vba.MaximumReadBandwidthWithPrefetch 4792 + mode_lib->vba.cursor_bw[k] 4793 + dml_max3( 4794 mode_lib->vba.prefetch_vm_bw[k], 4795 mode_lib->vba.prefetch_row_bw[k], 4796 dml_max(mode_lib->vba.ReadBandwidth[k], 4797 mode_lib->vba.RequiredPrefetchPixelDataBWLuma[i][j][k]) 4798 + mode_lib->vba.meta_row_bw[k] + mode_lib->vba.dpte_row_bw[k]); 4799 } 4800 locals->BandwidthWithoutPrefetchSupported[i] = true; 4801 if (mode_lib->vba.MaximumReadBandwidthWithoutPrefetch > locals->ReturnBWPerState[i]) { 4802 locals->BandwidthWithoutPrefetchSupported[i] = false; 4803 } 4804 4805 locals->PrefetchSupported[i][j] = true; 4806 if (mode_lib->vba.MaximumReadBandwidthWithPrefetch > locals->ReturnBWPerState[i]) { 4807 locals->PrefetchSupported[i][j] = false; 4808 } 4809 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4810 if (locals->LineTimesForPrefetch[k] < 2.0 4811 || locals->LinesForMetaPTE[k] >= 8.0 4812 || locals->LinesForMetaAndDPTERow[k] >= 16.0 4813 || mode_lib->vba.IsErrorResult[i][j][k] == true) { 4814 locals->PrefetchSupported[i][j] = false; 4815 } 4816 } 4817 locals->VRatioInPrefetchSupported[i][j] = true; 4818 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4819 if (locals->VRatioPreY[i][j][k] > 4.0 4820 || locals->VRatioPreC[i][j][k] > 4.0 4821 || mode_lib->vba.IsErrorResult[i][j][k] == true) { 4822 locals->VRatioInPrefetchSupported[i][j] = false; 4823 } 4824 } 4825 } while ((locals->PrefetchSupported[i][j] != true || locals->VRatioInPrefetchSupported[i][j] != true) 4826 && mode_lib->vba.NextPrefetchMode < mode_lib->vba.MaxPrefetchMode); 4827 4828 if (mode_lib->vba.PrefetchSupported[i][j] == true 4829 && mode_lib->vba.VRatioInPrefetchSupported[i][j] == true) { 4830 mode_lib->vba.BandwidthAvailableForImmediateFlip = 4831 mode_lib->vba.ReturnBWPerState[i]; 4832 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4833 mode_lib->vba.BandwidthAvailableForImmediateFlip = 4834 mode_lib->vba.BandwidthAvailableForImmediateFlip 4835 - mode_lib->vba.cursor_bw[k] 4836 - dml_max( 4837 mode_lib->vba.ReadBandwidth[k] + mode_lib->vba.qual_row_bw[k], 4838 mode_lib->vba.PrefetchBW[k]); 4839 } 4840 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4841 mode_lib->vba.ImmediateFlipBytes[k] = 0.0; 4842 if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8 4843 && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) { 4844 mode_lib->vba.ImmediateFlipBytes[k] = 4845 mode_lib->vba.PDEAndMetaPTEBytesPerFrame[k] 4846 + mode_lib->vba.MetaRowBytes[k] 4847 + mode_lib->vba.DPTEBytesPerRow[k]; 4848 } 4849 } 4850 mode_lib->vba.TotImmediateFlipBytes = 0.0; 4851 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4852 if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8 4853 && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) { 4854 mode_lib->vba.TotImmediateFlipBytes = 4855 mode_lib->vba.TotImmediateFlipBytes 4856 + mode_lib->vba.ImmediateFlipBytes[k]; 4857 } 4858 } 4859 4860 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4861 CalculateFlipSchedule( 4862 mode_lib, 4863 mode_lib->vba.ExtraLatency, 4864 mode_lib->vba.UrgentLatencyPixelDataOnly, 4865 mode_lib->vba.GPUVMMaxPageTableLevels, 4866 mode_lib->vba.GPUVMEnable, 4867 mode_lib->vba.BandwidthAvailableForImmediateFlip, 4868 mode_lib->vba.TotImmediateFlipBytes, 4869 mode_lib->vba.SourcePixelFormat[k], 4870 mode_lib->vba.ImmediateFlipBytes[k], 4871 mode_lib->vba.HTotal[k] 4872 / mode_lib->vba.PixelClock[k], 4873 mode_lib->vba.VRatio[k], 4874 mode_lib->vba.Tno_bw[k], 4875 mode_lib->vba.PDEAndMetaPTEBytesPerFrame[k], 4876 mode_lib->vba.MetaRowBytes[k], 4877 mode_lib->vba.DPTEBytesPerRow[k], 4878 mode_lib->vba.DCCEnable[k], 4879 mode_lib->vba.dpte_row_height[k], 4880 mode_lib->vba.meta_row_height[k], 4881 mode_lib->vba.qual_row_bw[k], 4882 &mode_lib->vba.DestinationLinesToRequestVMInImmediateFlip[k], 4883 &mode_lib->vba.DestinationLinesToRequestRowInImmediateFlip[k], 4884 &mode_lib->vba.final_flip_bw[k], 4885 &mode_lib->vba.ImmediateFlipSupportedForPipe[k]); 4886 } 4887 mode_lib->vba.total_dcn_read_bw_with_flip = 0.0; 4888 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4889 mode_lib->vba.total_dcn_read_bw_with_flip = 4890 mode_lib->vba.total_dcn_read_bw_with_flip 4891 + mode_lib->vba.cursor_bw[k] 4892 + dml_max3( 4893 mode_lib->vba.prefetch_vm_bw[k], 4894 mode_lib->vba.prefetch_row_bw[k], 4895 mode_lib->vba.final_flip_bw[k] 4896 + dml_max( 4897 mode_lib->vba.ReadBandwidth[k], 4898 mode_lib->vba.RequiredPrefetchPixelDataBWLuma[i][j][k])); 4899 } 4900 mode_lib->vba.ImmediateFlipSupportedForState[i][j] = true; 4901 if (mode_lib->vba.total_dcn_read_bw_with_flip 4902 > mode_lib->vba.ReturnBWPerState[i]) { 4903 mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false; 4904 } 4905 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4906 if (mode_lib->vba.ImmediateFlipSupportedForPipe[k] == false) { 4907 mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false; 4908 } 4909 } 4910 } else { 4911 mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false; 4912 } 4913 } 4914 } 4915 4916 /*Vertical Active BW support*/ 4917 mode_lib->vba.MaxTotalVActiveRDBandwidth = 0; 4918 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; k++) 4919 mode_lib->vba.MaxTotalVActiveRDBandwidth = mode_lib->vba.MaxTotalVActiveRDBandwidth + mode_lib->vba.ReadBandwidth[k]; 4920 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) { 4921 mode_lib->vba.MaxTotalVerticalActiveAvailableBandwidth[i] = dml_min(mode_lib->vba.ReturnBusWidth * 4922 mode_lib->vba.DCFCLKPerState[i], mode_lib->vba.FabricAndDRAMBandwidthPerState[i] * 1000) * 4923 mode_lib->vba.MaxAveragePercentOfIdealDRAMBWDisplayCanUseInNormalSystemOperation / 100; 4924 if (mode_lib->vba.MaxTotalVActiveRDBandwidth <= mode_lib->vba.MaxTotalVerticalActiveAvailableBandwidth[i]) 4925 mode_lib->vba.TotalVerticalActiveBandwidthSupport[i] = true; 4926 else 4927 mode_lib->vba.TotalVerticalActiveBandwidthSupport[i] = false; 4928 } 4929 4930 /*PTE Buffer Size Check*/ 4931 4932 for (i = 0; i <= mode_lib->vba.soc.num_states; i++) { 4933 for (j = 0; j < 2; j++) { 4934 locals->PTEBufferSizeNotExceeded[i][j] = true; 4935 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4936 if (locals->PTEBufferSizeNotExceededY[i][j][k] == false 4937 || locals->PTEBufferSizeNotExceededC[i][j][k] == false) { 4938 locals->PTEBufferSizeNotExceeded[i][j] = false; 4939 } 4940 } 4941 } 4942 } 4943 /*Cursor Support Check*/ 4944 mode_lib->vba.CursorSupport = true; 4945 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4946 for (j = 0; j < 2; j++) { 4947 if (mode_lib->vba.CursorWidth[k][j] > 0.0) { 4948 if (dml_floor( 4949 dml_floor( 4950 mode_lib->vba.CursorBufferSize 4951 - mode_lib->vba.CursorChunkSize, 4952 mode_lib->vba.CursorChunkSize) * 1024.0 4953 / (mode_lib->vba.CursorWidth[k][j] 4954 * mode_lib->vba.CursorBPP[k][j] 4955 / 8.0), 4956 1.0) 4957 * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) 4958 / mode_lib->vba.VRatio[k] < mode_lib->vba.UrgentLatencyPixelDataOnly 4959 || (mode_lib->vba.CursorBPP[k][j] == 64.0 4960 && mode_lib->vba.Cursor64BppSupport == false)) { 4961 mode_lib->vba.CursorSupport = false; 4962 } 4963 } 4964 } 4965 } 4966 /*Valid Pitch Check*/ 4967 4968 mode_lib->vba.PitchSupport = true; 4969 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 4970 locals->AlignedYPitch[k] = dml_ceil( 4971 dml_max(mode_lib->vba.PitchY[k], mode_lib->vba.ViewportWidth[k]), 4972 locals->MacroTileWidthY[k]); 4973 if (locals->AlignedYPitch[k] > mode_lib->vba.PitchY[k]) { 4974 mode_lib->vba.PitchSupport = false; 4975 } 4976 if (mode_lib->vba.DCCEnable[k] == true) { 4977 locals->AlignedDCCMetaPitch[k] = dml_ceil( 4978 dml_max( 4979 mode_lib->vba.DCCMetaPitchY[k], 4980 mode_lib->vba.ViewportWidth[k]), 4981 64.0 * locals->Read256BlockWidthY[k]); 4982 } else { 4983 locals->AlignedDCCMetaPitch[k] = mode_lib->vba.DCCMetaPitchY[k]; 4984 } 4985 if (locals->AlignedDCCMetaPitch[k] > mode_lib->vba.DCCMetaPitchY[k]) { 4986 mode_lib->vba.PitchSupport = false; 4987 } 4988 if (mode_lib->vba.SourcePixelFormat[k] != dm_444_64 4989 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32 4990 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16 4991 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16 4992 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8) { 4993 locals->AlignedCPitch[k] = dml_ceil( 4994 dml_max( 4995 mode_lib->vba.PitchC[k], 4996 mode_lib->vba.ViewportWidth[k] / 2.0), 4997 locals->MacroTileWidthC[k]); 4998 } else { 4999 locals->AlignedCPitch[k] = mode_lib->vba.PitchC[k]; 5000 } 5001 if (locals->AlignedCPitch[k] > mode_lib->vba.PitchC[k]) { 5002 mode_lib->vba.PitchSupport = false; 5003 } 5004 } 5005 /*Mode Support, Voltage State and SOC Configuration*/ 5006 5007 for (i = mode_lib->vba.soc.num_states; i >= 0; i--) { 5008 for (j = 0; j < 2; j++) { 5009 enum dm_validation_status status = DML_VALIDATION_OK; 5010 5011 if (mode_lib->vba.ScaleRatioAndTapsSupport != true) { 5012 status = DML_FAIL_SCALE_RATIO_TAP; 5013 } else if (mode_lib->vba.SourceFormatPixelAndScanSupport != true) { 5014 status = DML_FAIL_SOURCE_PIXEL_FORMAT; 5015 } else if (locals->ViewportSizeSupport[i] != true) { 5016 status = DML_FAIL_VIEWPORT_SIZE; 5017 } else if (locals->DIOSupport[i] != true) { 5018 status = DML_FAIL_DIO_SUPPORT; 5019 } else if (locals->NotEnoughDSCUnits[i] != false) { 5020 status = DML_FAIL_NOT_ENOUGH_DSC; 5021 } else if (locals->DSCCLKRequiredMoreThanSupported[i] != false) { 5022 status = DML_FAIL_DSC_CLK_REQUIRED; 5023 } else if (locals->UrgentLatencySupport[i][j] != true) { 5024 status = DML_FAIL_URGENT_LATENCY; 5025 } else if (locals->ROBSupport[i] != true) { 5026 status = DML_FAIL_REORDERING_BUFFER; 5027 } else if (locals->DISPCLK_DPPCLK_Support[i][j] != true) { 5028 status = DML_FAIL_DISPCLK_DPPCLK; 5029 } else if (locals->TotalAvailablePipesSupport[i][j] != true) { 5030 status = DML_FAIL_TOTAL_AVAILABLE_PIPES; 5031 } else if (mode_lib->vba.NumberOfOTGSupport != true) { 5032 status = DML_FAIL_NUM_OTG; 5033 } else if (mode_lib->vba.WritebackModeSupport != true) { 5034 status = DML_FAIL_WRITEBACK_MODE; 5035 } else if (mode_lib->vba.WritebackLatencySupport != true) { 5036 status = DML_FAIL_WRITEBACK_LATENCY; 5037 } else if (mode_lib->vba.WritebackScaleRatioAndTapsSupport != true) { 5038 status = DML_FAIL_WRITEBACK_SCALE_RATIO_TAP; 5039 } else if (mode_lib->vba.CursorSupport != true) { 5040 status = DML_FAIL_CURSOR_SUPPORT; 5041 } else if (mode_lib->vba.PitchSupport != true) { 5042 status = DML_FAIL_PITCH_SUPPORT; 5043 } else if (locals->PrefetchSupported[i][j] != true) { 5044 status = DML_FAIL_PREFETCH_SUPPORT; 5045 } else if (locals->TotalVerticalActiveBandwidthSupport[i] != true) { 5046 status = DML_FAIL_TOTAL_V_ACTIVE_BW; 5047 } else if (locals->VRatioInPrefetchSupported[i][j] != true) { 5048 status = DML_FAIL_V_RATIO_PREFETCH; 5049 } else if (locals->PTEBufferSizeNotExceeded[i][j] != true) { 5050 status = DML_FAIL_PTE_BUFFER_SIZE; 5051 } else if (mode_lib->vba.NonsupportedDSCInputBPC != false) { 5052 status = DML_FAIL_DSC_INPUT_BPC; 5053 } 5054 5055 if (status == DML_VALIDATION_OK) { 5056 locals->ModeSupport[i][j] = true; 5057 } else { 5058 locals->ModeSupport[i][j] = false; 5059 } 5060 locals->ValidationStatus[i] = status; 5061 } 5062 } 5063 { 5064 unsigned int MaximumMPCCombine = 0; 5065 mode_lib->vba.VoltageLevel = mode_lib->vba.soc.num_states + 1; 5066 for (i = mode_lib->vba.VoltageOverrideLevel; i <= mode_lib->vba.soc.num_states; i++) { 5067 if (locals->ModeSupport[i][0] == true || locals->ModeSupport[i][1] == true) { 5068 mode_lib->vba.VoltageLevel = i; 5069 if (locals->ModeSupport[i][1] == true && (locals->ModeSupport[i][0] == false 5070 || mode_lib->vba.WhenToDoMPCCombine == dm_mpc_always_when_possible)) { 5071 MaximumMPCCombine = 1; 5072 } else { 5073 MaximumMPCCombine = 0; 5074 } 5075 break; 5076 } 5077 } 5078 mode_lib->vba.ImmediateFlipSupport = 5079 locals->ImmediateFlipSupportedForState[mode_lib->vba.VoltageLevel][MaximumMPCCombine]; 5080 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 5081 mode_lib->vba.DPPPerPlane[k] = locals->NoOfDPP[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k]; 5082 locals->DPPCLK[k] = locals->RequiredDPPCLK[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k]; 5083 } 5084 mode_lib->vba.DISPCLK = locals->RequiredDISPCLK[mode_lib->vba.VoltageLevel][MaximumMPCCombine]; 5085 mode_lib->vba.maxMpcComb = MaximumMPCCombine; 5086 } 5087 mode_lib->vba.DCFCLK = mode_lib->vba.DCFCLKPerState[mode_lib->vba.VoltageLevel]; 5088 mode_lib->vba.DRAMSpeed = mode_lib->vba.DRAMSpeedPerState[mode_lib->vba.VoltageLevel]; 5089 mode_lib->vba.FabricClock = mode_lib->vba.FabricClockPerState[mode_lib->vba.VoltageLevel]; 5090 mode_lib->vba.SOCCLK = mode_lib->vba.SOCCLKPerState[mode_lib->vba.VoltageLevel]; 5091 mode_lib->vba.ReturnBW = locals->ReturnBWPerState[mode_lib->vba.VoltageLevel]; 5092 mode_lib->vba.FabricAndDRAMBandwidth = locals->FabricAndDRAMBandwidthPerState[mode_lib->vba.VoltageLevel]; 5093 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) { 5094 if (mode_lib->vba.BlendingAndTiming[k] == k) { 5095 mode_lib->vba.ODMCombineEnabled[k] = 5096 locals->ODMCombineEnablePerState[mode_lib->vba.VoltageLevel][k]; 5097 } else { 5098 mode_lib->vba.ODMCombineEnabled[k] = 0; 5099 } 5100 mode_lib->vba.DSCEnabled[k] = 5101 locals->RequiresDSC[mode_lib->vba.VoltageLevel][k]; 5102 mode_lib->vba.OutputBpp[k] = 5103 locals->OutputBppPerState[mode_lib->vba.VoltageLevel][k]; 5104 } 5105 } 5106