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