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_l_vp) {
 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] == dm_odm_combine_mode_2to1)
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[k] == dm_odm_combine_mode_2to1)
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.DRAMClockChangeSupportsVActive &&
2581                         mode_lib->vba.MinActiveDRAMClockChangeMargin > 60) {
2582                 mode_lib->vba.DRAMClockChangeWatermark += 25;
2583                 mode_lib->vba.DRAMClockChangeSupport[0][0] = dm_dram_clock_change_vactive;
2584         } else {
2585                 if (mode_lib->vba.SynchronizedVBlank || mode_lib->vba.NumberOfActivePlanes == 1) {
2586                         mode_lib->vba.DRAMClockChangeSupport[0][0] = dm_dram_clock_change_vblank;
2587                         for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2588                                 if (!mode_lib->vba.AllowDRAMClockChangeDuringVBlank[k]) {
2589                                         mode_lib->vba.DRAMClockChangeSupport[0][0] =
2590                                                         dm_dram_clock_change_unsupported;
2591                                 }
2592                         }
2593                 } else {
2594                         mode_lib->vba.DRAMClockChangeSupport[0][0] = dm_dram_clock_change_unsupported;
2595                 }
2596         }
2597         for (k = 0; k <= mode_lib->vba.soc.num_states; k++)
2598                 for (j = 0; j < 2; j++)
2599                         mode_lib->vba.DRAMClockChangeSupport[k][j] = mode_lib->vba.DRAMClockChangeSupport[0][0];
2600
2601         //XFC Parameters:
2602         for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2603                 if (mode_lib->vba.XFCEnabled[k] == true) {
2604                         double TWait;
2605
2606                         mode_lib->vba.XFCSlaveVUpdateOffset[k] = mode_lib->vba.XFCTSlvVupdateOffset;
2607                         mode_lib->vba.XFCSlaveVupdateWidth[k] = mode_lib->vba.XFCTSlvVupdateWidth;
2608                         mode_lib->vba.XFCSlaveVReadyOffset[k] = mode_lib->vba.XFCTSlvVreadyOffset;
2609                         TWait = CalculateTWait(
2610                                         mode_lib->vba.PrefetchMode[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb],
2611                                         mode_lib->vba.DRAMClockChangeLatency,
2612                                         mode_lib->vba.UrgentLatencyPixelDataOnly,
2613                                         mode_lib->vba.SREnterPlusExitTime);
2614                         mode_lib->vba.XFCRemoteSurfaceFlipDelay = CalculateRemoteSurfaceFlipDelay(
2615                                         mode_lib,
2616                                         mode_lib->vba.VRatio[k],
2617                                         mode_lib->vba.SwathWidthY[k],
2618                                         dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1),
2619                                         mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
2620                                         mode_lib->vba.XFCTSlvVupdateOffset,
2621                                         mode_lib->vba.XFCTSlvVupdateWidth,
2622                                         mode_lib->vba.XFCTSlvVreadyOffset,
2623                                         mode_lib->vba.XFCXBUFLatencyTolerance,
2624                                         mode_lib->vba.XFCFillBWOverhead,
2625                                         mode_lib->vba.XFCSlvChunkSize,
2626                                         mode_lib->vba.XFCBusTransportTime,
2627                                         mode_lib->vba.TCalc,
2628                                         TWait,
2629                                         &mode_lib->vba.SrcActiveDrainRate,
2630                                         &mode_lib->vba.TInitXFill,
2631                                         &mode_lib->vba.TslvChk);
2632                         mode_lib->vba.XFCRemoteSurfaceFlipLatency[k] =
2633                                         dml_floor(
2634                                                         mode_lib->vba.XFCRemoteSurfaceFlipDelay
2635                                                                         / (mode_lib->vba.HTotal[k]
2636                                                                                         / mode_lib->vba.PixelClock[k]),
2637                                                         1);
2638                         mode_lib->vba.XFCTransferDelay[k] =
2639                                         dml_ceil(
2640                                                         mode_lib->vba.XFCBusTransportTime
2641                                                                         / (mode_lib->vba.HTotal[k]
2642                                                                                         / mode_lib->vba.PixelClock[k]),
2643                                                         1);
2644                         mode_lib->vba.XFCPrechargeDelay[k] =
2645                                         dml_ceil(
2646                                                         (mode_lib->vba.XFCBusTransportTime
2647                                                                         + mode_lib->vba.TInitXFill
2648                                                                         + mode_lib->vba.TslvChk)
2649                                                                         / (mode_lib->vba.HTotal[k]
2650                                                                                         / mode_lib->vba.PixelClock[k]),
2651                                                         1);
2652                         mode_lib->vba.InitFillLevel = mode_lib->vba.XFCXBUFLatencyTolerance
2653                                         * mode_lib->vba.SrcActiveDrainRate;
2654                         mode_lib->vba.FinalFillMargin =
2655                                         (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k]
2656                                                         + mode_lib->vba.DestinationLinesToRequestRowInVBlank[k])
2657                                                         * mode_lib->vba.HTotal[k]
2658                                                         / mode_lib->vba.PixelClock[k]
2659                                                         * mode_lib->vba.SrcActiveDrainRate
2660                                                         + mode_lib->vba.XFCFillConstant;
2661                         mode_lib->vba.FinalFillLevel = mode_lib->vba.XFCRemoteSurfaceFlipDelay
2662                                         * mode_lib->vba.SrcActiveDrainRate
2663                                         + mode_lib->vba.FinalFillMargin;
2664                         mode_lib->vba.RemainingFillLevel = dml_max(
2665                                         0.0,
2666                                         mode_lib->vba.FinalFillLevel - mode_lib->vba.InitFillLevel);
2667                         mode_lib->vba.TFinalxFill = mode_lib->vba.RemainingFillLevel
2668                                         / (mode_lib->vba.SrcActiveDrainRate
2669                                                         * mode_lib->vba.XFCFillBWOverhead / 100);
2670                         mode_lib->vba.XFCPrefetchMargin[k] =
2671                                         mode_lib->vba.XFCRemoteSurfaceFlipDelay
2672                                                         + mode_lib->vba.TFinalxFill
2673                                                         + (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k]
2674                                                                         + mode_lib->vba.DestinationLinesToRequestRowInVBlank[k])
2675                                                                         * mode_lib->vba.HTotal[k]
2676                                                                         / mode_lib->vba.PixelClock[k];
2677                 } else {
2678                         mode_lib->vba.XFCSlaveVUpdateOffset[k] = 0;
2679                         mode_lib->vba.XFCSlaveVupdateWidth[k] = 0;
2680                         mode_lib->vba.XFCSlaveVReadyOffset[k] = 0;
2681                         mode_lib->vba.XFCRemoteSurfaceFlipLatency[k] = 0;
2682                         mode_lib->vba.XFCPrechargeDelay[k] = 0;
2683                         mode_lib->vba.XFCTransferDelay[k] = 0;
2684                         mode_lib->vba.XFCPrefetchMargin[k] = 0;
2685                 }
2686         }
2687         {
2688                 unsigned int VStartupMargin = 0;
2689                 bool FirstMainPlane = true;
2690
2691                 for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2692                         if (mode_lib->vba.BlendingAndTiming[k] == k) {
2693                                 unsigned int Margin = (mode_lib->vba.MaxVStartupLines[k] - mode_lib->vba.VStartup[k])
2694                                                 * mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k];
2695
2696                                 if (FirstMainPlane) {
2697                                         VStartupMargin = Margin;
2698                                         FirstMainPlane = false;
2699                                 } else
2700                                         VStartupMargin = dml_min(VStartupMargin, Margin);
2701                 }
2702
2703                 if (mode_lib->vba.UseMaximumVStartup) {
2704                         if (mode_lib->vba.VTotal_Max[k] == mode_lib->vba.VTotal[k]) {
2705                                 //only use max vstart if it is not drr or lateflip.
2706                                 mode_lib->vba.VStartup[k] = mode_lib->vba.MaxVStartupLines[mode_lib->vba.BlendingAndTiming[k]];
2707                         }
2708                 }
2709         }
2710 }
2711 }
2712
2713 static void dml20_DisplayPipeConfiguration(struct display_mode_lib *mode_lib)
2714 {
2715         double BytePerPixDETY;
2716         double BytePerPixDETC;
2717         double Read256BytesBlockHeightY;
2718         double Read256BytesBlockHeightC;
2719         double Read256BytesBlockWidthY;
2720         double Read256BytesBlockWidthC;
2721         double MaximumSwathHeightY;
2722         double MaximumSwathHeightC;
2723         double MinimumSwathHeightY;
2724         double MinimumSwathHeightC;
2725         double SwathWidth;
2726         double SwathWidthGranularityY;
2727         double SwathWidthGranularityC;
2728         double RoundedUpMaxSwathSizeBytesY;
2729         double RoundedUpMaxSwathSizeBytesC;
2730         unsigned int j, k;
2731
2732         for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2733                 bool MainPlaneDoesODMCombine = false;
2734
2735                 if (mode_lib->vba.SourcePixelFormat[k] == dm_444_64) {
2736                         BytePerPixDETY = 8;
2737                         BytePerPixDETC = 0;
2738                 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_32) {
2739                         BytePerPixDETY = 4;
2740                         BytePerPixDETC = 0;
2741                 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_16) {
2742                         BytePerPixDETY = 2;
2743                         BytePerPixDETC = 0;
2744                 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_8) {
2745                         BytePerPixDETY = 1;
2746                         BytePerPixDETC = 0;
2747                 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8) {
2748                         BytePerPixDETY = 1;
2749                         BytePerPixDETC = 2;
2750                 } else {
2751                         BytePerPixDETY = 4.0 / 3.0;
2752                         BytePerPixDETC = 8.0 / 3.0;
2753                 }
2754
2755                 if ((mode_lib->vba.SourcePixelFormat[k] == dm_444_64
2756                                 || mode_lib->vba.SourcePixelFormat[k] == dm_444_32
2757                                 || mode_lib->vba.SourcePixelFormat[k] == dm_444_16
2758                                 || mode_lib->vba.SourcePixelFormat[k] == dm_444_8)) {
2759                         if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
2760                                 Read256BytesBlockHeightY = 1;
2761                         } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_64) {
2762                                 Read256BytesBlockHeightY = 4;
2763                         } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_32
2764                                         || mode_lib->vba.SourcePixelFormat[k] == dm_444_16) {
2765                                 Read256BytesBlockHeightY = 8;
2766                         } else {
2767                                 Read256BytesBlockHeightY = 16;
2768                         }
2769                         Read256BytesBlockWidthY = 256 / dml_ceil(BytePerPixDETY, 1)
2770                                         / Read256BytesBlockHeightY;
2771                         Read256BytesBlockHeightC = 0;
2772                         Read256BytesBlockWidthC = 0;
2773                 } else {
2774                         if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
2775                                 Read256BytesBlockHeightY = 1;
2776                                 Read256BytesBlockHeightC = 1;
2777                         } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8) {
2778                                 Read256BytesBlockHeightY = 16;
2779                                 Read256BytesBlockHeightC = 8;
2780                         } else {
2781                                 Read256BytesBlockHeightY = 8;
2782                                 Read256BytesBlockHeightC = 8;
2783                         }
2784                         Read256BytesBlockWidthY = 256 / dml_ceil(BytePerPixDETY, 1)
2785                                         / Read256BytesBlockHeightY;
2786                         Read256BytesBlockWidthC = 256 / dml_ceil(BytePerPixDETC, 2)
2787                                         / Read256BytesBlockHeightC;
2788                 }
2789
2790                 if (mode_lib->vba.SourceScan[k] == dm_horz) {
2791                         MaximumSwathHeightY = Read256BytesBlockHeightY;
2792                         MaximumSwathHeightC = Read256BytesBlockHeightC;
2793                 } else {
2794                         MaximumSwathHeightY = Read256BytesBlockWidthY;
2795                         MaximumSwathHeightC = Read256BytesBlockWidthC;
2796                 }
2797
2798                 if ((mode_lib->vba.SourcePixelFormat[k] == dm_444_64
2799                                 || mode_lib->vba.SourcePixelFormat[k] == dm_444_32
2800                                 || mode_lib->vba.SourcePixelFormat[k] == dm_444_16
2801                                 || mode_lib->vba.SourcePixelFormat[k] == dm_444_8)) {
2802                         if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear
2803                                         || (mode_lib->vba.SourcePixelFormat[k] == dm_444_64
2804                                                         && (mode_lib->vba.SurfaceTiling[k]
2805                                                                         == dm_sw_4kb_s
2806                                                                         || mode_lib->vba.SurfaceTiling[k]
2807                                                                                         == dm_sw_4kb_s_x
2808                                                                         || mode_lib->vba.SurfaceTiling[k]
2809                                                                                         == dm_sw_64kb_s
2810                                                                         || mode_lib->vba.SurfaceTiling[k]
2811                                                                                         == dm_sw_64kb_s_t
2812                                                                         || mode_lib->vba.SurfaceTiling[k]
2813                                                                                         == dm_sw_64kb_s_x
2814                                                                         || mode_lib->vba.SurfaceTiling[k]
2815                                                                                         == dm_sw_var_s
2816                                                                         || mode_lib->vba.SurfaceTiling[k]
2817                                                                                         == dm_sw_var_s_x)
2818                                                         && mode_lib->vba.SourceScan[k] == dm_horz)) {
2819                                 MinimumSwathHeightY = MaximumSwathHeightY;
2820                         } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_8
2821                                         && mode_lib->vba.SourceScan[k] != dm_horz) {
2822                                 MinimumSwathHeightY = MaximumSwathHeightY;
2823                         } else {
2824                                 MinimumSwathHeightY = MaximumSwathHeightY / 2.0;
2825                         }
2826                         MinimumSwathHeightC = MaximumSwathHeightC;
2827                 } else {
2828                         if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
2829                                 MinimumSwathHeightY = MaximumSwathHeightY;
2830                                 MinimumSwathHeightC = MaximumSwathHeightC;
2831                         } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8
2832                                         && mode_lib->vba.SourceScan[k] == dm_horz) {
2833                                 MinimumSwathHeightY = MaximumSwathHeightY / 2.0;
2834                                 MinimumSwathHeightC = MaximumSwathHeightC;
2835                         } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10
2836                                         && mode_lib->vba.SourceScan[k] == dm_horz) {
2837                                 MinimumSwathHeightC = MaximumSwathHeightC / 2.0;
2838                                 MinimumSwathHeightY = MaximumSwathHeightY;
2839                         } else {
2840                                 MinimumSwathHeightY = MaximumSwathHeightY;
2841                                 MinimumSwathHeightC = MaximumSwathHeightC;
2842                         }
2843                 }
2844
2845                 if (mode_lib->vba.SourceScan[k] == dm_horz) {
2846                         SwathWidth = mode_lib->vba.ViewportWidth[k];
2847                 } else {
2848                         SwathWidth = mode_lib->vba.ViewportHeight[k];
2849                 }
2850
2851                 if (mode_lib->vba.ODMCombineEnabled[k] == dm_odm_combine_mode_2to1) {
2852                         MainPlaneDoesODMCombine = true;
2853                 }
2854                 for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) {
2855                         if (mode_lib->vba.BlendingAndTiming[k] == j
2856                                         && mode_lib->vba.ODMCombineEnabled[k] == dm_odm_combine_mode_2to1) {
2857                                 MainPlaneDoesODMCombine = true;
2858                         }
2859                 }
2860
2861                 if (MainPlaneDoesODMCombine == true) {
2862                         SwathWidth = dml_min(
2863                                         SwathWidth,
2864                                         mode_lib->vba.HActive[k] / 2.0 * mode_lib->vba.HRatio[k]);
2865                 } else {
2866                         if (mode_lib->vba.DPPPerPlane[k] == 0)
2867                                 SwathWidth = 0;
2868                         else
2869                                 SwathWidth = SwathWidth / mode_lib->vba.DPPPerPlane[k];
2870                 }
2871
2872                 SwathWidthGranularityY = 256 / dml_ceil(BytePerPixDETY, 1) / MaximumSwathHeightY;
2873                 RoundedUpMaxSwathSizeBytesY = (dml_ceil(
2874                                 (double) (SwathWidth - 1),
2875                                 SwathWidthGranularityY) + SwathWidthGranularityY) * BytePerPixDETY
2876                                 * MaximumSwathHeightY;
2877                 if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10) {
2878                         RoundedUpMaxSwathSizeBytesY = dml_ceil(RoundedUpMaxSwathSizeBytesY, 256)
2879                                         + 256;
2880                 }
2881                 if (MaximumSwathHeightC > 0) {
2882                         SwathWidthGranularityC = 256.0 / dml_ceil(BytePerPixDETC, 2)
2883                                         / MaximumSwathHeightC;
2884                         RoundedUpMaxSwathSizeBytesC = (dml_ceil(
2885                                         (double) (SwathWidth / 2.0 - 1),
2886                                         SwathWidthGranularityC) + SwathWidthGranularityC)
2887                                         * BytePerPixDETC * MaximumSwathHeightC;
2888                         if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10) {
2889                                 RoundedUpMaxSwathSizeBytesC = dml_ceil(
2890                                                 RoundedUpMaxSwathSizeBytesC,
2891                                                 256) + 256;
2892                         }
2893                 } else
2894                         RoundedUpMaxSwathSizeBytesC = 0.0;
2895
2896                 if (RoundedUpMaxSwathSizeBytesY + RoundedUpMaxSwathSizeBytesC
2897                                 <= mode_lib->vba.DETBufferSizeInKByte * 1024.0 / 2.0) {
2898                         mode_lib->vba.SwathHeightY[k] = MaximumSwathHeightY;
2899                         mode_lib->vba.SwathHeightC[k] = MaximumSwathHeightC;
2900                 } else {
2901                         mode_lib->vba.SwathHeightY[k] = MinimumSwathHeightY;
2902                         mode_lib->vba.SwathHeightC[k] = MinimumSwathHeightC;
2903                 }
2904
2905                 if (mode_lib->vba.SwathHeightC[k] == 0) {
2906                         mode_lib->vba.DETBufferSizeY[k] = mode_lib->vba.DETBufferSizeInKByte * 1024;
2907                         mode_lib->vba.DETBufferSizeC[k] = 0;
2908                 } else if (mode_lib->vba.SwathHeightY[k] <= mode_lib->vba.SwathHeightC[k]) {
2909                         mode_lib->vba.DETBufferSizeY[k] = mode_lib->vba.DETBufferSizeInKByte
2910                                         * 1024.0 / 2;
2911                         mode_lib->vba.DETBufferSizeC[k] = mode_lib->vba.DETBufferSizeInKByte
2912                                         * 1024.0 / 2;
2913                 } else {
2914                         mode_lib->vba.DETBufferSizeY[k] = mode_lib->vba.DETBufferSizeInKByte
2915                                         * 1024.0 * 2 / 3;
2916                         mode_lib->vba.DETBufferSizeC[k] = mode_lib->vba.DETBufferSizeInKByte
2917                                         * 1024.0 / 3;
2918                 }
2919         }
2920 }
2921
2922 static double CalculateTWait(
2923                 unsigned int PrefetchMode,
2924                 double DRAMClockChangeLatency,
2925                 double UrgentLatencyPixelDataOnly,
2926                 double SREnterPlusExitTime)
2927 {
2928         if (PrefetchMode == 0) {
2929                 return dml_max(
2930                                 DRAMClockChangeLatency + UrgentLatencyPixelDataOnly,
2931                                 dml_max(SREnterPlusExitTime, UrgentLatencyPixelDataOnly));
2932         } else if (PrefetchMode == 1) {
2933                 return dml_max(SREnterPlusExitTime, UrgentLatencyPixelDataOnly);
2934         } else {
2935                 return UrgentLatencyPixelDataOnly;
2936         }
2937 }
2938
2939 static double CalculateRemoteSurfaceFlipDelay(
2940                 struct display_mode_lib *mode_lib,
2941                 double VRatio,
2942                 double SwathWidth,
2943                 double Bpp,
2944                 double LineTime,
2945                 double XFCTSlvVupdateOffset,
2946                 double XFCTSlvVupdateWidth,
2947                 double XFCTSlvVreadyOffset,
2948                 double XFCXBUFLatencyTolerance,
2949                 double XFCFillBWOverhead,
2950                 double XFCSlvChunkSize,
2951                 double XFCBusTransportTime,
2952                 double TCalc,
2953                 double TWait,
2954                 double *SrcActiveDrainRate,
2955                 double *TInitXFill,
2956                 double *TslvChk)
2957 {
2958         double TSlvSetup, AvgfillRate, result;
2959
2960         *SrcActiveDrainRate = VRatio * SwathWidth * Bpp / LineTime;
2961         TSlvSetup = XFCTSlvVupdateOffset + XFCTSlvVupdateWidth + XFCTSlvVreadyOffset;
2962         *TInitXFill = XFCXBUFLatencyTolerance / (1 + XFCFillBWOverhead / 100);
2963         AvgfillRate = *SrcActiveDrainRate * (1 + XFCFillBWOverhead / 100);
2964         *TslvChk = XFCSlvChunkSize / AvgfillRate;
2965         dml_print(
2966                         "DML::CalculateRemoteSurfaceFlipDelay: SrcActiveDrainRate: %f\n",
2967                         *SrcActiveDrainRate);
2968         dml_print("DML::CalculateRemoteSurfaceFlipDelay: TSlvSetup: %f\n", TSlvSetup);
2969         dml_print("DML::CalculateRemoteSurfaceFlipDelay: TInitXFill: %f\n", *TInitXFill);
2970         dml_print("DML::CalculateRemoteSurfaceFlipDelay: AvgfillRate: %f\n", AvgfillRate);
2971         dml_print("DML::CalculateRemoteSurfaceFlipDelay: TslvChk: %f\n", *TslvChk);
2972         result = 2 * XFCBusTransportTime + TSlvSetup + TCalc + TWait + *TslvChk + *TInitXFill; // TODO: This doesn't seem to match programming guide
2973         dml_print("DML::CalculateRemoteSurfaceFlipDelay: RemoteSurfaceFlipDelay: %f\n", result);
2974         return result;
2975 }
2976
2977 static double CalculateWriteBackDelay(
2978                 enum source_format_class WritebackPixelFormat,
2979                 double WritebackHRatio,
2980                 double WritebackVRatio,
2981                 unsigned int WritebackLumaHTaps,
2982                 unsigned int WritebackLumaVTaps,
2983                 unsigned int WritebackChromaHTaps,
2984                 unsigned int WritebackChromaVTaps,
2985                 unsigned int WritebackDestinationWidth)
2986 {
2987         double CalculateWriteBackDelay =
2988                         dml_max(
2989                                         dml_ceil(WritebackLumaHTaps / 4.0, 1) / WritebackHRatio,
2990                                         WritebackLumaVTaps * dml_ceil(1.0 / WritebackVRatio, 1)
2991                                                         * dml_ceil(
2992                                                                         WritebackDestinationWidth
2993                                                                                         / 4.0,
2994                                                                         1)
2995                                                         + dml_ceil(1.0 / WritebackVRatio, 1)
2996                                                                         * (dml_ceil(
2997                                                                                         WritebackLumaVTaps
2998                                                                                                         / 4.0,
2999                                                                                         1) + 4));
3000
3001         if (WritebackPixelFormat != dm_444_32) {
3002                 CalculateWriteBackDelay =
3003                                 dml_max(
3004                                                 CalculateWriteBackDelay,
3005                                                 dml_max(
3006                                                                 dml_ceil(
3007                                                                                 WritebackChromaHTaps
3008                                                                                                 / 2.0,
3009                                                                                 1)
3010                                                                                 / (2
3011                                                                                                 * WritebackHRatio),
3012                                                                 WritebackChromaVTaps
3013                                                                                 * dml_ceil(
3014                                                                                                 1
3015                                                                                                                 / (2
3016                                                                                                                                 * WritebackVRatio),
3017                                                                                                 1)
3018                                                                                 * dml_ceil(
3019                                                                                                 WritebackDestinationWidth
3020                                                                                                                 / 2.0
3021                                                                                                                 / 2.0,
3022                                                                                                 1)
3023                                                                                 + dml_ceil(
3024                                                                                                 1
3025                                                                                                                 / (2
3026                                                                                                                                 * WritebackVRatio),
3027                                                                                                 1)
3028                                                                                                 * (dml_ceil(
3029                                                                                                                 WritebackChromaVTaps
3030                                                                                                                                 / 4.0,
3031                                                                                                                 1)
3032                                                                                                                 + 4)));
3033         }
3034         return CalculateWriteBackDelay;
3035 }
3036
3037 static void CalculateActiveRowBandwidth(
3038                 bool GPUVMEnable,
3039                 enum source_format_class SourcePixelFormat,
3040                 double VRatio,
3041                 bool DCCEnable,
3042                 double LineTime,
3043                 unsigned int MetaRowByteLuma,
3044                 unsigned int MetaRowByteChroma,
3045                 unsigned int meta_row_height_luma,
3046                 unsigned int meta_row_height_chroma,
3047                 unsigned int PixelPTEBytesPerRowLuma,
3048                 unsigned int PixelPTEBytesPerRowChroma,
3049                 unsigned int dpte_row_height_luma,
3050                 unsigned int dpte_row_height_chroma,
3051                 double *meta_row_bw,
3052                 double *dpte_row_bw,
3053                 double *qual_row_bw)
3054 {
3055         if (DCCEnable != true) {
3056                 *meta_row_bw = 0;
3057         } else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10) {
3058                 *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime)
3059                                 + VRatio / 2 * MetaRowByteChroma
3060                                                 / (meta_row_height_chroma * LineTime);
3061         } else {
3062                 *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime);
3063         }
3064
3065         if (GPUVMEnable != true) {
3066                 *dpte_row_bw = 0;
3067         } else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10) {
3068                 *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime)
3069                                 + VRatio / 2 * PixelPTEBytesPerRowChroma
3070                                                 / (dpte_row_height_chroma * LineTime);
3071         } else {
3072                 *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime);
3073         }
3074
3075         if ((SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10)) {
3076                 *qual_row_bw = *meta_row_bw + *dpte_row_bw;
3077         } else {
3078                 *qual_row_bw = 0;
3079         }
3080 }
3081
3082 static void CalculateFlipSchedule(
3083                 struct display_mode_lib *mode_lib,
3084                 double UrgentExtraLatency,
3085                 double UrgentLatencyPixelDataOnly,
3086                 unsigned int GPUVMMaxPageTableLevels,
3087                 bool GPUVMEnable,
3088                 double BandwidthAvailableForImmediateFlip,
3089                 unsigned int TotImmediateFlipBytes,
3090                 enum source_format_class SourcePixelFormat,
3091                 unsigned int ImmediateFlipBytes,
3092                 double LineTime,
3093                 double VRatio,
3094                 double Tno_bw,
3095                 double PDEAndMetaPTEBytesFrame,
3096                 unsigned int MetaRowByte,
3097                 unsigned int PixelPTEBytesPerRow,
3098                 bool DCCEnable,
3099                 unsigned int dpte_row_height,
3100                 unsigned int meta_row_height,
3101                 double qual_row_bw,
3102                 double *DestinationLinesToRequestVMInImmediateFlip,
3103                 double *DestinationLinesToRequestRowInImmediateFlip,
3104                 double *final_flip_bw,
3105                 bool *ImmediateFlipSupportedForPipe)
3106 {
3107         double min_row_time = 0.0;
3108
3109         if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10) {
3110                 *DestinationLinesToRequestVMInImmediateFlip = 0.0;
3111                 *DestinationLinesToRequestRowInImmediateFlip = 0.0;
3112                 *final_flip_bw = qual_row_bw;
3113                 *ImmediateFlipSupportedForPipe = true;
3114         } else {
3115                 double TimeForFetchingMetaPTEImmediateFlip;
3116                 double TimeForFetchingRowInVBlankImmediateFlip;
3117
3118                 if (GPUVMEnable == true) {
3119                         mode_lib->vba.ImmediateFlipBW[0] = BandwidthAvailableForImmediateFlip
3120                                         * ImmediateFlipBytes / TotImmediateFlipBytes;
3121                         TimeForFetchingMetaPTEImmediateFlip =
3122                                         dml_max(
3123                                                         Tno_bw
3124                                                                         + PDEAndMetaPTEBytesFrame
3125                                                                                         / mode_lib->vba.ImmediateFlipBW[0],
3126                                                         dml_max(
3127                                                                         UrgentExtraLatency
3128                                                                                         + UrgentLatencyPixelDataOnly
3129                                                                                                         * (GPUVMMaxPageTableLevels
3130                                                                                                                         - 1),
3131                                                                         LineTime / 4.0));
3132                 } else {
3133                         TimeForFetchingMetaPTEImmediateFlip = 0;
3134                 }
3135
3136                 *DestinationLinesToRequestVMInImmediateFlip = dml_floor(
3137                                 4.0 * (TimeForFetchingMetaPTEImmediateFlip / LineTime + 0.125),
3138                                 1) / 4.0;
3139
3140                 if ((GPUVMEnable == true || DCCEnable == true)) {
3141                         mode_lib->vba.ImmediateFlipBW[0] = BandwidthAvailableForImmediateFlip
3142                                         * ImmediateFlipBytes / TotImmediateFlipBytes;
3143                         TimeForFetchingRowInVBlankImmediateFlip = dml_max(
3144                                         (MetaRowByte + PixelPTEBytesPerRow)
3145                                                         / mode_lib->vba.ImmediateFlipBW[0],
3146                                         dml_max(UrgentLatencyPixelDataOnly, LineTime / 4.0));
3147                 } else {
3148                         TimeForFetchingRowInVBlankImmediateFlip = 0;
3149                 }
3150
3151                 *DestinationLinesToRequestRowInImmediateFlip = dml_floor(
3152                                 4.0 * (TimeForFetchingRowInVBlankImmediateFlip / LineTime + 0.125),
3153                                 1) / 4.0;
3154
3155                 if (GPUVMEnable == true) {
3156                         *final_flip_bw =
3157                                         dml_max(
3158                                                         PDEAndMetaPTEBytesFrame
3159                                                                         / (*DestinationLinesToRequestVMInImmediateFlip
3160                                                                                         * LineTime),
3161                                                         (MetaRowByte + PixelPTEBytesPerRow)
3162                                                                         / (TimeForFetchingRowInVBlankImmediateFlip
3163                                                                                         * LineTime));
3164                 } else if (MetaRowByte + PixelPTEBytesPerRow > 0) {
3165                         *final_flip_bw = (MetaRowByte + PixelPTEBytesPerRow)
3166                                         / (TimeForFetchingRowInVBlankImmediateFlip * LineTime);
3167                 } else {
3168                         *final_flip_bw = 0;
3169                 }
3170
3171                 if (GPUVMEnable && !DCCEnable)
3172                         min_row_time = dpte_row_height * LineTime / VRatio;
3173                 else if (!GPUVMEnable && DCCEnable)
3174                         min_row_time = meta_row_height * LineTime / VRatio;
3175                 else
3176                         min_row_time = dml_min(dpte_row_height, meta_row_height) * LineTime
3177                                         / VRatio;
3178
3179                 if (*DestinationLinesToRequestVMInImmediateFlip >= 8
3180                                 || *DestinationLinesToRequestRowInImmediateFlip >= 16
3181                                 || TimeForFetchingMetaPTEImmediateFlip
3182                                                 + 2 * TimeForFetchingRowInVBlankImmediateFlip
3183                                                 > min_row_time)
3184                         *ImmediateFlipSupportedForPipe = false;
3185                 else
3186                         *ImmediateFlipSupportedForPipe = true;
3187         }
3188 }
3189
3190 static unsigned int TruncToValidBPP(
3191                 double DecimalBPP,
3192                 bool DSCEnabled,
3193                 enum output_encoder_class Output,
3194                 enum output_format_class Format,
3195                 unsigned int DSCInputBitPerComponent)
3196 {
3197         if (Output == dm_hdmi) {
3198                 if (Format == dm_420) {
3199                         if (DecimalBPP >= 18)
3200                                 return 18;
3201                         else if (DecimalBPP >= 15)
3202                                 return 15;
3203                         else if (DecimalBPP >= 12)
3204                                 return 12;
3205                         else
3206                                 return BPP_INVALID;
3207                 } else if (Format == dm_444) {
3208                         if (DecimalBPP >= 36)
3209                                 return 36;
3210                         else if (DecimalBPP >= 30)
3211                                 return 30;
3212                         else if (DecimalBPP >= 24)
3213                                 return 24;
3214                         else if (DecimalBPP >= 18)
3215                                 return 18;
3216                         else
3217                                 return BPP_INVALID;
3218                 } else {
3219                         if (DecimalBPP / 1.5 >= 24)
3220                                 return 24;
3221                         else if (DecimalBPP / 1.5 >= 20)
3222                                 return 20;
3223                         else if (DecimalBPP / 1.5 >= 16)
3224                                 return 16;
3225                         else
3226                                 return BPP_INVALID;
3227                 }
3228         } else {
3229                 if (DSCEnabled) {
3230                         if (Format == dm_420) {
3231                                 if (DecimalBPP < 6)
3232                                         return BPP_INVALID;
3233                                 else if (DecimalBPP >= 1.5 * DSCInputBitPerComponent - 1 / 16)
3234                                         return 1.5 * DSCInputBitPerComponent - 1 / 16;
3235                                 else
3236                                         return dml_floor(16 * DecimalBPP, 1) / 16;
3237                         } else if (Format == dm_n422) {
3238                                 if (DecimalBPP < 7)
3239                                         return BPP_INVALID;
3240                                 else if (DecimalBPP >= 2 * DSCInputBitPerComponent - 1 / 16)
3241                                         return 2 * DSCInputBitPerComponent - 1 / 16;
3242                                 else
3243                                         return dml_floor(16 * DecimalBPP, 1) / 16;
3244                         } else {
3245                                 if (DecimalBPP < 8)
3246                                         return BPP_INVALID;
3247                                 else if (DecimalBPP >= 3 * DSCInputBitPerComponent - 1 / 16)
3248                                         return 3 * DSCInputBitPerComponent - 1 / 16;
3249                                 else
3250                                         return dml_floor(16 * DecimalBPP, 1) / 16;
3251                         }
3252                 } else if (Format == dm_420) {
3253                         if (DecimalBPP >= 18)
3254                                 return 18;
3255                         else if (DecimalBPP >= 15)
3256                                 return 15;
3257                         else if (DecimalBPP >= 12)
3258                                 return 12;
3259                         else
3260                                 return BPP_INVALID;
3261                 } else if (Format == dm_s422 || Format == dm_n422) {
3262                         if (DecimalBPP >= 24)
3263                                 return 24;
3264                         else if (DecimalBPP >= 20)
3265                                 return 20;
3266                         else if (DecimalBPP >= 16)
3267                                 return 16;
3268                         else
3269                                 return BPP_INVALID;
3270                 } else {
3271                         if (DecimalBPP >= 36)
3272                                 return 36;
3273                         else if (DecimalBPP >= 30)
3274                                 return 30;
3275                         else if (DecimalBPP >= 24)
3276                                 return 24;
3277                         else if (DecimalBPP >= 18)
3278                                 return 18;
3279                         else
3280                                 return BPP_INVALID;
3281                 }
3282         }
3283 }
3284
3285 void dml20_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_lib)
3286 {
3287         struct vba_vars_st *locals = &mode_lib->vba;
3288
3289         int i;
3290         unsigned int j, k, m;
3291
3292         /*MODE SUPPORT, VOLTAGE STATE AND SOC CONFIGURATION*/
3293
3294         /*Scale Ratio, taps Support Check*/
3295
3296         mode_lib->vba.ScaleRatioAndTapsSupport = true;
3297         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3298                 if (mode_lib->vba.ScalerEnabled[k] == false
3299                                 && ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64
3300                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
3301                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
3302                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
3303                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8)
3304                                                 || mode_lib->vba.HRatio[k] != 1.0
3305                                                 || mode_lib->vba.htaps[k] != 1.0
3306                                                 || mode_lib->vba.VRatio[k] != 1.0
3307                                                 || mode_lib->vba.vtaps[k] != 1.0)) {
3308                         mode_lib->vba.ScaleRatioAndTapsSupport = false;
3309                 } else if (mode_lib->vba.vtaps[k] < 1.0 || mode_lib->vba.vtaps[k] > 8.0
3310                                 || mode_lib->vba.htaps[k] < 1.0 || mode_lib->vba.htaps[k] > 8.0
3311                                 || (mode_lib->vba.htaps[k] > 1.0
3312                                                 && (mode_lib->vba.htaps[k] % 2) == 1)
3313                                 || mode_lib->vba.HRatio[k] > mode_lib->vba.MaxHSCLRatio
3314                                 || mode_lib->vba.VRatio[k] > mode_lib->vba.MaxVSCLRatio
3315                                 || mode_lib->vba.HRatio[k] > mode_lib->vba.htaps[k]
3316                                 || mode_lib->vba.VRatio[k] > mode_lib->vba.vtaps[k]
3317                                 || (mode_lib->vba.SourcePixelFormat[k] != dm_444_64
3318                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
3319                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
3320                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
3321                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8
3322                                                 && (mode_lib->vba.HRatio[k] / 2.0
3323                                                                 > mode_lib->vba.HTAPsChroma[k]
3324                                                                 || mode_lib->vba.VRatio[k] / 2.0
3325                                                                                 > mode_lib->vba.VTAPsChroma[k]))) {
3326                         mode_lib->vba.ScaleRatioAndTapsSupport = false;
3327                 }
3328         }
3329         /*Source Format, Pixel Format and Scan Support Check*/
3330
3331         mode_lib->vba.SourceFormatPixelAndScanSupport = true;
3332         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3333                 if ((mode_lib->vba.SurfaceTiling[k] == dm_sw_linear
3334                                 && mode_lib->vba.SourceScan[k] != dm_horz)
3335                                 || ((mode_lib->vba.SurfaceTiling[k] == dm_sw_4kb_d
3336                                                 || mode_lib->vba.SurfaceTiling[k] == dm_sw_4kb_d_x
3337                                                 || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d
3338                                                 || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d_t
3339                                                 || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d_x
3340                                                 || mode_lib->vba.SurfaceTiling[k] == dm_sw_var_d
3341                                                 || mode_lib->vba.SurfaceTiling[k] == dm_sw_var_d_x)
3342                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_64)
3343                                 || (mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_r_x
3344                                                 && (mode_lib->vba.SourcePixelFormat[k] == dm_mono_8
3345                                                                 || mode_lib->vba.SourcePixelFormat[k]
3346                                                                                 == dm_420_8
3347                                                                 || mode_lib->vba.SourcePixelFormat[k]
3348                                                                                 == dm_420_10))
3349                                 || (((mode_lib->vba.SurfaceTiling[k] == dm_sw_gfx7_2d_thin_gl
3350                                                 || mode_lib->vba.SurfaceTiling[k]
3351                                                                 == dm_sw_gfx7_2d_thin_l_vp)
3352                                                 && !((mode_lib->vba.SourcePixelFormat[k]
3353                                                                 == dm_444_64
3354                                                                 || mode_lib->vba.SourcePixelFormat[k]
3355                                                                                 == dm_444_32)
3356                                                                 && mode_lib->vba.SourceScan[k]
3357                                                                                 == dm_horz
3358                                                                 && mode_lib->vba.SupportGFX7CompatibleTilingIn32bppAnd64bpp
3359                                                                                 == true
3360                                                                 && mode_lib->vba.DCCEnable[k]
3361                                                                                 == false))
3362                                                 || (mode_lib->vba.DCCEnable[k] == true
3363                                                                 && (mode_lib->vba.SurfaceTiling[k]
3364                                                                                 == dm_sw_linear
3365                                                                                 || mode_lib->vba.SourcePixelFormat[k]
3366                                                                                                 == dm_420_8
3367                                                                                 || mode_lib->vba.SourcePixelFormat[k]
3368                                                                                                 == dm_420_10)))) {
3369                         mode_lib->vba.SourceFormatPixelAndScanSupport = false;
3370                 }
3371         }
3372         /*Bandwidth Support Check*/
3373
3374         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3375                 if (mode_lib->vba.SourcePixelFormat[k] == dm_444_64) {
3376                         locals->BytePerPixelInDETY[k] = 8.0;
3377                         locals->BytePerPixelInDETC[k] = 0.0;
3378                 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_32) {
3379                         locals->BytePerPixelInDETY[k] = 4.0;
3380                         locals->BytePerPixelInDETC[k] = 0.0;
3381                 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_16
3382                                 || mode_lib->vba.SourcePixelFormat[k] == dm_mono_16) {
3383                         locals->BytePerPixelInDETY[k] = 2.0;
3384                         locals->BytePerPixelInDETC[k] = 0.0;
3385                 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_mono_8) {
3386                         locals->BytePerPixelInDETY[k] = 1.0;
3387                         locals->BytePerPixelInDETC[k] = 0.0;
3388                 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8) {
3389                         locals->BytePerPixelInDETY[k] = 1.0;
3390                         locals->BytePerPixelInDETC[k] = 2.0;
3391                 } else {
3392                         locals->BytePerPixelInDETY[k] = 4.0 / 3;
3393                         locals->BytePerPixelInDETC[k] = 8.0 / 3;
3394                 }
3395                 if (mode_lib->vba.SourceScan[k] == dm_horz) {
3396                         locals->SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportWidth[k];
3397                 } else {
3398                         locals->SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportHeight[k];
3399                 }
3400         }
3401         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3402                 locals->ReadBandwidthLuma[k] = locals->SwathWidthYSingleDPP[k] * dml_ceil(locals->BytePerPixelInDETY[k], 1.0)
3403                                 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k];
3404                 locals->ReadBandwidthChroma[k] = locals->SwathWidthYSingleDPP[k] / 2 * dml_ceil(locals->BytePerPixelInDETC[k], 2.0)
3405                                 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k] / 2.0;
3406                 locals->ReadBandwidth[k] = locals->ReadBandwidthLuma[k] + locals->ReadBandwidthChroma[k];
3407         }
3408         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3409                 if (mode_lib->vba.WritebackEnable[k] == true
3410                                 && mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) {
3411                         locals->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k]
3412                                         * mode_lib->vba.WritebackDestinationHeight[k]
3413                                         / (mode_lib->vba.WritebackSourceHeight[k]
3414                                                         * mode_lib->vba.HTotal[k]
3415                                                         / mode_lib->vba.PixelClock[k]) * 4.0;
3416                 } else if (mode_lib->vba.WritebackEnable[k] == true
3417                                 && mode_lib->vba.WritebackPixelFormat[k] == dm_420_10) {
3418                         locals->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k]
3419                                         * mode_lib->vba.WritebackDestinationHeight[k]
3420                                         / (mode_lib->vba.WritebackSourceHeight[k]
3421                                                         * mode_lib->vba.HTotal[k]
3422                                                         / mode_lib->vba.PixelClock[k]) * 3.0;
3423                 } else if (mode_lib->vba.WritebackEnable[k] == true) {
3424                         locals->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k]
3425                                         * mode_lib->vba.WritebackDestinationHeight[k]
3426                                         / (mode_lib->vba.WritebackSourceHeight[k]
3427                                                         * mode_lib->vba.HTotal[k]
3428                                                         / mode_lib->vba.PixelClock[k]) * 1.5;
3429                 } else {
3430                         locals->WriteBandwidth[k] = 0.0;
3431                 }
3432         }
3433         mode_lib->vba.DCCEnabledInAnyPlane = false;
3434         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3435                 if (mode_lib->vba.DCCEnable[k] == true) {
3436                         mode_lib->vba.DCCEnabledInAnyPlane = true;
3437                 }
3438         }
3439         for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
3440                 locals->FabricAndDRAMBandwidthPerState[i] = dml_min(
3441                                 mode_lib->vba.DRAMSpeedPerState[i] * mode_lib->vba.NumberOfChannels
3442                                                 * mode_lib->vba.DRAMChannelWidth,
3443                                 mode_lib->vba.FabricClockPerState[i]
3444                                                 * mode_lib->vba.FabricDatapathToDCNDataReturn) / 1000;
3445                 locals->ReturnBWToDCNPerState = dml_min(locals->ReturnBusWidth * locals->DCFCLKPerState[i],
3446                                 locals->FabricAndDRAMBandwidthPerState[i] * 1000)
3447                                 * locals->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly / 100;
3448
3449                 locals->ReturnBWPerState[i][0] = locals->ReturnBWToDCNPerState;
3450
3451                 if (locals->DCCEnabledInAnyPlane == true && locals->ReturnBWToDCNPerState > locals->DCFCLKPerState[i] * locals->ReturnBusWidth / 4) {
3452                         locals->ReturnBWPerState[i][0] = dml_min(locals->ReturnBWPerState[i][0],
3453                                         locals->ReturnBWToDCNPerState * 4 * (1 - locals->UrgentLatency /
3454                                         ((locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024
3455                                         / (locals->ReturnBWToDCNPerState - locals->DCFCLKPerState[i]
3456                                         * locals->ReturnBusWidth / 4) + locals->UrgentLatency)));
3457                 }
3458                 locals->CriticalPoint = 2 * locals->ReturnBusWidth * locals->DCFCLKPerState[i] *
3459                                 locals->UrgentLatency / (locals->ReturnBWToDCNPerState * locals->UrgentLatency
3460                                 + (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024);
3461
3462                 if (locals->DCCEnabledInAnyPlane && locals->CriticalPoint > 1 && locals->CriticalPoint < 4) {
3463                         locals->ReturnBWPerState[i][0] = dml_min(locals->ReturnBWPerState[i][0],
3464                                 4 * locals->ReturnBWToDCNPerState *
3465                                 (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024
3466                                 * locals->ReturnBusWidth * locals->DCFCLKPerState[i] * locals->UrgentLatency /
3467                                 dml_pow((locals->ReturnBWToDCNPerState * locals->UrgentLatency
3468                                 + (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024), 2));
3469                 }
3470
3471                 locals->ReturnBWToDCNPerState = dml_min(locals->ReturnBusWidth *
3472                                 locals->DCFCLKPerState[i], locals->FabricAndDRAMBandwidthPerState[i] * 1000);
3473
3474                 if (locals->DCCEnabledInAnyPlane == true && locals->ReturnBWToDCNPerState > locals->DCFCLKPerState[i] * locals->ReturnBusWidth / 4) {
3475                         locals->ReturnBWPerState[i][0] = dml_min(locals->ReturnBWPerState[i][0],
3476                                         locals->ReturnBWToDCNPerState * 4 * (1 - locals->UrgentLatency /
3477                                         ((locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024
3478                                         / (locals->ReturnBWToDCNPerState - locals->DCFCLKPerState[i]
3479                                         * locals->ReturnBusWidth / 4) + locals->UrgentLatency)));
3480                 }
3481                 locals->CriticalPoint = 2 * locals->ReturnBusWidth * locals->DCFCLKPerState[i] *
3482                                 locals->UrgentLatency / (locals->ReturnBWToDCNPerState * locals->UrgentLatency
3483                                 + (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024);
3484
3485                 if (locals->DCCEnabledInAnyPlane && locals->CriticalPoint > 1 && locals->CriticalPoint < 4) {
3486                         locals->ReturnBWPerState[i][0] = dml_min(locals->ReturnBWPerState[i][0],
3487                                 4 * locals->ReturnBWToDCNPerState *
3488                                 (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024
3489                                 * locals->ReturnBusWidth * locals->DCFCLKPerState[i] * locals->UrgentLatency /
3490                                 dml_pow((locals->ReturnBWToDCNPerState * locals->UrgentLatency
3491                                 + (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024), 2));
3492                 }
3493         }
3494         /*Writeback Latency support check*/
3495
3496         mode_lib->vba.WritebackLatencySupport = true;
3497         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3498                 if (mode_lib->vba.WritebackEnable[k] == true) {
3499                         if (mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) {
3500                                 if (locals->WriteBandwidth[k]
3501                                                 > (mode_lib->vba.WritebackInterfaceLumaBufferSize
3502                                                                 + mode_lib->vba.WritebackInterfaceChromaBufferSize)
3503                                                                 / mode_lib->vba.WritebackLatency) {
3504                                         mode_lib->vba.WritebackLatencySupport = false;
3505                                 }
3506                         } else {
3507                                 if (locals->WriteBandwidth[k]
3508                                                 > 1.5
3509                                                                 * dml_min(
3510                                                                                 mode_lib->vba.WritebackInterfaceLumaBufferSize,
3511                                                                                 2.0
3512                                                                                                 * mode_lib->vba.WritebackInterfaceChromaBufferSize)
3513                                                                 / mode_lib->vba.WritebackLatency) {
3514                                         mode_lib->vba.WritebackLatencySupport = false;
3515                                 }
3516                         }
3517                 }
3518         }
3519         /*Re-ordering Buffer Support Check*/
3520
3521         for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
3522                 locals->UrgentRoundTripAndOutOfOrderLatencyPerState[i] =
3523                                 (mode_lib->vba.RoundTripPingLatencyCycles + 32.0) / mode_lib->vba.DCFCLKPerState[i]
3524                                 + locals->UrgentOutOfOrderReturnPerChannel * mode_lib->vba.NumberOfChannels / locals->ReturnBWPerState[i][0];
3525                 if ((mode_lib->vba.ROBBufferSizeInKByte - mode_lib->vba.PixelChunkSizeInKByte) * 1024.0 / locals->ReturnBWPerState[i][0]
3526                                 > locals->UrgentRoundTripAndOutOfOrderLatencyPerState[i]) {
3527                         locals->ROBSupport[i][0] = true;
3528                 } else {
3529                         locals->ROBSupport[i][0] = false;
3530                 }
3531         }
3532         /*Writeback Mode Support Check*/
3533
3534         mode_lib->vba.TotalNumberOfActiveWriteback = 0;
3535         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3536                 if (mode_lib->vba.WritebackEnable[k] == true) {
3537                         if (mode_lib->vba.ActiveWritebacksPerPlane[k] == 0)
3538                                 mode_lib->vba.ActiveWritebacksPerPlane[k] = 1;
3539                         mode_lib->vba.TotalNumberOfActiveWriteback =
3540                                         mode_lib->vba.TotalNumberOfActiveWriteback
3541                                                         + mode_lib->vba.ActiveWritebacksPerPlane[k];
3542                 }
3543         }
3544         mode_lib->vba.WritebackModeSupport = true;
3545         if (mode_lib->vba.TotalNumberOfActiveWriteback > mode_lib->vba.MaxNumWriteback) {
3546                 mode_lib->vba.WritebackModeSupport = false;
3547         }
3548         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3549                 if (mode_lib->vba.WritebackEnable[k] == true
3550                                 && mode_lib->vba.Writeback10bpc420Supported != true
3551                                 && mode_lib->vba.WritebackPixelFormat[k] == dm_420_10) {
3552                         mode_lib->vba.WritebackModeSupport = false;
3553                 }
3554         }
3555         /*Writeback Scale Ratio and Taps Support Check*/
3556
3557         mode_lib->vba.WritebackScaleRatioAndTapsSupport = true;
3558         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3559                 if (mode_lib->vba.WritebackEnable[k] == true) {
3560                         if (mode_lib->vba.WritebackLumaAndChromaScalingSupported == false
3561                                         && (mode_lib->vba.WritebackHRatio[k] != 1.0
3562                                                         || mode_lib->vba.WritebackVRatio[k] != 1.0)) {
3563                                 mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
3564                         }
3565                         if (mode_lib->vba.WritebackHRatio[k] > mode_lib->vba.WritebackMaxHSCLRatio
3566                                         || mode_lib->vba.WritebackVRatio[k]
3567                                                         > mode_lib->vba.WritebackMaxVSCLRatio
3568                                         || mode_lib->vba.WritebackHRatio[k]
3569                                                         < mode_lib->vba.WritebackMinHSCLRatio
3570                                         || mode_lib->vba.WritebackVRatio[k]
3571                                                         < mode_lib->vba.WritebackMinVSCLRatio
3572                                         || mode_lib->vba.WritebackLumaHTaps[k]
3573                                                         > mode_lib->vba.WritebackMaxHSCLTaps
3574                                         || mode_lib->vba.WritebackLumaVTaps[k]
3575                                                         > mode_lib->vba.WritebackMaxVSCLTaps
3576                                         || mode_lib->vba.WritebackHRatio[k]
3577                                                         > mode_lib->vba.WritebackLumaHTaps[k]
3578                                         || mode_lib->vba.WritebackVRatio[k]
3579                                                         > mode_lib->vba.WritebackLumaVTaps[k]
3580                                         || (mode_lib->vba.WritebackLumaHTaps[k] > 2.0
3581                                                         && ((mode_lib->vba.WritebackLumaHTaps[k] % 2)
3582                                                                         == 1))
3583                                         || (mode_lib->vba.WritebackPixelFormat[k] != dm_444_32
3584                                                         && (mode_lib->vba.WritebackChromaHTaps[k]
3585                                                                         > mode_lib->vba.WritebackMaxHSCLTaps
3586                                                                         || mode_lib->vba.WritebackChromaVTaps[k]
3587                                                                                         > mode_lib->vba.WritebackMaxVSCLTaps
3588                                                                         || 2.0
3589                                                                                         * mode_lib->vba.WritebackHRatio[k]
3590                                                                                         > mode_lib->vba.WritebackChromaHTaps[k]
3591                                                                         || 2.0
3592                                                                                         * mode_lib->vba.WritebackVRatio[k]
3593                                                                                         > mode_lib->vba.WritebackChromaVTaps[k]
3594                                                                         || (mode_lib->vba.WritebackChromaHTaps[k] > 2.0
3595                                                                                 && ((mode_lib->vba.WritebackChromaHTaps[k] % 2) == 1))))) {
3596                                 mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
3597                         }
3598                         if (mode_lib->vba.WritebackVRatio[k] < 1.0) {
3599                                 mode_lib->vba.WritebackLumaVExtra =
3600                                                 dml_max(1.0 - 2.0 / dml_ceil(1.0 / mode_lib->vba.WritebackVRatio[k], 1.0), 0.0);
3601                         } else {
3602                                 mode_lib->vba.WritebackLumaVExtra = -1;
3603                         }
3604                         if ((mode_lib->vba.WritebackPixelFormat[k] == dm_444_32
3605                                         && mode_lib->vba.WritebackLumaVTaps[k]
3606                                                         > (mode_lib->vba.WritebackLineBufferLumaBufferSize
3607                                                                         + mode_lib->vba.WritebackLineBufferChromaBufferSize)
3608                                                                         / 3.0
3609                                                                         / mode_lib->vba.WritebackDestinationWidth[k]
3610                                                                         - mode_lib->vba.WritebackLumaVExtra)
3611                                         || (mode_lib->vba.WritebackPixelFormat[k] == dm_420_8
3612                                                         && mode_lib->vba.WritebackLumaVTaps[k]
3613                                                                         > mode_lib->vba.WritebackLineBufferLumaBufferSize
3614                                                                                         * 8.0 / 10.0 / mode_lib->vba.WritebackDestinationWidth[k]
3615                                                                                         - mode_lib->vba.WritebackLumaVExtra)
3616                                         || (mode_lib->vba.WritebackPixelFormat[k] == dm_420_10
3617                                                         && mode_lib->vba.WritebackLumaVTaps[k]
3618                                                                         > mode_lib->vba.WritebackLineBufferLumaBufferSize
3619                                                                                         * 8.0 / 10.0
3620                                                                                         / mode_lib->vba.WritebackDestinationWidth[k]
3621                                                                                         - mode_lib->vba.WritebackLumaVExtra)) {
3622                                 mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
3623                         }
3624                         if (2.0 * mode_lib->vba.WritebackVRatio[k] < 1) {
3625                                 mode_lib->vba.WritebackChromaVExtra = 0.0;
3626                         } else {
3627                                 mode_lib->vba.WritebackChromaVExtra = -1;
3628                         }
3629                         if ((mode_lib->vba.WritebackPixelFormat[k] == dm_420_8
3630                                         && mode_lib->vba.WritebackChromaVTaps[k]
3631                                                         > mode_lib->vba.WritebackLineBufferChromaBufferSize
3632                                                                         * 8.0 / 10.0 / mode_lib->vba.WritebackDestinationWidth[k]
3633                                                                         - mode_lib->vba.WritebackChromaVExtra)
3634                                         || (mode_lib->vba.WritebackPixelFormat[k] == dm_420_10
3635                                                         && mode_lib->vba.WritebackChromaVTaps[k]
3636                                                                         > mode_lib->vba.WritebackLineBufferChromaBufferSize
3637                                                                                         * 8.0 / 10.0
3638                                                                                         / mode_lib->vba.WritebackDestinationWidth[k]
3639                                                                                         - mode_lib->vba.WritebackChromaVExtra)) {
3640                                 mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
3641                         }
3642                 }
3643         }
3644         /*Maximum DISPCLK/DPPCLK Support check*/
3645
3646         mode_lib->vba.WritebackRequiredDISPCLK = 0.0;
3647         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3648                 if (mode_lib->vba.WritebackEnable[k] == true) {
3649                         mode_lib->vba.WritebackRequiredDISPCLK =
3650                                         dml_max(
3651                                                         mode_lib->vba.WritebackRequiredDISPCLK,
3652                                                         CalculateWriteBackDISPCLK(
3653                                                                         mode_lib->vba.WritebackPixelFormat[k],
3654                                                                         mode_lib->vba.PixelClock[k],
3655                                                                         mode_lib->vba.WritebackHRatio[k],
3656                                                                         mode_lib->vba.WritebackVRatio[k],
3657                                                                         mode_lib->vba.WritebackLumaHTaps[k],
3658                                                                         mode_lib->vba.WritebackLumaVTaps[k],
3659                                                                         mode_lib->vba.WritebackChromaHTaps[k],
3660                                                                         mode_lib->vba.WritebackChromaVTaps[k],
3661                                                                         mode_lib->vba.WritebackDestinationWidth[k],
3662                                                                         mode_lib->vba.HTotal[k],
3663                                                                         mode_lib->vba.WritebackChromaLineBufferWidth));
3664                 }
3665         }
3666         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3667                 if (mode_lib->vba.HRatio[k] > 1.0) {
3668                         locals->PSCL_FACTOR[k] = dml_min(
3669                                         mode_lib->vba.MaxDCHUBToPSCLThroughput,
3670                                         mode_lib->vba.MaxPSCLToLBThroughput
3671                                                         * mode_lib->vba.HRatio[k]
3672                                                         / dml_ceil(
3673                                                                         mode_lib->vba.htaps[k]
3674                                                                                         / 6.0,
3675                                                                         1.0));
3676                 } else {
3677                         locals->PSCL_FACTOR[k] = dml_min(
3678                                         mode_lib->vba.MaxDCHUBToPSCLThroughput,
3679                                         mode_lib->vba.MaxPSCLToLBThroughput);
3680                 }
3681                 if (locals->BytePerPixelInDETC[k] == 0.0) {
3682                         locals->PSCL_FACTOR_CHROMA[k] = 0.0;
3683                         locals->MinDPPCLKUsingSingleDPP[k] =
3684                                         mode_lib->vba.PixelClock[k]
3685                                                         * dml_max3(
3686                                                                         mode_lib->vba.vtaps[k] / 6.0
3687                                                                                         * dml_min(
3688                                                                                                         1.0,
3689                                                                                                         mode_lib->vba.HRatio[k]),
3690                                                                         mode_lib->vba.HRatio[k]
3691                                                                                         * mode_lib->vba.VRatio[k]
3692                                                                                         / locals->PSCL_FACTOR[k],
3693                                                                         1.0);
3694                         if ((mode_lib->vba.htaps[k] > 6.0 || mode_lib->vba.vtaps[k] > 6.0)
3695                                         && locals->MinDPPCLKUsingSingleDPP[k]
3696                                                         < 2.0 * mode_lib->vba.PixelClock[k]) {
3697                                 locals->MinDPPCLKUsingSingleDPP[k] = 2.0
3698                                                 * mode_lib->vba.PixelClock[k];
3699                         }
3700                 } else {
3701                         if (mode_lib->vba.HRatio[k] / 2.0 > 1.0) {
3702                                 locals->PSCL_FACTOR_CHROMA[k] =
3703                                                 dml_min(
3704                                                                 mode_lib->vba.MaxDCHUBToPSCLThroughput,
3705                                                                 mode_lib->vba.MaxPSCLToLBThroughput
3706                                                                                 * mode_lib->vba.HRatio[k]
3707                                                                                 / 2.0
3708                                                                                 / dml_ceil(
3709                                                                                                 mode_lib->vba.HTAPsChroma[k]
3710                                                                                                                 / 6.0,
3711                                                                                                 1.0));
3712                         } else {
3713                                 locals->PSCL_FACTOR_CHROMA[k] = dml_min(
3714                                                 mode_lib->vba.MaxDCHUBToPSCLThroughput,
3715                                                 mode_lib->vba.MaxPSCLToLBThroughput);
3716                         }
3717                         locals->MinDPPCLKUsingSingleDPP[k] =
3718                                         mode_lib->vba.PixelClock[k]
3719                                                         * dml_max5(
3720                                                                         mode_lib->vba.vtaps[k] / 6.0
3721                                                                                         * dml_min(
3722                                                                                                         1.0,
3723                                                                                                         mode_lib->vba.HRatio[k]),
3724                                                                         mode_lib->vba.HRatio[k]
3725                                                                                         * mode_lib->vba.VRatio[k]
3726                                                                                         / locals->PSCL_FACTOR[k],
3727                                                                         mode_lib->vba.VTAPsChroma[k]
3728                                                                                         / 6.0
3729                                                                                         * dml_min(
3730                                                                                                         1.0,
3731                                                                                                         mode_lib->vba.HRatio[k]
3732                                                                                                                         / 2.0),
3733                                                                         mode_lib->vba.HRatio[k]
3734                                                                                         * mode_lib->vba.VRatio[k]
3735                                                                                         / 4.0
3736                                                                                         / locals->PSCL_FACTOR_CHROMA[k],
3737                                                                         1.0);
3738                         if ((mode_lib->vba.htaps[k] > 6.0 || mode_lib->vba.vtaps[k] > 6.0
3739                                         || mode_lib->vba.HTAPsChroma[k] > 6.0
3740                                         || mode_lib->vba.VTAPsChroma[k] > 6.0)
3741                                         && locals->MinDPPCLKUsingSingleDPP[k]
3742                                                         < 2.0 * mode_lib->vba.PixelClock[k]) {
3743                                 locals->MinDPPCLKUsingSingleDPP[k] = 2.0
3744                                                 * mode_lib->vba.PixelClock[k];
3745                         }
3746                 }
3747         }
3748         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3749                 Calculate256BBlockSizes(
3750                                 mode_lib->vba.SourcePixelFormat[k],
3751                                 mode_lib->vba.SurfaceTiling[k],
3752                                 dml_ceil(locals->BytePerPixelInDETY[k], 1.0),
3753                                 dml_ceil(locals->BytePerPixelInDETC[k], 2.0),
3754                                 &locals->Read256BlockHeightY[k],
3755                                 &locals->Read256BlockHeightC[k],
3756                                 &locals->Read256BlockWidthY[k],
3757                                 &locals->Read256BlockWidthC[k]);
3758                 if (mode_lib->vba.SourceScan[k] == dm_horz) {
3759                         locals->MaxSwathHeightY[k] = locals->Read256BlockHeightY[k];
3760                         locals->MaxSwathHeightC[k] = locals->Read256BlockHeightC[k];
3761                 } else {
3762                         locals->MaxSwathHeightY[k] = locals->Read256BlockWidthY[k];
3763                         locals->MaxSwathHeightC[k] = locals->Read256BlockWidthC[k];
3764                 }
3765                 if ((mode_lib->vba.SourcePixelFormat[k] == dm_444_64
3766                                 || mode_lib->vba.SourcePixelFormat[k] == dm_444_32
3767                                 || mode_lib->vba.SourcePixelFormat[k] == dm_444_16
3768                                 || mode_lib->vba.SourcePixelFormat[k] == dm_mono_16
3769                                 || mode_lib->vba.SourcePixelFormat[k] == dm_mono_8)) {
3770                         if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear
3771                                         || (mode_lib->vba.SourcePixelFormat[k] == dm_444_64
3772                                                         && (mode_lib->vba.SurfaceTiling[k]
3773                                                                         == dm_sw_4kb_s
3774                                                                         || mode_lib->vba.SurfaceTiling[k]
3775                                                                                         == dm_sw_4kb_s_x
3776                                                                         || mode_lib->vba.SurfaceTiling[k]
3777                                                                                         == dm_sw_64kb_s
3778                                                                         || mode_lib->vba.SurfaceTiling[k]
3779                                                                                         == dm_sw_64kb_s_t
3780                                                                         || mode_lib->vba.SurfaceTiling[k]
3781                                                                                         == dm_sw_64kb_s_x
3782                                                                         || mode_lib->vba.SurfaceTiling[k]
3783                                                                                         == dm_sw_var_s
3784                                                                         || mode_lib->vba.SurfaceTiling[k]
3785                                                                                         == dm_sw_var_s_x)
3786                                                         && mode_lib->vba.SourceScan[k] == dm_horz)) {
3787                                 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k];
3788                         } else {
3789                                 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k]
3790                                                 / 2.0;
3791                         }
3792                         locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k];
3793                 } else {
3794                         if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
3795                                 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k];
3796                                 locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k];
3797                         } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8
3798                                         && mode_lib->vba.SourceScan[k] == dm_horz) {
3799                                 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k]
3800                                                 / 2.0;
3801                                 locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k];
3802                         } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10
3803                                         && mode_lib->vba.SourceScan[k] == dm_horz) {
3804                                 locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k]
3805                                                 / 2.0;
3806                                 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k];
3807                         } else {
3808                                 locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k];
3809                                 locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k];
3810                         }
3811                 }
3812                 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
3813                         mode_lib->vba.MaximumSwathWidthSupport = 8192.0;
3814                 } else {
3815                         mode_lib->vba.MaximumSwathWidthSupport = 5120.0;
3816                 }
3817                 mode_lib->vba.MaximumSwathWidthInDETBuffer =
3818                                 dml_min(
3819                                                 mode_lib->vba.MaximumSwathWidthSupport,
3820                                                 mode_lib->vba.DETBufferSizeInKByte * 1024.0 / 2.0
3821                                                                 / (locals->BytePerPixelInDETY[k]
3822                                                                                 * locals->MinSwathHeightY[k]
3823                                                                                 + locals->BytePerPixelInDETC[k]
3824                                                                                                 / 2.0
3825                                                                                                 * locals->MinSwathHeightC[k]));
3826                 if (locals->BytePerPixelInDETC[k] == 0.0) {
3827                         mode_lib->vba.MaximumSwathWidthInLineBuffer =
3828                                         mode_lib->vba.LineBufferSize
3829                                                         * dml_max(mode_lib->vba.HRatio[k], 1.0)
3830                                                         / mode_lib->vba.LBBitPerPixel[k]
3831                                                         / (mode_lib->vba.vtaps[k]
3832                                                                         + dml_max(
3833                                                                                         dml_ceil(
3834                                                                                                         mode_lib->vba.VRatio[k],
3835                                                                                                         1.0)
3836                                                                                                         - 2,
3837                                                                                         0.0));
3838                 } else {
3839                         mode_lib->vba.MaximumSwathWidthInLineBuffer =
3840                                         dml_min(
3841                                                         mode_lib->vba.LineBufferSize
3842                                                                         * dml_max(
3843                                                                                         mode_lib->vba.HRatio[k],
3844                                                                                         1.0)
3845                                                                         / mode_lib->vba.LBBitPerPixel[k]
3846                                                                         / (mode_lib->vba.vtaps[k]
3847                                                                                         + dml_max(
3848                                                                                                         dml_ceil(
3849                                                                                                                         mode_lib->vba.VRatio[k],
3850                                                                                                                         1.0)
3851                                                                                                                         - 2,
3852                                                                                                         0.0)),
3853                                                         2.0 * mode_lib->vba.LineBufferSize
3854                                                                         * dml_max(
3855                                                                                         mode_lib->vba.HRatio[k]
3856                                                                                                         / 2.0,
3857                                                                                         1.0)
3858                                                                         / mode_lib->vba.LBBitPerPixel[k]
3859                                                                         / (mode_lib->vba.VTAPsChroma[k]
3860                                                                                         + dml_max(
3861                                                                                                         dml_ceil(
3862                                                                                                                         mode_lib->vba.VRatio[k]
3863                                                                                                                                         / 2.0,
3864                                                                                                                         1.0)
3865                                                                                                                         - 2,
3866                                                                                                         0.0)));
3867                 }
3868                 locals->MaximumSwathWidth[k] = dml_min(
3869                                 mode_lib->vba.MaximumSwathWidthInDETBuffer,
3870                                 mode_lib->vba.MaximumSwathWidthInLineBuffer);
3871         }
3872         for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
3873                 for (j = 0; j < 2; j++) {
3874                         mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity = RoundToDFSGranularityDown(
3875                                 mode_lib->vba.MaxDispclk[i],
3876                                 mode_lib->vba.DISPCLKDPPCLKVCOSpeed);
3877                         mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity = RoundToDFSGranularityDown(
3878                                 mode_lib->vba.MaxDppclk[i],
3879                                 mode_lib->vba.DISPCLKDPPCLKVCOSpeed);
3880                         locals->RequiredDISPCLK[i][j] = 0.0;
3881                         locals->DISPCLK_DPPCLK_Support[i][j] = true;
3882                         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3883                                 mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine =
3884                                                 mode_lib->vba.PixelClock[k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3885                                                                 * (1.0 + mode_lib->vba.DISPCLKRampingMargin / 100.0);
3886                                 if (mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine >= mode_lib->vba.MaxDispclk[i]
3887                                                 && i == mode_lib->vba.soc.num_states)
3888                                         mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine = mode_lib->vba.PixelClock[k]
3889                                                         * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3890
3891                                 mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine = mode_lib->vba.PixelClock[k] / 2
3892                                         * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * (1 + mode_lib->vba.DISPCLKRampingMargin / 100.0);
3893                                 if (mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine >= mode_lib->vba.MaxDispclk[i]
3894                                                 && i == mode_lib->vba.soc.num_states)
3895                                         mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine = mode_lib->vba.PixelClock[k] / 2
3896                                                         * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3897                                 if (mode_lib->vba.ODMCapability == false || mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine <= mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity) {
3898                                         locals->ODMCombineEnablePerState[i][k] = false;
3899                                         mode_lib->vba.PlaneRequiredDISPCLK = mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine;
3900                                 } else {
3901                                         locals->ODMCombineEnablePerState[i][k] = true;
3902                                         mode_lib->vba.PlaneRequiredDISPCLK = mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine;
3903                                 }
3904                                 if (locals->MinDPPCLKUsingSingleDPP[k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) <= mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity
3905                                                 && locals->SwathWidthYSingleDPP[k] <= locals->MaximumSwathWidth[k]
3906                                                 && locals->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_disabled) {
3907                                         locals->NoOfDPP[i][j][k] = 1;
3908                                         locals->RequiredDPPCLK[i][j][k] =
3909                                                 locals->MinDPPCLKUsingSingleDPP[k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3910                                 } else {
3911                                         locals->NoOfDPP[i][j][k] = 2;
3912                                         locals->RequiredDPPCLK[i][j][k] =
3913                                                 locals->MinDPPCLKUsingSingleDPP[k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 2.0;
3914                                 }
3915                                 locals->RequiredDISPCLK[i][j] = dml_max(
3916                                                 locals->RequiredDISPCLK[i][j],
3917                                                 mode_lib->vba.PlaneRequiredDISPCLK);
3918                                 if ((locals->MinDPPCLKUsingSingleDPP[k] / locals->NoOfDPP[i][j][k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3919                                                 > mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity)
3920                                                 || (mode_lib->vba.PlaneRequiredDISPCLK > mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity)) {
3921                                         locals->DISPCLK_DPPCLK_Support[i][j] = false;
3922                                 }
3923                         }
3924                         locals->TotalNumberOfActiveDPP[i][j] = 0.0;
3925                         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++)
3926                                 locals->TotalNumberOfActiveDPP[i][j] = locals->TotalNumberOfActiveDPP[i][j] + locals->NoOfDPP[i][j][k];
3927                         if (j == 1) {
3928                                 while (locals->TotalNumberOfActiveDPP[i][j] < mode_lib->vba.MaxNumDPP
3929                                                 && locals->TotalNumberOfActiveDPP[i][j] < 2 * mode_lib->vba.NumberOfActivePlanes) {
3930                                         double BWOfNonSplitPlaneOfMaximumBandwidth;
3931                                         unsigned int NumberOfNonSplitPlaneOfMaximumBandwidth;
3932
3933                                         BWOfNonSplitPlaneOfMaximumBandwidth = 0;
3934                                         NumberOfNonSplitPlaneOfMaximumBandwidth = 0;
3935                                         for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
3936                                                 if (locals->ReadBandwidth[k] > BWOfNonSplitPlaneOfMaximumBandwidth && locals->NoOfDPP[i][j][k] == 1) {
3937                                                         BWOfNonSplitPlaneOfMaximumBandwidth = locals->ReadBandwidth[k];
3938                                                         NumberOfNonSplitPlaneOfMaximumBandwidth = k;
3939                                                 }
3940                                         }
3941                                         locals->NoOfDPP[i][j][NumberOfNonSplitPlaneOfMaximumBandwidth] = 2;
3942                                         locals->RequiredDPPCLK[i][j][NumberOfNonSplitPlaneOfMaximumBandwidth] =
3943                                                 locals->MinDPPCLKUsingSingleDPP[NumberOfNonSplitPlaneOfMaximumBandwidth]
3944                                                         * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100) / 2;
3945                                         locals->TotalNumberOfActiveDPP[i][j] = locals->TotalNumberOfActiveDPP[i][j] + 1;
3946                                 }
3947                         }
3948                         if (locals->TotalNumberOfActiveDPP[i][j] > mode_lib->vba.MaxNumDPP) {
3949                                 locals->RequiredDISPCLK[i][j] = 0.0;
3950                                 locals->DISPCLK_DPPCLK_Support[i][j] = true;
3951                                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3952                                         locals->ODMCombineEnablePerState[i][k] = false;
3953                                         if (locals->SwathWidthYSingleDPP[k] <= locals->MaximumSwathWidth[k]) {
3954                                                 locals->NoOfDPP[i][j][k] = 1;
3955                                                 locals->RequiredDPPCLK[i][j][k] = locals->MinDPPCLKUsingSingleDPP[k]
3956                                                         * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3957                                         } else {
3958                                                 locals->NoOfDPP[i][j][k] = 2;
3959                                                 locals->RequiredDPPCLK[i][j][k] = locals->MinDPPCLKUsingSingleDPP[k]
3960                                                                                 * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 2.0;
3961                                         }
3962                                         if (i != mode_lib->vba.soc.num_states) {
3963                                                 mode_lib->vba.PlaneRequiredDISPCLK =
3964                                                                 mode_lib->vba.PixelClock[k]
3965                                                                                 * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3966                                                                                 * (1.0 + mode_lib->vba.DISPCLKRampingMargin / 100.0);
3967                                         } else {
3968                                                 mode_lib->vba.PlaneRequiredDISPCLK = mode_lib->vba.PixelClock[k]
3969                                                         * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
3970                                         }
3971                                         locals->RequiredDISPCLK[i][j] = dml_max(
3972                                                         locals->RequiredDISPCLK[i][j],
3973                                                         mode_lib->vba.PlaneRequiredDISPCLK);
3974                                         if (locals->MinDPPCLKUsingSingleDPP[k] / locals->NoOfDPP[i][j][k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3975                                                         > mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity
3976                                                         || mode_lib->vba.PlaneRequiredDISPCLK > mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity)
3977                                                 locals->DISPCLK_DPPCLK_Support[i][j] = false;
3978                                 }
3979                                 locals->TotalNumberOfActiveDPP[i][j] = 0.0;
3980                                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++)
3981                                         locals->TotalNumberOfActiveDPP[i][j] = locals->TotalNumberOfActiveDPP[i][j] + locals->NoOfDPP[i][j][k];
3982                         }
3983                         locals->RequiredDISPCLK[i][j] = dml_max(
3984                                         locals->RequiredDISPCLK[i][j],
3985                                         mode_lib->vba.WritebackRequiredDISPCLK);
3986                         if (mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity
3987                                         < mode_lib->vba.WritebackRequiredDISPCLK) {
3988                                 locals->DISPCLK_DPPCLK_Support[i][j] = false;
3989                         }
3990                 }
3991         }
3992         /*Viewport Size Check*/
3993
3994         for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
3995                 locals->ViewportSizeSupport[i][0] = true;
3996                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3997                         if (locals->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
3998                                 if (dml_min(locals->SwathWidthYSingleDPP[k], dml_round(mode_lib->vba.HActive[k] / 2.0 * mode_lib->vba.HRatio[k]))
3999                                                 > locals->MaximumSwathWidth[k]) {
4000                                         locals->ViewportSizeSupport[i][0] = false;
4001                                 }
4002                         } else {
4003                                 if (locals->SwathWidthYSingleDPP[k] / 2.0 > locals->MaximumSwathWidth[k]) {
4004                                         locals->ViewportSizeSupport[i][0] = false;
4005                                 }
4006                         }
4007                 }
4008         }
4009         /*Total Available Pipes Support Check*/
4010
4011         for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4012                 for (j = 0; j < 2; j++) {
4013                         if (locals->TotalNumberOfActiveDPP[i][j] <= mode_lib->vba.MaxNumDPP)
4014                                 locals->TotalAvailablePipesSupport[i][j] = true;
4015                         else
4016                                 locals->TotalAvailablePipesSupport[i][j] = false;
4017                 }
4018         }
4019         /*Total Available OTG Support Check*/
4020
4021         mode_lib->vba.TotalNumberOfActiveOTG = 0.0;
4022         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4023                 if (mode_lib->vba.BlendingAndTiming[k] == k) {
4024                         mode_lib->vba.TotalNumberOfActiveOTG = mode_lib->vba.TotalNumberOfActiveOTG
4025                                         + 1.0;
4026                 }
4027         }
4028         if (mode_lib->vba.TotalNumberOfActiveOTG <= mode_lib->vba.MaxNumOTG) {
4029                 mode_lib->vba.NumberOfOTGSupport = true;
4030         } else {
4031                 mode_lib->vba.NumberOfOTGSupport = false;
4032         }
4033         /*Display IO and DSC Support Check*/
4034
4035         mode_lib->vba.NonsupportedDSCInputBPC = false;
4036         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4037                 if (!(mode_lib->vba.DSCInputBitPerComponent[k] == 12.0
4038                                 || mode_lib->vba.DSCInputBitPerComponent[k] == 10.0
4039                                 || mode_lib->vba.DSCInputBitPerComponent[k] == 8.0)) {
4040                         mode_lib->vba.NonsupportedDSCInputBPC = true;
4041                 }
4042         }
4043         for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4044                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4045                         locals->RequiresDSC[i][k] = 0;
4046                         locals->RequiresFEC[i][k] = 0;
4047                         if (mode_lib->vba.BlendingAndTiming[k] == k) {
4048                                 if (mode_lib->vba.Output[k] == dm_hdmi) {
4049                                         locals->RequiresDSC[i][k] = 0;
4050                                         locals->RequiresFEC[i][k] = 0;
4051                                         locals->OutputBppPerState[i][k] = TruncToValidBPP(
4052                                                         dml_min(600.0, mode_lib->vba.PHYCLKPerState[i]) / mode_lib->vba.PixelClockBackEnd[k] * 24,
4053                                                         false,
4054                                                         mode_lib->vba.Output[k],
4055                                                         mode_lib->vba.OutputFormat[k],
4056                                                         mode_lib->vba.DSCInputBitPerComponent[k]);
4057                                 } else if (mode_lib->vba.Output[k] == dm_dp
4058                                                 || mode_lib->vba.Output[k] == dm_edp) {
4059                                         if (mode_lib->vba.Output[k] == dm_edp) {
4060                                                 mode_lib->vba.EffectiveFECOverhead = 0.0;
4061                                         } else {
4062                                                 mode_lib->vba.EffectiveFECOverhead =
4063                                                                 mode_lib->vba.FECOverhead;
4064                                         }
4065                                         if (mode_lib->vba.PHYCLKPerState[i] >= 270.0) {
4066                                                 mode_lib->vba.Outbpp = TruncToValidBPP(
4067                                                                 (1.0 - mode_lib->vba.Downspreading / 100.0) * 270.0
4068                                                                 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4069                                                                 false,
4070                                                                 mode_lib->vba.Output[k],
4071                                                                 mode_lib->vba.OutputFormat[k],
4072                                                                 mode_lib->vba.DSCInputBitPerComponent[k]);
4073                                                 mode_lib->vba.OutbppDSC = TruncToValidBPP(
4074                                                                 (1.0 - mode_lib->vba.Downspreading / 100.0) * (1.0 - mode_lib->vba.EffectiveFECOverhead / 100.0) * 270.0
4075                                                                 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4076                                                                 true,
4077                                                                 mode_lib->vba.Output[k],
4078                                                                 mode_lib->vba.OutputFormat[k],
4079                                                                 mode_lib->vba.DSCInputBitPerComponent[k]);
4080                                                 if (mode_lib->vba.DSCEnabled[k] == true) {
4081                                                         locals->RequiresDSC[i][k] = true;
4082                                                         if (mode_lib->vba.Output[k] == dm_dp) {
4083                                                                 locals->RequiresFEC[i][k] = true;
4084                                                         } else {
4085                                                                 locals->RequiresFEC[i][k] = false;
4086                                                         }
4087                                                         mode_lib->vba.Outbpp = mode_lib->vba.OutbppDSC;
4088                                                 } else {
4089                                                         locals->RequiresDSC[i][k] = false;
4090                                                         locals->RequiresFEC[i][k] = false;
4091                                                 }
4092                                                 locals->OutputBppPerState[i][k] = mode_lib->vba.Outbpp;
4093                                         }
4094                                         if (mode_lib->vba.Outbpp == BPP_INVALID && mode_lib->vba.PHYCLKPerState[i] >= 540.0) {
4095                                                 mode_lib->vba.Outbpp = TruncToValidBPP(
4096                                                                 (1.0 - mode_lib->vba.Downspreading / 100.0) * 540.0
4097                                                                 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4098                                                                         false,
4099                                                                         mode_lib->vba.Output[k],
4100                                                                         mode_lib->vba.OutputFormat[k],
4101                                                                         mode_lib->vba.DSCInputBitPerComponent[k]);
4102                                                 mode_lib->vba.OutbppDSC = TruncToValidBPP(
4103                                                                 (1.0 - mode_lib->vba.Downspreading / 100.0) * (1.0 - mode_lib->vba.EffectiveFECOverhead / 100.0) * 540.0
4104                                                                 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4105                                                                 true,
4106                                                                 mode_lib->vba.Output[k],
4107                                                                 mode_lib->vba.OutputFormat[k],
4108                                                                 mode_lib->vba.DSCInputBitPerComponent[k]);
4109                                                 if (mode_lib->vba.DSCEnabled[k] == true) {
4110                                                         locals->RequiresDSC[i][k] = true;
4111                                                         if (mode_lib->vba.Output[k] == dm_dp) {
4112                                                                 locals->RequiresFEC[i][k] = true;
4113                                                         } else {
4114                                                                 locals->RequiresFEC[i][k] = false;
4115                                                         }
4116                                                         mode_lib->vba.Outbpp = mode_lib->vba.OutbppDSC;
4117                                                 } else {
4118                                                         locals->RequiresDSC[i][k] = false;
4119                                                         locals->RequiresFEC[i][k] = false;
4120                                                 }
4121                                                 locals->OutputBppPerState[i][k] = mode_lib->vba.Outbpp;
4122                                         }
4123                                         if (mode_lib->vba.Outbpp == BPP_INVALID
4124                                                         && mode_lib->vba.PHYCLKPerState[i]
4125                                                                         >= 810.0) {
4126                                                 mode_lib->vba.Outbpp = TruncToValidBPP(
4127                                                                 (1.0 - mode_lib->vba.Downspreading / 100.0) * 810.0
4128                                                                 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4129                                                                 false,
4130                                                                 mode_lib->vba.Output[k],
4131                                                                 mode_lib->vba.OutputFormat[k],
4132                                                                 mode_lib->vba.DSCInputBitPerComponent[k]);
4133                                                 mode_lib->vba.OutbppDSC = TruncToValidBPP(
4134                                                                 (1.0 - mode_lib->vba.Downspreading / 100.0) * (1.0 - mode_lib->vba.EffectiveFECOverhead / 100.0) * 810.0
4135                                                                 * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4136                                                                 true,
4137                                                                 mode_lib->vba.Output[k],
4138                                                                 mode_lib->vba.OutputFormat[k],
4139                                                                 mode_lib->vba.DSCInputBitPerComponent[k]);
4140                                                 if (mode_lib->vba.DSCEnabled[k] == true || mode_lib->vba.Outbpp == BPP_INVALID) {
4141                                                         locals->RequiresDSC[i][k] = true;
4142                                                         if (mode_lib->vba.Output[k] == dm_dp) {
4143                                                                 locals->RequiresFEC[i][k] = true;
4144                                                         } else {
4145                                                                 locals->RequiresFEC[i][k] = false;
4146                                                         }
4147                                                         mode_lib->vba.Outbpp = mode_lib->vba.OutbppDSC;
4148                                                 } else {
4149                                                         locals->RequiresDSC[i][k] = false;
4150                                                         locals->RequiresFEC[i][k] = false;
4151                                                 }
4152                                                 locals->OutputBppPerState[i][k] =
4153                                                                 mode_lib->vba.Outbpp;
4154                                         }
4155                                 }
4156                         } else {
4157                                 locals->OutputBppPerState[i][k] = BPP_BLENDED_PIPE;
4158                         }
4159                 }
4160         }
4161         for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4162                 locals->DIOSupport[i] = true;
4163                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4164                         if (locals->OutputBppPerState[i][k] == BPP_INVALID
4165                                         || (mode_lib->vba.OutputFormat[k] == dm_420
4166                                                         && mode_lib->vba.Interlace[k] == true
4167                                                         && mode_lib->vba.ProgressiveToInterlaceUnitInOPP == true)) {
4168                                 locals->DIOSupport[i] = false;
4169                         }
4170                 }
4171         }
4172         for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4173                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4174                         locals->DSCCLKRequiredMoreThanSupported[i] = false;
4175                         if (mode_lib->vba.BlendingAndTiming[k] == k) {
4176                                 if ((mode_lib->vba.Output[k] == dm_dp
4177                                                 || mode_lib->vba.Output[k] == dm_edp)) {
4178                                         if (mode_lib->vba.OutputFormat[k] == dm_420
4179                                                         || mode_lib->vba.OutputFormat[k]
4180                                                                         == dm_n422) {
4181                                                 mode_lib->vba.DSCFormatFactor = 2;
4182                                         } else {
4183                                                 mode_lib->vba.DSCFormatFactor = 1;
4184                                         }
4185                                         if (locals->RequiresDSC[i][k] == true) {
4186                                                 if (locals->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
4187                                                         if (mode_lib->vba.PixelClockBackEnd[k] / 6.0 / mode_lib->vba.DSCFormatFactor
4188                                                                         > (1.0 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * mode_lib->vba.MaxDSCCLK[i]) {
4189                                                                 locals->DSCCLKRequiredMoreThanSupported[i] =
4190                                                                                 true;
4191                                                         }
4192                                                 } else {
4193                                                         if (mode_lib->vba.PixelClockBackEnd[k] / 3.0 / mode_lib->vba.DSCFormatFactor
4194                                                                         > (1.0 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * mode_lib->vba.MaxDSCCLK[i]) {
4195                                                                 locals->DSCCLKRequiredMoreThanSupported[i] =
4196                                                                                 true;
4197                                                         }
4198                                                 }
4199                                         }
4200                                 }
4201                         }
4202                 }
4203         }
4204         for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4205                 locals->NotEnoughDSCUnits[i] = false;
4206                 mode_lib->vba.TotalDSCUnitsRequired = 0.0;
4207                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4208                         if (locals->RequiresDSC[i][k] == true) {
4209                                 if (locals->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
4210                                         mode_lib->vba.TotalDSCUnitsRequired =
4211                                                         mode_lib->vba.TotalDSCUnitsRequired + 2.0;
4212                                 } else {
4213                                         mode_lib->vba.TotalDSCUnitsRequired =
4214                                                         mode_lib->vba.TotalDSCUnitsRequired + 1.0;
4215                                 }
4216                         }
4217                 }
4218                 if (mode_lib->vba.TotalDSCUnitsRequired > mode_lib->vba.NumberOfDSC) {
4219                         locals->NotEnoughDSCUnits[i] = true;
4220                 }
4221         }
4222         /*DSC Delay per state*/
4223
4224         for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4225                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4226                         if (mode_lib->vba.BlendingAndTiming[k] != k) {
4227                                 mode_lib->vba.slices = 0;
4228                         } else if (locals->RequiresDSC[i][k] == 0
4229                                         || locals->RequiresDSC[i][k] == false) {
4230                                 mode_lib->vba.slices = 0;
4231                         } else if (mode_lib->vba.PixelClockBackEnd[k] > 3200.0) {
4232                                 mode_lib->vba.slices = dml_ceil(
4233                                                 mode_lib->vba.PixelClockBackEnd[k] / 400.0,
4234                                                 4.0);
4235                         } else if (mode_lib->vba.PixelClockBackEnd[k] > 1360.0) {
4236                                 mode_lib->vba.slices = 8.0;
4237                         } else if (mode_lib->vba.PixelClockBackEnd[k] > 680.0) {
4238                                 mode_lib->vba.slices = 4.0;
4239                         } else if (mode_lib->vba.PixelClockBackEnd[k] > 340.0) {
4240                                 mode_lib->vba.slices = 2.0;
4241                         } else {
4242                                 mode_lib->vba.slices = 1.0;
4243                         }
4244                         if (locals->OutputBppPerState[i][k] == BPP_BLENDED_PIPE
4245                                         || locals->OutputBppPerState[i][k] == BPP_INVALID) {
4246                                 mode_lib->vba.bpp = 0.0;
4247                         } else {
4248                                 mode_lib->vba.bpp = locals->OutputBppPerState[i][k];
4249                         }
4250                         if (locals->RequiresDSC[i][k] == true && mode_lib->vba.bpp != 0.0) {
4251                                 if (locals->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_disabled) {
4252                                         locals->DSCDelayPerState[i][k] =
4253                                                         dscceComputeDelay(
4254                                                                         mode_lib->vba.DSCInputBitPerComponent[k],
4255                                                                         mode_lib->vba.bpp,
4256                                                                         dml_ceil(
4257                                                                                         mode_lib->vba.HActive[k]
4258                                                                                                         / mode_lib->vba.slices,
4259                                                                                         1.0),
4260                                                                         mode_lib->vba.slices,
4261                                                                         mode_lib->vba.OutputFormat[k])
4262                                                                         + dscComputeDelay(
4263                                                                                         mode_lib->vba.OutputFormat[k]);
4264                                 } else {
4265                                         locals->DSCDelayPerState[i][k] =
4266                                                         2.0 * (dscceComputeDelay(
4267                                                                                         mode_lib->vba.DSCInputBitPerComponent[k],
4268                                                                                         mode_lib->vba.bpp,
4269                                                                                         dml_ceil(mode_lib->vba.HActive[k] / mode_lib->vba.slices, 1.0),
4270                                                                                         mode_lib->vba.slices / 2,
4271                                                                                         mode_lib->vba.OutputFormat[k])
4272                                                                         + dscComputeDelay(mode_lib->vba.OutputFormat[k]));
4273                                 }
4274                                 locals->DSCDelayPerState[i][k] =
4275                                                 locals->DSCDelayPerState[i][k] * mode_lib->vba.PixelClock[k] / mode_lib->vba.PixelClockBackEnd[k];
4276                         } else {
4277                                 locals->DSCDelayPerState[i][k] = 0.0;
4278                         }
4279                 }
4280                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4281                         for (m = 0; m <= mode_lib->vba.NumberOfActivePlanes - 1; m++) {
4282                                 for (j = 0; j <= mode_lib->vba.NumberOfActivePlanes - 1; j++) {
4283                                         if (mode_lib->vba.BlendingAndTiming[k] == m && locals->RequiresDSC[i][m] == true)
4284                                                 locals->DSCDelayPerState[i][k] = locals->DSCDelayPerState[i][m];
4285                                 }
4286                         }
4287                 }
4288         }
4289
4290         //Prefetch Check
4291         for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4292                 for (j = 0; j < 2; j++) {
4293                         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4294                                 if (locals->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1)
4295                                         locals->SwathWidthYPerState[i][j][k] = dml_min(locals->SwathWidthYSingleDPP[k], dml_round(locals->HActive[k] / 2 * locals->HRatio[k]));
4296                                 else
4297                                         locals->SwathWidthYPerState[i][j][k] = locals->SwathWidthYSingleDPP[k] / locals->NoOfDPP[i][j][k];
4298                                 locals->SwathWidthGranularityY = 256  / dml_ceil(locals->BytePerPixelInDETY[k], 1) / locals->MaxSwathHeightY[k];
4299                                 locals->RoundedUpMaxSwathSizeBytesY = (dml_ceil(locals->SwathWidthYPerState[i][j][k] - 1, locals->SwathWidthGranularityY)
4300                                                 + locals->SwathWidthGranularityY) * locals->BytePerPixelInDETY[k] * locals->MaxSwathHeightY[k];
4301                                 if (locals->SourcePixelFormat[k] == dm_420_10) {
4302                                         locals->RoundedUpMaxSwathSizeBytesY = dml_ceil(locals->RoundedUpMaxSwathSizeBytesY, 256) + 256;
4303                                 }
4304                                 if (locals->MaxSwathHeightC[k] > 0) {
4305                                         locals->SwathWidthGranularityC = 256 / dml_ceil(locals->BytePerPixelInDETC[k], 2) / locals->MaxSwathHeightC[k];
4306
4307                                         locals->RoundedUpMaxSwathSizeBytesC = (dml_ceil(locals->SwathWidthYPerState[i][j][k] / 2 - 1, locals->SwathWidthGranularityC)
4308                                         + locals->SwathWidthGranularityC) * locals->BytePerPixelInDETC[k] * locals->MaxSwathHeightC[k];
4309                                 }
4310                                 if (locals->SourcePixelFormat[k] == dm_420_10) {
4311                                         locals->RoundedUpMaxSwathSizeBytesC = dml_ceil(locals->RoundedUpMaxSwathSizeBytesC, 256)  + 256;
4312                                 } else {
4313                                         locals->RoundedUpMaxSwathSizeBytesC = 0;
4314                                 }
4315
4316                                 if (locals->RoundedUpMaxSwathSizeBytesY + locals->RoundedUpMaxSwathSizeBytesC <= locals->DETBufferSizeInKByte * 1024 / 2) {
4317                                         locals->SwathHeightYPerState[i][j][k] = locals->MaxSwathHeightY[k];
4318                                         locals->SwathHeightCPerState[i][j][k] = locals->MaxSwathHeightC[k];
4319                                 } else {
4320                                         locals->SwathHeightYPerState[i][j][k] = locals->MinSwathHeightY[k];
4321                                         locals->SwathHeightCPerState[i][j][k] = locals->MinSwathHeightC[k];
4322                                 }
4323
4324                                 if (locals->BytePerPixelInDETC[k] == 0) {
4325                                         locals->LinesInDETLuma = locals->DETBufferSizeInKByte * 1024 / locals->BytePerPixelInDETY[k] / locals->SwathWidthYPerState[i][j][k];
4326                                         locals->LinesInDETChroma = 0;
4327                                 } else if (locals->SwathHeightYPerState[i][j][k] <= locals->SwathHeightCPerState[i][j][k]) {
4328                                         locals->LinesInDETLuma = locals->DETBufferSizeInKByte * 1024 / 2 / locals->BytePerPixelInDETY[k] /
4329                                                         locals->SwathWidthYPerState[i][j][k];
4330                                         locals->LinesInDETChroma = locals->DETBufferSizeInKByte * 1024 / 2 / locals->BytePerPixelInDETC[k] / (locals->SwathWidthYPerState[i][j][k] / 2);
4331                                 } else {
4332                                         locals->LinesInDETLuma = locals->DETBufferSizeInKByte * 1024 * 2 / 3 / locals->BytePerPixelInDETY[k] / locals->SwathWidthYPerState[i][j][k];
4333                                         locals->LinesInDETChroma = locals->DETBufferSizeInKByte * 1024 / 3 / locals->BytePerPixelInDETY[k] / (locals->SwathWidthYPerState[i][j][k] / 2);
4334                                 }
4335
4336                                 locals->EffectiveLBLatencyHidingSourceLinesLuma = dml_min(locals->MaxLineBufferLines,
4337                                         dml_floor(locals->LineBufferSize / locals->LBBitPerPixel[k] / (locals->SwathWidthYPerState[i][j][k]
4338                                         / dml_max(locals->HRatio[k], 1)), 1)) - (locals->vtaps[k] - 1);
4339
4340                                 locals->EffectiveLBLatencyHidingSourceLinesChroma =  dml_min(locals->MaxLineBufferLines,
4341                                                 dml_floor(locals->LineBufferSize / locals->LBBitPerPixel[k]
4342                                                 / (locals->SwathWidthYPerState[i][j][k] / 2
4343                                                 / dml_max(locals->HRatio[k] / 2, 1)), 1)) - (locals->VTAPsChroma[k] - 1);
4344
4345                                 locals->EffectiveDETLBLinesLuma = dml_floor(locals->LinesInDETLuma +  dml_min(
4346                                                 locals->LinesInDETLuma * locals->RequiredDISPCLK[i][j] * locals->BytePerPixelInDETY[k] *
4347                                                 locals->PSCL_FACTOR[k] / locals->ReturnBWPerState[i][0],
4348                                                 locals->EffectiveLBLatencyHidingSourceLinesLuma),
4349                                                 locals->SwathHeightYPerState[i][j][k]);
4350
4351                                 locals->EffectiveDETLBLinesChroma = dml_floor(locals->LinesInDETChroma + dml_min(
4352                                                 locals->LinesInDETChroma * locals->RequiredDISPCLK[i][j] * locals->BytePerPixelInDETC[k] *
4353                                                 locals->PSCL_FACTOR_CHROMA[k] / locals->ReturnBWPerState[i][0],
4354                                                 locals->EffectiveLBLatencyHidingSourceLinesChroma),
4355                                                 locals->SwathHeightCPerState[i][j][k]);
4356
4357                                 if (locals->BytePerPixelInDETC[k] == 0) {
4358                                         locals->UrgentLatencySupportUsPerState[i][j][k] = locals->EffectiveDETLBLinesLuma * (locals->HTotal[k] / locals->PixelClock[k])
4359                                                         / locals->VRatio[k] - locals->EffectiveDETLBLinesLuma * locals->SwathWidthYPerState[i][j][k] *
4360                                                                 dml_ceil(locals->BytePerPixelInDETY[k], 1) / (locals->ReturnBWPerState[i][0] / locals->NoOfDPP[i][j][k]);
4361                                 } else {
4362                                         locals->UrgentLatencySupportUsPerState[i][j][k] = dml_min(
4363                                                 locals->EffectiveDETLBLinesLuma * (locals->HTotal[k] / locals->PixelClock[k])
4364                                                 / locals->VRatio[k] - locals->EffectiveDETLBLinesLuma * locals->SwathWidthYPerState[i][j][k] *
4365                                                 dml_ceil(locals->BytePerPixelInDETY[k], 1) / (locals->ReturnBWPerState[i][0] / locals->NoOfDPP[i][j][k]),
4366                                                         locals->EffectiveDETLBLinesChroma * (locals->HTotal[k] / locals->PixelClock[k]) / (locals->VRatio[k] / 2) -
4367                                                         locals->EffectiveDETLBLinesChroma * locals->SwathWidthYPerState[i][j][k] / 2 *
4368                                                         dml_ceil(locals->BytePerPixelInDETC[k], 2) / (locals->ReturnBWPerState[i][0] / locals->NoOfDPP[i][j][k]));
4369                                 }
4370                         }
4371                 }
4372         }
4373
4374         for (i = 0; i <= locals->soc.num_states; i++) {
4375                 for (j = 0; j < 2; j++) {
4376                         locals->UrgentLatencySupport[i][j] = true;
4377                         for (k = 0; k < locals->NumberOfActivePlanes; k++) {
4378                                 if (locals->UrgentLatencySupportUsPerState[i][j][k] < locals->UrgentLatency)
4379                                         locals->UrgentLatencySupport[i][j] = false;
4380                         }
4381                 }
4382         }
4383
4384
4385         /*Prefetch Check*/
4386         for (i = 0; i <= locals->soc.num_states; i++) {
4387                 for (j = 0; j < 2; j++) {
4388                         locals->TotalNumberOfDCCActiveDPP[i][j] = 0;
4389                         for (k = 0; k < locals->NumberOfActivePlanes; k++) {
4390                                 if (locals->DCCEnable[k] == true) {
4391                                         locals->TotalNumberOfDCCActiveDPP[i][j] =
4392                                                 locals->TotalNumberOfDCCActiveDPP[i][j] + locals->NoOfDPP[i][j][k];
4393                                 }
4394                         }
4395                 }
4396         }
4397
4398         CalculateMinAndMaxPrefetchMode(locals->AllowDRAMSelfRefreshOrDRAMClockChangeInVblank, &locals->MinPrefetchMode, &locals->MaxPrefetchMode);
4399
4400         for (i = 0; i <= locals->soc.num_states; i++) {
4401                 for (j = 0; j < 2; j++) {
4402                         for (k = 0; k < locals->NumberOfActivePlanes; k++) {
4403                                 locals->NoOfDPPThisState[k] = locals->NoOfDPP[i][j][k];
4404                                 locals->RequiredDPPCLKThisState[k] = locals->RequiredDPPCLK[i][j][k];
4405                                 locals->SwathHeightYThisState[k] = locals->SwathHeightYPerState[i][j][k];
4406                                 locals->SwathHeightCThisState[k] = locals->SwathHeightCPerState[i][j][k];
4407                                 locals->SwathWidthYThisState[k] = locals->SwathWidthYPerState[i][j][k];
4408                                 mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0] = dml_max(
4409                                                 mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0],
4410                                                 mode_lib->vba.PixelClock[k] / 16.0);
4411                                 if (mode_lib->vba.BytePerPixelInDETC[k] == 0.0) {
4412                                         if (mode_lib->vba.VRatio[k] <= 1.0) {
4413                                                 mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0] =
4414                                                                 dml_max(
4415                                                                                 mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0],
4416                                                                                 1.1
4417                                                                                                 * dml_ceil(
4418                                                                                                                 mode_lib->vba.BytePerPixelInDETY[k],
4419                                                                                                                 1.0)
4420                                                                                                 / 64.0
4421                                                                                                 * mode_lib->vba.HRatio[k]
4422                                                                                                 * mode_lib->vba.PixelClock[k]
4423                                                                                                 / mode_lib->vba.NoOfDPP[i][j][k]);
4424                                         } else {
4425                                                 mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0] =
4426                                                                 dml_max(
4427                                                                                 mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0],
4428                                                                                 1.1
4429                                                                                                 * dml_ceil(
4430                                                                                                                 mode_lib->vba.BytePerPixelInDETY[k],
4431                                                                                                                 1.0)
4432                                                                                                 / 64.0
4433                                                                                                 * mode_lib->vba.PSCL_FACTOR[k]
4434                                                                                                 * mode_lib->vba.RequiredDPPCLK[i][j][k]);
4435                                         }
4436                                 } else {
4437                                         if (mode_lib->vba.VRatio[k] <= 1.0) {
4438                                                 mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0] =
4439                                                                 dml_max(
4440                                                                                 mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0],
4441                                                                                 1.1
4442                                                                                                 * dml_ceil(
4443                                                                                                                 mode_lib->vba.BytePerPixelInDETY[k],
4444                                                                                                                 1.0)
4445                                                                                                 / 32.0
4446                                                                                                 * mode_lib->vba.HRatio[k]
4447                                                                                                 * mode_lib->vba.PixelClock[k]
4448                                                                                                 / mode_lib->vba.NoOfDPP[i][j][k]);
4449                                         } else {
4450                                                 mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0] =
4451                                                                 dml_max(
4452                                                                                 mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0],
4453                                                                                 1.1
4454                                                                                                 * dml_ceil(
4455                                                                                                                 mode_lib->vba.BytePerPixelInDETY[k],
4456                                                                                                                 1.0)
4457                                                                                                 / 32.0
4458                                                                                                 * mode_lib->vba.PSCL_FACTOR[k]
4459                                                                                                 * mode_lib->vba.RequiredDPPCLK[i][j][k]);
4460                                         }
4461                                         if (mode_lib->vba.VRatio[k] / 2.0 <= 1.0) {
4462                                                 mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0] =
4463                                                                 dml_max(
4464                                                                                 mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0],
4465                                                                                 1.1
4466                                                                                                 * dml_ceil(
4467                                                                                                                 mode_lib->vba.BytePerPixelInDETC[k],
4468                                                                                                                 2.0)
4469                                                                                                 / 32.0
4470                                                                                                 * mode_lib->vba.HRatio[k]
4471                                                                                                 / 2.0
4472                                                                                                 * mode_lib->vba.PixelClock[k]
4473                                                                                                 / mode_lib->vba.NoOfDPP[i][j][k]);
4474                                         } else {
4475                                                 mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0] =
4476                                                                 dml_max(
4477                                                                                 mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0],
4478                                                                                 1.1
4479                                                                                                 * dml_ceil(
4480                                                                                                                 mode_lib->vba.BytePerPixelInDETC[k],
4481                                                                                                                 2.0)
4482                                                                                                 / 32.0
4483                                                                                                 * mode_lib->vba.PSCL_FACTOR_CHROMA[k]
4484                                                                                                 * mode_lib->vba.RequiredDPPCLK[i][j][k]);
4485                                         }
4486                                 }
4487                         }
4488                         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4489                                 mode_lib->vba.PDEAndMetaPTEBytesPerFrameY = CalculateVMAndRowBytes(
4490                                                 mode_lib,
4491                                                 mode_lib->vba.DCCEnable[k],
4492                                                 mode_lib->vba.Read256BlockHeightY[k],
4493                                                 mode_lib->vba.Read256BlockWidthY[k],
4494                                                 mode_lib->vba.SourcePixelFormat[k],
4495                                                 mode_lib->vba.SurfaceTiling[k],
4496                                                 dml_ceil(mode_lib->vba.BytePerPixelInDETY[k], 1.0),
4497                                                 mode_lib->vba.SourceScan[k],
4498                                                 mode_lib->vba.ViewportWidth[k],
4499                                                 mode_lib->vba.ViewportHeight[k],
4500                                                 mode_lib->vba.SwathWidthYPerState[i][j][k],
4501                                                 mode_lib->vba.GPUVMEnable,
4502                                                 mode_lib->vba.VMMPageSize,
4503                                                 mode_lib->vba.PTEBufferSizeInRequestsLuma,
4504                                                 mode_lib->vba.PDEProcessingBufIn64KBReqs,
4505                                                 mode_lib->vba.PitchY[k],
4506                                                 mode_lib->vba.DCCMetaPitchY[k],
4507                                                 &mode_lib->vba.MacroTileWidthY[k],
4508                                                 &mode_lib->vba.MetaRowBytesY,
4509                                                 &mode_lib->vba.DPTEBytesPerRowY,
4510                                                 &mode_lib->vba.PTEBufferSizeNotExceededY[i][j][k],
4511                                                 &mode_lib->vba.dpte_row_height[k],
4512                                                 &mode_lib->vba.meta_row_height[k]);
4513                                 mode_lib->vba.PrefetchLinesY[0][0][k] = CalculatePrefetchSourceLines(
4514                                                 mode_lib,
4515                                                 mode_lib->vba.VRatio[k],
4516                                                 mode_lib->vba.vtaps[k],
4517                                                 mode_lib->vba.Interlace[k],
4518                                                 mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
4519                                                 mode_lib->vba.SwathHeightYPerState[i][j][k],
4520                                                 mode_lib->vba.ViewportYStartY[k],
4521                                                 &mode_lib->vba.PrefillY[k],
4522                                                 &mode_lib->vba.MaxNumSwY[k]);
4523                                 if ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64
4524                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
4525                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
4526                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
4527                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8)) {
4528                                         mode_lib->vba.PDEAndMetaPTEBytesPerFrameC = CalculateVMAndRowBytes(
4529                                                         mode_lib,
4530                                                         mode_lib->vba.DCCEnable[k],
4531                                                         mode_lib->vba.Read256BlockHeightY[k],
4532                                                         mode_lib->vba.Read256BlockWidthY[k],
4533                                                         mode_lib->vba.SourcePixelFormat[k],
4534                                                         mode_lib->vba.SurfaceTiling[k],
4535                                                         dml_ceil(mode_lib->vba.BytePerPixelInDETC[k], 2.0),
4536                                                         mode_lib->vba.SourceScan[k],
4537                                                         mode_lib->vba.ViewportWidth[k] / 2.0,
4538                                                         mode_lib->vba.ViewportHeight[k] / 2.0,
4539                                                         mode_lib->vba.SwathWidthYPerState[i][j][k] / 2.0,
4540                                                         mode_lib->vba.GPUVMEnable,
4541                                                         mode_lib->vba.VMMPageSize,
4542                                                         mode_lib->vba.PTEBufferSizeInRequestsLuma,
4543                                                         mode_lib->vba.PDEProcessingBufIn64KBReqs,
4544                                                         mode_lib->vba.PitchC[k],
4545                                                         0.0,
4546                                                         &mode_lib->vba.MacroTileWidthC[k],
4547                                                         &mode_lib->vba.MetaRowBytesC,
4548                                                         &mode_lib->vba.DPTEBytesPerRowC,
4549                                                         &mode_lib->vba.PTEBufferSizeNotExceededC[i][j][k],
4550                                                         &mode_lib->vba.dpte_row_height_chroma[k],
4551                                                         &mode_lib->vba.meta_row_height_chroma[k]);
4552                                         mode_lib->vba.PrefetchLinesC[0][0][k] = CalculatePrefetchSourceLines(
4553                                                         mode_lib,
4554                                                         mode_lib->vba.VRatio[k] / 2.0,
4555                                                         mode_lib->vba.VTAPsChroma[k],
4556                                                         mode_lib->vba.Interlace[k],
4557                                                         mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
4558                                                         mode_lib->vba.SwathHeightCPerState[i][j][k],
4559                                                         mode_lib->vba.ViewportYStartC[k],
4560                                                         &mode_lib->vba.PrefillC[k],
4561                                                         &mode_lib->vba.MaxNumSwC[k]);
4562                                 } else {
4563                                         mode_lib->vba.PDEAndMetaPTEBytesPerFrameC = 0.0;
4564                                         mode_lib->vba.MetaRowBytesC = 0.0;
4565                                         mode_lib->vba.DPTEBytesPerRowC = 0.0;
4566                                         locals->PrefetchLinesC[0][0][k] = 0.0;
4567                                         locals->PTEBufferSizeNotExceededC[i][j][k] = true;
4568                                         locals->PTEBufferSizeInRequestsForLuma = mode_lib->vba.PTEBufferSizeInRequestsLuma + mode_lib->vba.PTEBufferSizeInRequestsChroma;
4569                                 }
4570                                 locals->PDEAndMetaPTEBytesPerFrame[0][0][k] =
4571                                                 mode_lib->vba.PDEAndMetaPTEBytesPerFrameY + mode_lib->vba.PDEAndMetaPTEBytesPerFrameC;
4572                                 locals->MetaRowBytes[0][0][k] = mode_lib->vba.MetaRowBytesY + mode_lib->vba.MetaRowBytesC;
4573                                 locals->DPTEBytesPerRow[0][0][k] = mode_lib->vba.DPTEBytesPerRowY + mode_lib->vba.DPTEBytesPerRowC;
4574
4575                                 CalculateActiveRowBandwidth(
4576                                                 mode_lib->vba.GPUVMEnable,
4577                                                 mode_lib->vba.SourcePixelFormat[k],
4578                                                 mode_lib->vba.VRatio[k],
4579                                                 mode_lib->vba.DCCEnable[k],
4580                                                 mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
4581                                                 mode_lib->vba.MetaRowBytesY,
4582                                                 mode_lib->vba.MetaRowBytesC,
4583                                                 mode_lib->vba.meta_row_height[k],
4584                                                 mode_lib->vba.meta_row_height_chroma[k],
4585                                                 mode_lib->vba.DPTEBytesPerRowY,
4586                                                 mode_lib->vba.DPTEBytesPerRowC,
4587                                                 mode_lib->vba.dpte_row_height[k],
4588                                                 mode_lib->vba.dpte_row_height_chroma[k],
4589                                                 &mode_lib->vba.meta_row_bw[k],
4590                                                 &mode_lib->vba.dpte_row_bw[k],
4591                                                 &mode_lib->vba.qual_row_bw[k]);
4592                         }
4593                         mode_lib->vba.ExtraLatency =
4594                                         mode_lib->vba.UrgentRoundTripAndOutOfOrderLatencyPerState[i]
4595                                                         + (mode_lib->vba.TotalNumberOfActiveDPP[i][j]
4596                                                                         * mode_lib->vba.PixelChunkSizeInKByte
4597                                                                         + mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j]
4598                                                                                         * mode_lib->vba.MetaChunkSize)
4599                                                                         * 1024.0
4600                                                                         / mode_lib->vba.ReturnBWPerState[i][0];
4601                         if (mode_lib->vba.GPUVMEnable == true) {
4602                                 mode_lib->vba.ExtraLatency = mode_lib->vba.ExtraLatency
4603                                                 + mode_lib->vba.TotalNumberOfActiveDPP[i][j]
4604                                                                 * mode_lib->vba.PTEGroupSize
4605                                                                 / mode_lib->vba.ReturnBWPerState[i][0];
4606                         }
4607                         mode_lib->vba.TimeCalc = 24.0 / mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0];
4608
4609                         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4610                                 if (mode_lib->vba.BlendingAndTiming[k] == k) {
4611                                         if (mode_lib->vba.WritebackEnable[k] == true) {
4612                                                 locals->WritebackDelay[i][k] = mode_lib->vba.WritebackLatency
4613                                                                 + CalculateWriteBackDelay(
4614                                                                                 mode_lib->vba.WritebackPixelFormat[k],
4615                                                                                 mode_lib->vba.WritebackHRatio[k],
4616                                                                                 mode_lib->vba.WritebackVRatio[k],
4617                                                                                 mode_lib->vba.WritebackLumaHTaps[k],
4618                                                                                 mode_lib->vba.WritebackLumaVTaps[k],
4619                                                                                 mode_lib->vba.WritebackChromaHTaps[k],
4620                                                                                 mode_lib->vba.WritebackChromaVTaps[k],
4621                                                                                 mode_lib->vba.WritebackDestinationWidth[k]) / locals->RequiredDISPCLK[i][j];
4622                                         } else {
4623                                                 locals->WritebackDelay[i][k] = 0.0;
4624                                         }
4625                                         for (m = 0; m <= mode_lib->vba.NumberOfActivePlanes - 1; m++) {
4626                                                 if (mode_lib->vba.BlendingAndTiming[m] == k
4627                                                                 && mode_lib->vba.WritebackEnable[m]
4628                                                                                 == true) {
4629                                                         locals->WritebackDelay[i][k] = dml_max(locals->WritebackDelay[i][k],
4630                                                                                         mode_lib->vba.WritebackLatency + CalculateWriteBackDelay(
4631                                                                                                         mode_lib->vba.WritebackPixelFormat[m],
4632                                                                                                         mode_lib->vba.WritebackHRatio[m],
4633                                                                                                         mode_lib->vba.WritebackVRatio[m],
4634                                                                                                         mode_lib->vba.WritebackLumaHTaps[m],
4635                                                                                                         mode_lib->vba.WritebackLumaVTaps[m],
4636                                                                                                         mode_lib->vba.WritebackChromaHTaps[m],
4637                                                                                                         mode_lib->vba.WritebackChromaVTaps[m],
4638                                                                                                         mode_lib->vba.WritebackDestinationWidth[m]) / locals->RequiredDISPCLK[i][j]);
4639                                                 }
4640                                         }
4641                                 }
4642                         }
4643                         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4644                                 for (m = 0; m <= mode_lib->vba.NumberOfActivePlanes - 1; m++) {
4645                                         if (mode_lib->vba.BlendingAndTiming[k] == m) {
4646                                                 locals->WritebackDelay[i][k] = locals->WritebackDelay[i][m];
4647                                         }
4648                                 }
4649                         }
4650                         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4651                                 for (m = 0; m < locals->NumberOfCursors[k]; m++)
4652                                         locals->cursor_bw[k] = locals->NumberOfCursors[k] * locals->CursorWidth[k][m] * locals->CursorBPP[k][m]
4653                                                 / 8 / (locals->HTotal[k] / locals->PixelClock[k]) * locals->VRatio[k];
4654                         }
4655
4656                         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4657                                 locals->MaximumVStartup[0][0][k] = mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]
4658                                         - dml_max(1.0, dml_ceil(locals->WritebackDelay[i][k] / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]), 1.0));
4659                         }
4660
4661                         mode_lib->vba.NextPrefetchMode = mode_lib->vba.MinPrefetchMode;
4662                         do {
4663                                 mode_lib->vba.PrefetchMode[i][j] = mode_lib->vba.NextPrefetchMode;
4664                                 mode_lib->vba.NextPrefetchMode = mode_lib->vba.NextPrefetchMode + 1;
4665
4666                                 mode_lib->vba.TWait = CalculateTWait(
4667                                                 mode_lib->vba.PrefetchMode[i][j],
4668                                                 mode_lib->vba.DRAMClockChangeLatency,
4669                                                 mode_lib->vba.UrgentLatency,
4670                                                 mode_lib->vba.SREnterPlusExitTime);
4671                                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4672
4673                                         if (mode_lib->vba.XFCEnabled[k] == true) {
4674                                                 mode_lib->vba.XFCRemoteSurfaceFlipDelay =
4675                                                                 CalculateRemoteSurfaceFlipDelay(
4676                                                                                 mode_lib,
4677                                                                                 mode_lib->vba.VRatio[k],
4678                                                                                 locals->SwathWidthYPerState[i][j][k],
4679                                                                                 dml_ceil(locals->BytePerPixelInDETY[k], 1.0),
4680                                                                                 mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
4681                                                                                 mode_lib->vba.XFCTSlvVupdateOffset,
4682                                                                                 mode_lib->vba.XFCTSlvVupdateWidth,
4683                                                                                 mode_lib->vba.XFCTSlvVreadyOffset,
4684                                                                                 mode_lib->vba.XFCXBUFLatencyTolerance,
4685                                                                                 mode_lib->vba.XFCFillBWOverhead,
4686                                                                                 mode_lib->vba.XFCSlvChunkSize,
4687                                                                                 mode_lib->vba.XFCBusTransportTime,
4688                                                                                 mode_lib->vba.TimeCalc,
4689                                                                                 mode_lib->vba.TWait,
4690                                                                                 &mode_lib->vba.SrcActiveDrainRate,
4691                                                                                 &mode_lib->vba.TInitXFill,
4692                                                                                 &mode_lib->vba.TslvChk);
4693                                         } else {
4694                                                 mode_lib->vba.XFCRemoteSurfaceFlipDelay = 0.0;
4695                                         }
4696                                         mode_lib->vba.IsErrorResult[i][j][k] =
4697                                                         CalculatePrefetchSchedule(
4698                                                                         mode_lib,
4699                                                                         mode_lib->vba.RequiredDPPCLK[i][j][k],
4700                                                                         mode_lib->vba.RequiredDISPCLK[i][j],
4701                                                                         mode_lib->vba.PixelClock[k],
4702                                                                         mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0],
4703                                                                         mode_lib->vba.DSCDelayPerState[i][k],
4704                                                                         mode_lib->vba.NoOfDPP[i][j][k],
4705                                                                         mode_lib->vba.ScalerEnabled[k],
4706                                                                         mode_lib->vba.NumberOfCursors[k],
4707                                                                         mode_lib->vba.DPPCLKDelaySubtotal,
4708                                                                         mode_lib->vba.DPPCLKDelaySCL,
4709                                                                         mode_lib->vba.DPPCLKDelaySCLLBOnly,
4710                                                                         mode_lib->vba.DPPCLKDelayCNVCFormater,
4711                                                                         mode_lib->vba.DPPCLKDelayCNVCCursor,
4712                                                                         mode_lib->vba.DISPCLKDelaySubtotal,
4713                                                                         mode_lib->vba.SwathWidthYPerState[i][j][k]
4714                                                                                         / mode_lib->vba.HRatio[k],
4715                                                                         mode_lib->vba.OutputFormat[k],
4716                                                                         mode_lib->vba.VTotal[k]
4717                                                                                         - mode_lib->vba.VActive[k],
4718                                                                         mode_lib->vba.HTotal[k],
4719                                                                         mode_lib->vba.MaxInterDCNTileRepeaters,
4720                                                                         mode_lib->vba.MaximumVStartup[0][0][k],
4721                                                                         mode_lib->vba.GPUVMMaxPageTableLevels,
4722                                                                         mode_lib->vba.GPUVMEnable,
4723                                                                         mode_lib->vba.DynamicMetadataEnable[k],
4724                                                                         mode_lib->vba.DynamicMetadataLinesBeforeActiveRequired[k],
4725                                                                         mode_lib->vba.DynamicMetadataTransmittedBytes[k],
4726                                                                         mode_lib->vba.DCCEnable[k],
4727                                                                         mode_lib->vba.UrgentLatencyPixelDataOnly,
4728                                                                         mode_lib->vba.ExtraLatency,
4729                                                                         mode_lib->vba.TimeCalc,
4730                                                                         mode_lib->vba.PDEAndMetaPTEBytesPerFrame[0][0][k],
4731                                                                         mode_lib->vba.MetaRowBytes[0][0][k],
4732                                                                         mode_lib->vba.DPTEBytesPerRow[0][0][k],
4733                                                                         mode_lib->vba.PrefetchLinesY[0][0][k],
4734                                                                         mode_lib->vba.SwathWidthYPerState[i][j][k],
4735                                                                         mode_lib->vba.BytePerPixelInDETY[k],
4736                                                                         mode_lib->vba.PrefillY[k],
4737                                                                         mode_lib->vba.MaxNumSwY[k],
4738                                                                         mode_lib->vba.PrefetchLinesC[0][0][k],
4739                                                                         mode_lib->vba.BytePerPixelInDETC[k],
4740                                                                         mode_lib->vba.PrefillC[k],
4741                                                                         mode_lib->vba.MaxNumSwC[k],
4742                                                                         mode_lib->vba.SwathHeightYPerState[i][j][k],
4743                                                                         mode_lib->vba.SwathHeightCPerState[i][j][k],
4744                                                                         mode_lib->vba.TWait,
4745                                                                         mode_lib->vba.XFCEnabled[k],
4746                                                                         mode_lib->vba.XFCRemoteSurfaceFlipDelay,
4747                                                                         mode_lib->vba.Interlace[k],
4748                                                                         mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
4749                                                                         mode_lib->vba.DSTXAfterScaler,
4750                                                                         mode_lib->vba.DSTYAfterScaler,
4751                                                                         &mode_lib->vba.LineTimesForPrefetch[k],
4752                                                                         &mode_lib->vba.PrefetchBW[k],
4753                                                                         &mode_lib->vba.LinesForMetaPTE[k],
4754                                                                         &mode_lib->vba.LinesForMetaAndDPTERow[k],
4755                                                                         &mode_lib->vba.VRatioPreY[i][j][k],
4756                                                                         &mode_lib->vba.VRatioPreC[i][j][k],
4757                                                                         &mode_lib->vba.RequiredPrefetchPixelDataBWLuma[i][j][k],
4758                                                                         &mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata,
4759                                                                         &mode_lib->vba.Tno_bw[k],
4760                                                                         &mode_lib->vba.VUpdateOffsetPix[k],
4761                                                                         &mode_lib->vba.VUpdateWidthPix[k],
4762                                                                         &mode_lib->vba.VReadyOffsetPix[k]);
4763                                 }
4764                                 mode_lib->vba.MaximumReadBandwidthWithoutPrefetch = 0.0;
4765                                 mode_lib->vba.MaximumReadBandwidthWithPrefetch = 0.0;
4766                                 locals->prefetch_vm_bw_valid = true;
4767                                 locals->prefetch_row_bw_valid = true;
4768                                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4769                                         if (locals->PDEAndMetaPTEBytesPerFrame[0][0][k] == 0)
4770                                                 locals->prefetch_vm_bw[k] = 0;
4771                                         else if (locals->LinesForMetaPTE[k] > 0)
4772                                                 locals->prefetch_vm_bw[k] = locals->PDEAndMetaPTEBytesPerFrame[0][0][k]
4773                                                         / (locals->LinesForMetaPTE[k] * locals->HTotal[k] / locals->PixelClock[k]);
4774                                         else {
4775                                                 locals->prefetch_vm_bw[k] = 0;
4776                                                 locals->prefetch_vm_bw_valid = false;
4777                                         }
4778                                         if (locals->MetaRowBytes[0][0][k] + locals->DPTEBytesPerRow[0][0][k] == 0)
4779                                                 locals->prefetch_row_bw[k] = 0;
4780                                         else if (locals->LinesForMetaAndDPTERow[k] > 0)
4781                                                 locals->prefetch_row_bw[k] = (locals->MetaRowBytes[0][0][k] + locals->DPTEBytesPerRow[0][0][k])
4782                                                         / (locals->LinesForMetaAndDPTERow[k] * locals->HTotal[k] / locals->PixelClock[k]);
4783                                         else {
4784                                                 locals->prefetch_row_bw[k] = 0;
4785                                                 locals->prefetch_row_bw_valid = false;
4786                                         }
4787
4788                                         mode_lib->vba.MaximumReadBandwidthWithoutPrefetch = mode_lib->vba.MaximumReadBandwidthWithPrefetch
4789                                                         + mode_lib->vba.cursor_bw[k] + mode_lib->vba.ReadBandwidth[k] + mode_lib->vba.meta_row_bw[k] + mode_lib->vba.dpte_row_bw[k];
4790                                         mode_lib->vba.MaximumReadBandwidthWithPrefetch =
4791                                                         mode_lib->vba.MaximumReadBandwidthWithPrefetch
4792                                                                         + mode_lib->vba.cursor_bw[k]
4793                                                                         + dml_max3(
4794                                                                                         mode_lib->vba.prefetch_vm_bw[k],
4795                                                                                         mode_lib->vba.prefetch_row_bw[k],
4796                                                                                         dml_max(mode_lib->vba.ReadBandwidth[k],
4797                                                                                         mode_lib->vba.RequiredPrefetchPixelDataBWLuma[i][j][k])
4798                                                                                         + mode_lib->vba.meta_row_bw[k] + mode_lib->vba.dpte_row_bw[k]);
4799                                 }
4800                                 locals->BandwidthWithoutPrefetchSupported[i][0] = true;
4801                                 if (mode_lib->vba.MaximumReadBandwidthWithoutPrefetch > locals->ReturnBWPerState[i][0]) {
4802                                         locals->BandwidthWithoutPrefetchSupported[i][0] = false;
4803                                 }
4804
4805                                 locals->PrefetchSupported[i][j] = true;
4806                                 if (mode_lib->vba.MaximumReadBandwidthWithPrefetch > locals->ReturnBWPerState[i][0]) {
4807                                         locals->PrefetchSupported[i][j] = false;
4808                                 }
4809                                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4810                                         if (locals->LineTimesForPrefetch[k] < 2.0
4811                                                         || locals->LinesForMetaPTE[k] >= 8.0
4812                                                         || locals->LinesForMetaAndDPTERow[k] >= 16.0
4813                                                         || mode_lib->vba.IsErrorResult[i][j][k] == true) {
4814                                                 locals->PrefetchSupported[i][j] = false;
4815                                         }
4816                                 }
4817                                 locals->VRatioInPrefetchSupported[i][j] = true;
4818                                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4819                                         if (locals->VRatioPreY[i][j][k] > 4.0
4820                                                         || locals->VRatioPreC[i][j][k] > 4.0
4821                                                         || mode_lib->vba.IsErrorResult[i][j][k] == true) {
4822                                                 locals->VRatioInPrefetchSupported[i][j] = false;
4823                                         }
4824                                 }
4825                         } while ((locals->PrefetchSupported[i][j] != true || locals->VRatioInPrefetchSupported[i][j] != true)
4826                                         && mode_lib->vba.NextPrefetchMode < mode_lib->vba.MaxPrefetchMode);
4827
4828                         if (mode_lib->vba.PrefetchSupported[i][j] == true
4829                                         && mode_lib->vba.VRatioInPrefetchSupported[i][j] == true) {
4830                                 mode_lib->vba.BandwidthAvailableForImmediateFlip =
4831                                                 mode_lib->vba.ReturnBWPerState[i][0];
4832                                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4833                                         mode_lib->vba.BandwidthAvailableForImmediateFlip =
4834                                                         mode_lib->vba.BandwidthAvailableForImmediateFlip
4835                                                                         - mode_lib->vba.cursor_bw[k]
4836                                                                         - dml_max(
4837                                                                                         mode_lib->vba.ReadBandwidth[k] + mode_lib->vba.qual_row_bw[k],
4838                                                                                         mode_lib->vba.PrefetchBW[k]);
4839                                 }
4840                                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4841                                         mode_lib->vba.ImmediateFlipBytes[k] = 0.0;
4842                                         if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8
4843                                                         && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) {
4844                                                 mode_lib->vba.ImmediateFlipBytes[k] =
4845                                                                 mode_lib->vba.PDEAndMetaPTEBytesPerFrame[0][0][k]
4846                                                                                 + mode_lib->vba.MetaRowBytes[0][0][k]
4847                                                                                 + mode_lib->vba.DPTEBytesPerRow[0][0][k];
4848                                         }
4849                                 }
4850                                 mode_lib->vba.TotImmediateFlipBytes = 0.0;
4851                                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4852                                         if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8
4853                                                         && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) {
4854                                                 mode_lib->vba.TotImmediateFlipBytes =
4855                                                                 mode_lib->vba.TotImmediateFlipBytes
4856                                                                                 + mode_lib->vba.ImmediateFlipBytes[k];
4857                                         }
4858                                 }
4859
4860                                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4861                                         CalculateFlipSchedule(
4862                                                         mode_lib,
4863                                                         mode_lib->vba.ExtraLatency,
4864                                                         mode_lib->vba.UrgentLatencyPixelDataOnly,
4865                                                         mode_lib->vba.GPUVMMaxPageTableLevels,
4866                                                         mode_lib->vba.GPUVMEnable,
4867                                                         mode_lib->vba.BandwidthAvailableForImmediateFlip,
4868                                                         mode_lib->vba.TotImmediateFlipBytes,
4869                                                         mode_lib->vba.SourcePixelFormat[k],
4870                                                         mode_lib->vba.ImmediateFlipBytes[k],
4871                                                         mode_lib->vba.HTotal[k]
4872                                                                         / mode_lib->vba.PixelClock[k],
4873                                                         mode_lib->vba.VRatio[k],
4874                                                         mode_lib->vba.Tno_bw[k],
4875                                                         mode_lib->vba.PDEAndMetaPTEBytesPerFrame[0][0][k],
4876                                                         mode_lib->vba.MetaRowBytes[0][0][k],
4877                                                         mode_lib->vba.DPTEBytesPerRow[0][0][k],
4878                                                         mode_lib->vba.DCCEnable[k],
4879                                                         mode_lib->vba.dpte_row_height[k],
4880                                                         mode_lib->vba.meta_row_height[k],
4881                                                         mode_lib->vba.qual_row_bw[k],
4882                                                         &mode_lib->vba.DestinationLinesToRequestVMInImmediateFlip[k],
4883                                                         &mode_lib->vba.DestinationLinesToRequestRowInImmediateFlip[k],
4884                                                         &mode_lib->vba.final_flip_bw[k],
4885                                                         &mode_lib->vba.ImmediateFlipSupportedForPipe[k]);
4886                                 }
4887                                 mode_lib->vba.total_dcn_read_bw_with_flip = 0.0;
4888                                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4889                                         mode_lib->vba.total_dcn_read_bw_with_flip =
4890                                                         mode_lib->vba.total_dcn_read_bw_with_flip
4891                                                                         + mode_lib->vba.cursor_bw[k]
4892                                                                         + dml_max3(
4893                                                                                         mode_lib->vba.prefetch_vm_bw[k],
4894                                                                                         mode_lib->vba.prefetch_row_bw[k],
4895                                                                                         mode_lib->vba.final_flip_bw[k]
4896                                                                                                         + dml_max(
4897                                                                                                                         mode_lib->vba.ReadBandwidth[k],
4898                                                                                                                         mode_lib->vba.RequiredPrefetchPixelDataBWLuma[i][j][k]));
4899                                 }
4900                                 mode_lib->vba.ImmediateFlipSupportedForState[i][j] = true;
4901                                 if (mode_lib->vba.total_dcn_read_bw_with_flip
4902                                                 > mode_lib->vba.ReturnBWPerState[i][0]) {
4903                                         mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false;
4904                                 }
4905                                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4906                                         if (mode_lib->vba.ImmediateFlipSupportedForPipe[k] == false) {
4907                                                 mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false;
4908                                         }
4909                                 }
4910                         } else {
4911                                 mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false;
4912                         }
4913                 }
4914         }
4915
4916         /*Vertical Active BW support*/
4917         mode_lib->vba.MaxTotalVActiveRDBandwidth = 0;
4918         for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; k++)
4919                 mode_lib->vba.MaxTotalVActiveRDBandwidth = mode_lib->vba.MaxTotalVActiveRDBandwidth + mode_lib->vba.ReadBandwidth[k];
4920         for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4921                 mode_lib->vba.MaxTotalVerticalActiveAvailableBandwidth[i][0] = dml_min(mode_lib->vba.ReturnBusWidth *
4922                                 mode_lib->vba.DCFCLKPerState[i], mode_lib->vba.FabricAndDRAMBandwidthPerState[i] * 1000) *
4923                                 mode_lib->vba.MaxAveragePercentOfIdealDRAMBWDisplayCanUseInNormalSystemOperation / 100;
4924                 if (mode_lib->vba.MaxTotalVActiveRDBandwidth <= mode_lib->vba.MaxTotalVerticalActiveAvailableBandwidth[i][0])
4925                         mode_lib->vba.TotalVerticalActiveBandwidthSupport[i][0] = true;
4926                 else
4927                         mode_lib->vba.TotalVerticalActiveBandwidthSupport[i][0] = false;
4928         }
4929
4930         /*PTE Buffer Size Check*/
4931
4932         for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4933                 for (j = 0; j < 2; j++) {
4934                         locals->PTEBufferSizeNotExceeded[i][j] = true;
4935                         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4936                                 if (locals->PTEBufferSizeNotExceededY[i][j][k] == false
4937                                                 || locals->PTEBufferSizeNotExceededC[i][j][k] == false) {
4938                                         locals->PTEBufferSizeNotExceeded[i][j] = false;
4939                                 }
4940                         }
4941                 }
4942         }
4943         /*Cursor Support Check*/
4944         mode_lib->vba.CursorSupport = true;
4945         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4946                 for (j = 0; j < 2; j++) {
4947                         if (mode_lib->vba.CursorWidth[k][j] > 0.0) {
4948                                 if (dml_floor(
4949                                                 dml_floor(
4950                                                                 mode_lib->vba.CursorBufferSize
4951                                                                                 - mode_lib->vba.CursorChunkSize,
4952                                                                 mode_lib->vba.CursorChunkSize) * 1024.0
4953                                                                 / (mode_lib->vba.CursorWidth[k][j]
4954                                                                                 * mode_lib->vba.CursorBPP[k][j]
4955                                                                                 / 8.0),
4956                                                 1.0)
4957                                                 * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k])
4958                                                 / mode_lib->vba.VRatio[k] < mode_lib->vba.UrgentLatencyPixelDataOnly
4959                                                 || (mode_lib->vba.CursorBPP[k][j] == 64.0
4960                                                                 && mode_lib->vba.Cursor64BppSupport == false)) {
4961                                         mode_lib->vba.CursorSupport = false;
4962                                 }
4963                         }
4964                 }
4965         }
4966         /*Valid Pitch Check*/
4967
4968         mode_lib->vba.PitchSupport = true;
4969         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4970                 locals->AlignedYPitch[k] = dml_ceil(
4971                                 dml_max(mode_lib->vba.PitchY[k], mode_lib->vba.ViewportWidth[k]),
4972                                 locals->MacroTileWidthY[k]);
4973                 if (locals->AlignedYPitch[k] > mode_lib->vba.PitchY[k]) {
4974                         mode_lib->vba.PitchSupport = false;
4975                 }
4976                 if (mode_lib->vba.DCCEnable[k] == true) {
4977                         locals->AlignedDCCMetaPitch[k] = dml_ceil(
4978                                         dml_max(
4979                                                         mode_lib->vba.DCCMetaPitchY[k],
4980                                                         mode_lib->vba.ViewportWidth[k]),
4981                                         64.0 * locals->Read256BlockWidthY[k]);
4982                 } else {
4983                         locals->AlignedDCCMetaPitch[k] = mode_lib->vba.DCCMetaPitchY[k];
4984                 }
4985                 if (locals->AlignedDCCMetaPitch[k] > mode_lib->vba.DCCMetaPitchY[k]) {
4986                         mode_lib->vba.PitchSupport = false;
4987                 }
4988                 if (mode_lib->vba.SourcePixelFormat[k] != dm_444_64
4989                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
4990                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
4991                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
4992                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8) {
4993                         locals->AlignedCPitch[k] = dml_ceil(
4994                                         dml_max(
4995                                                         mode_lib->vba.PitchC[k],
4996                                                         mode_lib->vba.ViewportWidth[k] / 2.0),
4997                                         locals->MacroTileWidthC[k]);
4998                 } else {
4999                         locals->AlignedCPitch[k] = mode_lib->vba.PitchC[k];
5000                 }
5001                 if (locals->AlignedCPitch[k] > mode_lib->vba.PitchC[k]) {
5002                         mode_lib->vba.PitchSupport = false;
5003                 }
5004         }
5005         /*Mode Support, Voltage State and SOC Configuration*/
5006
5007         for (i = mode_lib->vba.soc.num_states; i >= 0; i--) {
5008                 for (j = 0; j < 2; j++) {
5009                         enum dm_validation_status status = DML_VALIDATION_OK;
5010
5011                         if (mode_lib->vba.ScaleRatioAndTapsSupport != true) {
5012                                 status = DML_FAIL_SCALE_RATIO_TAP;
5013                         } else if (mode_lib->vba.SourceFormatPixelAndScanSupport != true) {
5014                                 status = DML_FAIL_SOURCE_PIXEL_FORMAT;
5015                         } else if (locals->ViewportSizeSupport[i][0] != true) {
5016                                 status = DML_FAIL_VIEWPORT_SIZE;
5017                         } else if (locals->DIOSupport[i] != true) {
5018                                 status = DML_FAIL_DIO_SUPPORT;
5019                         } else if (locals->NotEnoughDSCUnits[i] != false) {
5020                                 status = DML_FAIL_NOT_ENOUGH_DSC;
5021                         } else if (locals->DSCCLKRequiredMoreThanSupported[i] != false) {
5022                                 status = DML_FAIL_DSC_CLK_REQUIRED;
5023                         } else if (locals->UrgentLatencySupport[i][j] != true) {
5024                                 status = DML_FAIL_URGENT_LATENCY;
5025                         } else if (locals->ROBSupport[i][0] != true) {
5026                                 status = DML_FAIL_REORDERING_BUFFER;
5027                         } else if (locals->DISPCLK_DPPCLK_Support[i][j] != true) {
5028                                 status = DML_FAIL_DISPCLK_DPPCLK;
5029                         } else if (locals->TotalAvailablePipesSupport[i][j] != true) {
5030                                 status = DML_FAIL_TOTAL_AVAILABLE_PIPES;
5031                         } else if (mode_lib->vba.NumberOfOTGSupport != true) {
5032                                 status = DML_FAIL_NUM_OTG;
5033                         } else if (mode_lib->vba.WritebackModeSupport != true) {
5034                                 status = DML_FAIL_WRITEBACK_MODE;
5035                         } else if (mode_lib->vba.WritebackLatencySupport != true) {
5036                                 status = DML_FAIL_WRITEBACK_LATENCY;
5037                         } else if (mode_lib->vba.WritebackScaleRatioAndTapsSupport != true) {
5038                                 status = DML_FAIL_WRITEBACK_SCALE_RATIO_TAP;
5039                         } else if (mode_lib->vba.CursorSupport != true) {
5040                                 status = DML_FAIL_CURSOR_SUPPORT;
5041                         } else if (mode_lib->vba.PitchSupport != true) {
5042                                 status = DML_FAIL_PITCH_SUPPORT;
5043                         } else if (locals->PrefetchSupported[i][j] != true) {
5044                                 status = DML_FAIL_PREFETCH_SUPPORT;
5045                         } else if (locals->TotalVerticalActiveBandwidthSupport[i][0] != true) {
5046                                 status = DML_FAIL_TOTAL_V_ACTIVE_BW;
5047                         } else if (locals->VRatioInPrefetchSupported[i][j] != true) {
5048                                 status = DML_FAIL_V_RATIO_PREFETCH;
5049                         } else if (locals->PTEBufferSizeNotExceeded[i][j] != true) {
5050                                 status = DML_FAIL_PTE_BUFFER_SIZE;
5051                         } else if (mode_lib->vba.NonsupportedDSCInputBPC != false) {
5052                                 status = DML_FAIL_DSC_INPUT_BPC;
5053                         }
5054
5055                         if (status == DML_VALIDATION_OK) {
5056                                 locals->ModeSupport[i][j] = true;
5057                         } else {
5058                                 locals->ModeSupport[i][j] = false;
5059                         }
5060                         locals->ValidationStatus[i] = status;
5061                 }
5062         }
5063         {
5064                 unsigned int MaximumMPCCombine = 0;
5065                 mode_lib->vba.VoltageLevel = mode_lib->vba.soc.num_states + 1;
5066                 for (i = mode_lib->vba.VoltageOverrideLevel; i <= mode_lib->vba.soc.num_states; i++) {
5067                         if (locals->ModeSupport[i][0] == true || locals->ModeSupport[i][1] == true) {
5068                                 mode_lib->vba.VoltageLevel = i;
5069                                 if (locals->ModeSupport[i][1] == true && (locals->ModeSupport[i][0] == false
5070                                                 || mode_lib->vba.WhenToDoMPCCombine == dm_mpc_always_when_possible)) {
5071                                         MaximumMPCCombine = 1;
5072                                 } else {
5073                                         MaximumMPCCombine = 0;
5074                                 }
5075                                 break;
5076                         }
5077                 }
5078                 mode_lib->vba.ImmediateFlipSupport =
5079                         locals->ImmediateFlipSupportedForState[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
5080                 for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
5081                         mode_lib->vba.DPPPerPlane[k] = locals->NoOfDPP[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
5082                         locals->DPPCLK[k] = locals->RequiredDPPCLK[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
5083                 }
5084                 mode_lib->vba.DISPCLK = locals->RequiredDISPCLK[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
5085                 mode_lib->vba.maxMpcComb = MaximumMPCCombine;
5086         }
5087         mode_lib->vba.DCFCLK = mode_lib->vba.DCFCLKPerState[mode_lib->vba.VoltageLevel];
5088         mode_lib->vba.DRAMSpeed = mode_lib->vba.DRAMSpeedPerState[mode_lib->vba.VoltageLevel];
5089         mode_lib->vba.FabricClock = mode_lib->vba.FabricClockPerState[mode_lib->vba.VoltageLevel];
5090         mode_lib->vba.SOCCLK = mode_lib->vba.SOCCLKPerState[mode_lib->vba.VoltageLevel];
5091         mode_lib->vba.ReturnBW = locals->ReturnBWPerState[mode_lib->vba.VoltageLevel][0];
5092         mode_lib->vba.FabricAndDRAMBandwidth = locals->FabricAndDRAMBandwidthPerState[mode_lib->vba.VoltageLevel];
5093         for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
5094                 if (mode_lib->vba.BlendingAndTiming[k] == k) {
5095                         mode_lib->vba.ODMCombineEnabled[k] =
5096                                         locals->ODMCombineEnablePerState[mode_lib->vba.VoltageLevel][k];
5097                 } else {
5098                         mode_lib->vba.ODMCombineEnabled[k] = 0;
5099                 }
5100                 mode_lib->vba.DSCEnabled[k] =
5101                                 locals->RequiresDSC[mode_lib->vba.VoltageLevel][k];
5102                 mode_lib->vba.OutputBpp[k] =
5103                                 locals->OutputBppPerState[mode_lib->vba.VoltageLevel][k];
5104         }
5105 }