drivers/gpu/drm/amd/display/dc/dml/dcn20/display_mode_vba_20.c

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