LXR linux/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_mode_vba

   1/*
   2 * Copyright 2018 Advanced Micro Devices, Inc.
   3 *
   4 * Permission is hereby granted, free of charge, to any person obtaining a
   5 * copy of this software and associated documentation files (the "Software"),
   6 * to deal in the Software without restriction, including without limitation
   7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8 * and/or sell copies of the Software, and to permit persons to whom the
   9 * Software is furnished to do so, subject to the following conditions:
  10 *
  11 * The above copyright notice and this permission notice shall be included in
  12 * all copies or substantial portions of the Software.
  13 *
  14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20 * OTHER DEALINGS IN THE SOFTWARE.
  21 *
  22 * Authors: AMD
  23 *
  24 */
  25
  26#include "../display_mode_lib.h"
  27#include "display_mode_vba_20v2.h"
  28#include "../dml_inline_defs.h"
  29
  30/*
  31 * NOTE:
  32 *   This file is gcc-parseable HW gospel, coming straight from HW engineers.
  33 *
  34 * It doesn't adhere to Linux kernel style and sometimes will do things in odd
  35 * ways. Unless there is something clearly wrong with it the code should
  36 * remain as-is as it provides us with a guarantee from HW that it is correct.
  37 */
  38
  39#define BPP_INVALID 0
  40#define BPP_BLENDED_PIPE 0xffffffff
  41#define DCN20_MAX_DSC_IMAGE_WIDTH 5184
  42#define DCN20_MAX_420_IMAGE_WIDTH 4096
  43
  44static double adjust_ReturnBW(
  45                struct display_mode_lib *mode_lib,
  46                double ReturnBW,
  47                bool DCCEnabledAnyPlane,
  48                double ReturnBandwidthToDCN);
  49static unsigned int dscceComputeDelay(
  50                unsigned int bpc,
  51                double bpp,
  52                unsigned int sliceWidth,
  53                unsigned int numSlices,
  54                enum output_format_class pixelFormat);
  55static unsigned int dscComputeDelay(enum output_format_class pixelFormat);
  56static bool CalculateDelayAfterScaler(
  57                struct display_mode_lib *mode_lib,
  58                double ReturnBW,
  59                double ReadBandwidthPlaneLuma,
  60                double ReadBandwidthPlaneChroma,
  61                double TotalDataReadBandwidth,
  62                double DisplayPipeLineDeliveryTimeLuma,
  63                double DisplayPipeLineDeliveryTimeChroma,
  64                double DPPCLK,
  65                double DISPCLK,
  66                double PixelClock,
  67                unsigned int DSCDelay,
  68                unsigned int DPPPerPlane,
  69                bool ScalerEnabled,
  70                unsigned int NumberOfCursors,
  71                double DPPCLKDelaySubtotal,
  72                double DPPCLKDelaySCL,
  73                double DPPCLKDelaySCLLBOnly,
  74                double DPPCLKDelayCNVCFormater,
  75                double DPPCLKDelayCNVCCursor,
  76                double DISPCLKDelaySubtotal,
  77                unsigned int ScalerRecoutWidth,
  78                enum output_format_class OutputFormat,
  79                unsigned int HTotal,
  80                unsigned int SwathWidthSingleDPPY,
  81                double BytePerPixelDETY,
  82                double BytePerPixelDETC,
  83                unsigned int SwathHeightY,
  84                unsigned int SwathHeightC,
  85                bool Interlace,
  86                bool ProgressiveToInterlaceUnitInOPP,
  87                double *DSTXAfterScaler,
  88                double *DSTYAfterScaler
  89                );
  90// Super monster function with some 45 argument
  91static bool CalculatePrefetchSchedule(
  92                struct display_mode_lib *mode_lib,
  93                double DPPCLK,
  94                double DISPCLK,
  95                double PixelClock,
  96                double DCFCLKDeepSleep,
  97                unsigned int DPPPerPlane,
  98                unsigned int NumberOfCursors,
  99                unsigned int VBlank,
 100                unsigned int HTotal,
 101                unsigned int MaxInterDCNTileRepeaters,
 102                unsigned int VStartup,
 103                unsigned int PageTableLevels,
 104                bool GPUVMEnable,
 105                bool DynamicMetadataEnable,
 106                unsigned int DynamicMetadataLinesBeforeActiveRequired,
 107                unsigned int DynamicMetadataTransmittedBytes,
 108                bool DCCEnable,
 109                double UrgentLatencyPixelDataOnly,
 110                double UrgentExtraLatency,
 111                double TCalc,
 112                unsigned int PDEAndMetaPTEBytesFrame,
 113                unsigned int MetaRowByte,
 114                unsigned int PixelPTEBytesPerRow,
 115                double PrefetchSourceLinesY,
 116                unsigned int SwathWidthY,
 117                double BytePerPixelDETY,
 118                double VInitPreFillY,
 119                unsigned int MaxNumSwathY,
 120                double PrefetchSourceLinesC,
 121                double BytePerPixelDETC,
 122                double VInitPreFillC,
 123                unsigned int MaxNumSwathC,
 124                unsigned int SwathHeightY,
 125                unsigned int SwathHeightC,
 126                double TWait,
 127                bool XFCEnabled,
 128                double XFCRemoteSurfaceFlipDelay,
 129                bool InterlaceEnable,
 130                bool ProgressiveToInterlaceUnitInOPP,
 131                double DSTXAfterScaler,
 132                double DSTYAfterScaler,
 133                double *DestinationLinesForPrefetch,
 134                double *PrefetchBandwidth,
 135                double *DestinationLinesToRequestVMInVBlank,
 136                double *DestinationLinesToRequestRowInVBlank,
 137                double *VRatioPrefetchY,
 138                double *VRatioPrefetchC,
 139                double *RequiredPrefetchPixDataBW,
 140                double *Tno_bw,
 141                unsigned int *VUpdateOffsetPix,
 142                double *VUpdateWidthPix,
 143                double *VReadyOffsetPix);
 144static double RoundToDFSGranularityUp(double Clock, double VCOSpeed);
 145static double RoundToDFSGranularityDown(double Clock, double VCOSpeed);
 146static double CalculatePrefetchSourceLines(
 147                struct display_mode_lib *mode_lib,
 148                double VRatio,
 149                double vtaps,
 150                bool Interlace,
 151                bool ProgressiveToInterlaceUnitInOPP,
 152                unsigned int SwathHeight,
 153                unsigned int ViewportYStart,
 154                double *VInitPreFill,
 155                unsigned int *MaxNumSwath);
 156static unsigned int CalculateVMAndRowBytes(
 157                struct display_mode_lib *mode_lib,
 158                bool DCCEnable,
 159                unsigned int BlockHeight256Bytes,
 160                unsigned int BlockWidth256Bytes,
 161                enum source_format_class SourcePixelFormat,
 162                unsigned int SurfaceTiling,
 163                unsigned int BytePerPixel,
 164                enum scan_direction_class ScanDirection,
 165                unsigned int ViewportWidth,
 166                unsigned int ViewportHeight,
 167                unsigned int SwathWidthY,
 168                bool GPUVMEnable,
 169                unsigned int VMMPageSize,
 170                unsigned int PTEBufferSizeInRequestsLuma,
 171                unsigned int PDEProcessingBufIn64KBReqs,
 172                unsigned int Pitch,
 173                unsigned int DCCMetaPitch,
 174                unsigned int *MacroTileWidth,
 175                unsigned int *MetaRowByte,
 176                unsigned int *PixelPTEBytesPerRow,
 177                bool *PTEBufferSizeNotExceeded,
 178                unsigned int *dpte_row_height,
 179                unsigned int *meta_row_height);
 180static double CalculateTWait(
 181                unsigned int PrefetchMode,
 182                double DRAMClockChangeLatency,
 183                double UrgentLatencyPixelDataOnly,
 184                double SREnterPlusExitTime);
 185static double CalculateRemoteSurfaceFlipDelay(
 186                struct display_mode_lib *mode_lib,
 187                double VRatio,
 188                double SwathWidth,
 189                double Bpp,
 190                double LineTime,
 191                double XFCTSlvVupdateOffset,
 192                double XFCTSlvVupdateWidth,
 193                double XFCTSlvVreadyOffset,
 194                double XFCXBUFLatencyTolerance,
 195                double XFCFillBWOverhead,
 196                double XFCSlvChunkSize,
 197                double XFCBusTransportTime,
 198                double TCalc,
 199                double TWait,
 200                double *SrcActiveDrainRate,
 201                double *TInitXFill,
 202                double *TslvChk);
 203static void CalculateActiveRowBandwidth(
 204                bool GPUVMEnable,
 205                enum source_format_class SourcePixelFormat,
 206                double VRatio,
 207                bool DCCEnable,
 208                double LineTime,
 209                unsigned int MetaRowByteLuma,
 210                unsigned int MetaRowByteChroma,
 211                unsigned int meta_row_height_luma,
 212                unsigned int meta_row_height_chroma,
 213                unsigned int PixelPTEBytesPerRowLuma,
 214                unsigned int PixelPTEBytesPerRowChroma,
 215                unsigned int dpte_row_height_luma,
 216                unsigned int dpte_row_height_chroma,
 217                double *meta_row_bw,
 218                double *dpte_row_bw,
 219                double *qual_row_bw);
 220static void CalculateFlipSchedule(
 221                struct display_mode_lib *mode_lib,
 222                double UrgentExtraLatency,
 223                double UrgentLatencyPixelDataOnly,
 224                unsigned int GPUVMMaxPageTableLevels,
 225                bool GPUVMEnable,
 226                double BandwidthAvailableForImmediateFlip,
 227                unsigned int TotImmediateFlipBytes,
 228                enum source_format_class SourcePixelFormat,
 229                unsigned int ImmediateFlipBytes,
 230                double LineTime,
 231                double VRatio,
 232                double Tno_bw,
 233                double PDEAndMetaPTEBytesFrame,
 234                unsigned int MetaRowByte,
 235                unsigned int PixelPTEBytesPerRow,
 236                bool DCCEnable,
 237                unsigned int dpte_row_height,
 238                unsigned int meta_row_height,
 239                double qual_row_bw,
 240                double *DestinationLinesToRequestVMInImmediateFlip,
 241                double *DestinationLinesToRequestRowInImmediateFlip,
 242                double *final_flip_bw,
 243                bool *ImmediateFlipSupportedForPipe);
 244static double CalculateWriteBackDelay(
 245                enum source_format_class WritebackPixelFormat,
 246                double WritebackHRatio,
 247                double WritebackVRatio,
 248                unsigned int WritebackLumaHTaps,
 249                unsigned int WritebackLumaVTaps,
 250                unsigned int WritebackChromaHTaps,
 251                unsigned int WritebackChromaVTaps,
 252                unsigned int WritebackDestinationWidth);
 253
 254static void dml20v2_DisplayPipeConfiguration(struct display_mode_lib *mode_lib);
 255static void dml20v2_DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(
 256                struct display_mode_lib *mode_lib);
 257
 258void dml20v2_recalculate(struct display_mode_lib *mode_lib)
 259{
 260        ModeSupportAndSystemConfiguration(mode_lib);
 261        mode_lib->vba.FabricAndDRAMBandwidth = dml_min(
 262                mode_lib->vba.DRAMSpeed * mode_lib->vba.NumberOfChannels * mode_lib->vba.DRAMChannelWidth,
 263                mode_lib->vba.FabricClock * mode_lib->vba.FabricDatapathToDCNDataReturn) / 1000.0;
 264        PixelClockAdjustmentForProgressiveToInterlaceUnit(mode_lib);
 265        dml20v2_DisplayPipeConfiguration(mode_lib);
 266        dml20v2_DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(mode_lib);
 267}
 268
 269static double adjust_ReturnBW(
 270                struct display_mode_lib *mode_lib,
 271                double ReturnBW,
 272                bool DCCEnabledAnyPlane,
 273                double ReturnBandwidthToDCN)
 274{
 275        double CriticalCompression;
 276
 277        if (DCCEnabledAnyPlane
 278                        && ReturnBandwidthToDCN
 279                                        > mode_lib->vba.DCFCLK * mode_lib->vba.ReturnBusWidth / 4.0)
 280                ReturnBW =
 281                                dml_min(
 282                                                ReturnBW,
 283                                                ReturnBandwidthToDCN * 4
 284                                                                * (1.0
 285                                                                                - mode_lib->vba.UrgentLatencyPixelDataOnly
 286                                                                                                / ((mode_lib->vba.ROBBufferSizeInKByte
 287                                                                                                                - mode_lib->vba.PixelChunkSizeInKByte)
 288                                                                                                                * 1024
 289                                                                                                                / ReturnBandwidthToDCN
 290                                                                                                                - mode_lib->vba.DCFCLK
 291                                                                                                                                * mode_lib->vba.ReturnBusWidth
 292                                                                                                                                / 4)
 293                                                                                + mode_lib->vba.UrgentLatencyPixelDataOnly));
 294
 295        CriticalCompression = 2.0 * mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLK
 296                        * mode_lib->vba.UrgentLatencyPixelDataOnly
 297                        / (ReturnBandwidthToDCN * mode_lib->vba.UrgentLatencyPixelDataOnly
 298                                        + (mode_lib->vba.ROBBufferSizeInKByte
 299                                                        - mode_lib->vba.PixelChunkSizeInKByte)
 300                                                        * 1024);
 301
 302        if (DCCEnabledAnyPlane && CriticalCompression > 1.0 && CriticalCompression < 4.0)
 303                ReturnBW =
 304                                dml_min(
 305                                                ReturnBW,
 306                                                4.0 * ReturnBandwidthToDCN
 307                                                                * (mode_lib->vba.ROBBufferSizeInKByte
 308                                                                                - mode_lib->vba.PixelChunkSizeInKByte)
 309                                                                * 1024
 310                                                                * mode_lib->vba.ReturnBusWidth
 311                                                                * mode_lib->vba.DCFCLK
 312                                                                * mode_lib->vba.UrgentLatencyPixelDataOnly
 313                                                                / dml_pow(
 314                                                                                (ReturnBandwidthToDCN
 315                                                                                                * mode_lib->vba.UrgentLatencyPixelDataOnly
 316                                                                                                + (mode_lib->vba.ROBBufferSizeInKByte
 317                                                                                                                - mode_lib->vba.PixelChunkSizeInKByte)
 318                                                                                                                * 1024),
 319                                                                                2));
 320
 321        return ReturnBW;
 322}
 323
 324static unsigned int dscceComputeDelay(
 325                unsigned int bpc,
 326                double bpp,
 327                unsigned int sliceWidth,
 328                unsigned int numSlices,
 329                enum output_format_class pixelFormat)
 330{
 331        // valid bpc         = source bits per component in the set of {8, 10, 12}
 332        // valid bpp         = increments of 1/16 of a bit
 333        //                    min = 6/7/8 in N420/N422/444, respectively
 334        //                    max = such that compression is 1:1
 335        //valid sliceWidth  = number of pixels per slice line, must be less than or equal to 5184/numSlices (or 4096/numSlices in 420 mode)
 336        //valid numSlices   = number of slices in the horiziontal direction per DSC engine in the set of {1, 2, 3, 4}
 337        //valid pixelFormat = pixel/color format in the set of {:N444_RGB, :S422, :N422, :N420}
 338
 339        // fixed value
 340        unsigned int rcModelSize = 8192;
 341
 342        // N422/N420 operate at 2 pixels per clock
 343        unsigned int pixelsPerClock, lstall, D, initalXmitDelay, w, s, ix, wx, p, l0, a, ax, l,
 344                        Delay, pixels;
 345
 346        if (pixelFormat == dm_n422 || pixelFormat == dm_420)
 347                pixelsPerClock = 2;
 348        // #all other modes operate at 1 pixel per clock
 349        else
 350                pixelsPerClock = 1;
 351
 352        //initial transmit delay as per PPS
 353        initalXmitDelay = dml_round(rcModelSize / 2.0 / bpp / pixelsPerClock);
 354
 355        //compute ssm delay
 356        if (bpc == 8)
 357                D = 81;
 358        else if (bpc == 10)
 359                D = 89;
 360        else
 361                D = 113;
 362
 363        //divide by pixel per cycle to compute slice width as seen by DSC
 364        w = sliceWidth / pixelsPerClock;
 365
 366        //422 mode has an additional cycle of delay
 367        if (pixelFormat == dm_s422)
 368                s = 1;
 369        else
 370                s = 0;
 371
 372        //main calculation for the dscce
 373        ix = initalXmitDelay + 45;
 374        wx = (w + 2) / 3;
 375        p = 3 * wx - w;
 376        l0 = ix / w;
 377        a = ix + p * l0;
 378        ax = (a + 2) / 3 + D + 6 + 1;
 379        l = (ax + wx - 1) / wx;
 380        if ((ix % w) == 0 && p != 0)
 381                lstall = 1;
 382        else
 383                lstall = 0;
 384        Delay = l * wx * (numSlices - 1) + ax + s + lstall + 22;
 385
 386        //dsc processes 3 pixel containers per cycle and a container can contain 1 or 2 pixels
 387        pixels = Delay * 3 * pixelsPerClock;
 388        return pixels;
 389}
 390
 391static unsigned int dscComputeDelay(enum output_format_class pixelFormat)
 392{
 393        unsigned int Delay = 0;
 394
 395        if (pixelFormat == dm_420) {
 396                //   sfr
 397                Delay = Delay + 2;
 398                //   dsccif
 399                Delay = Delay + 0;
 400                //   dscc - input deserializer
 401                Delay = Delay + 3;
 402                //   dscc gets pixels every other cycle
 403                Delay = Delay + 2;
 404                //   dscc - input cdc fifo
 405                Delay = Delay + 12;
 406                //   dscc gets pixels every other cycle
 407                Delay = Delay + 13;
 408                //   dscc - cdc uncertainty
 409                Delay = Delay + 2;
 410                //   dscc - output cdc fifo
 411                Delay = Delay + 7;
 412                //   dscc gets pixels every other cycle
 413                Delay = Delay + 3;
 414                //   dscc - cdc uncertainty
 415                Delay = Delay + 2;
 416                //   dscc - output serializer
 417                Delay = Delay + 1;
 418                //   sft
 419                Delay = Delay + 1;
 420        } else if (pixelFormat == dm_n422) {
 421                //   sfr
 422                Delay = Delay + 2;
 423                //   dsccif
 424                Delay = Delay + 1;
 425                //   dscc - input deserializer
 426                Delay = Delay + 5;
 427                //  dscc - input cdc fifo
 428                Delay = Delay + 25;
 429                //   dscc - cdc uncertainty
 430                Delay = Delay + 2;
 431                //   dscc - output cdc fifo
 432                Delay = Delay + 10;
 433                //   dscc - cdc uncertainty
 434                Delay = Delay + 2;
 435                //   dscc - output serializer
 436                Delay = Delay + 1;
 437                //   sft
 438                Delay = Delay + 1;
 439        } else {
 440                //   sfr
 441                Delay = Delay + 2;
 442                //   dsccif
 443                Delay = Delay + 0;
 444                //   dscc - input deserializer
 445                Delay = Delay + 3;
 446                //   dscc - input cdc fifo
 447                Delay = Delay + 12;
 448                //   dscc - cdc uncertainty
 449                Delay = Delay + 2;
 450                //   dscc - output cdc fifo
 451                Delay = Delay + 7;
 452                //   dscc - output serializer
 453                Delay = Delay + 1;
 454                //   dscc - cdc uncertainty
 455                Delay = Delay + 2;
 456                //   sft
 457                Delay = Delay + 1;
 458        }
 459
 460        return Delay;
 461}
 462
 463static bool CalculateDelayAfterScaler(
 464                struct display_mode_lib *mode_lib,
 465                double ReturnBW,
 466                double ReadBandwidthPlaneLuma,
 467                double ReadBandwidthPlaneChroma,
 468                double TotalDataReadBandwidth,
 469                double DisplayPipeLineDeliveryTimeLuma,
 470                double DisplayPipeLineDeliveryTimeChroma,
 471                double DPPCLK,
 472                double DISPCLK,
 473                double PixelClock,
 474                unsigned int DSCDelay,
 475                unsigned int DPPPerPlane,
 476                bool ScalerEnabled,
 477                unsigned int NumberOfCursors,
 478                double DPPCLKDelaySubtotal,
 479                double DPPCLKDelaySCL,
 480                double DPPCLKDelaySCLLBOnly,
 481                double DPPCLKDelayCNVCFormater,
 482                double DPPCLKDelayCNVCCursor,
 483                double DISPCLKDelaySubtotal,
 484                unsigned int ScalerRecoutWidth,
 485                enum output_format_class OutputFormat,
 486                unsigned int HTotal,
 487                unsigned int SwathWidthSingleDPPY,
 488                double BytePerPixelDETY,
 489                double BytePerPixelDETC,
 490                unsigned int SwathHeightY,
 491                unsigned int SwathHeightC,
 492                bool Interlace,
 493                bool ProgressiveToInterlaceUnitInOPP,
 494                double *DSTXAfterScaler,
 495                double *DSTYAfterScaler
 496                )
 497{
 498        unsigned int DPPCycles, DISPCLKCycles;
 499        double DataFabricLineDeliveryTimeLuma;
 500        double DataFabricLineDeliveryTimeChroma;
 501        double DSTTotalPixelsAfterScaler;
 502
 503        DataFabricLineDeliveryTimeLuma = SwathWidthSingleDPPY * SwathHeightY * dml_ceil(BytePerPixelDETY, 1) / (mode_lib->vba.ReturnBW * ReadBandwidthPlaneLuma / TotalDataReadBandwidth);
 504        mode_lib->vba.LastPixelOfLineExtraWatermark = dml_max(mode_lib->vba.LastPixelOfLineExtraWatermark, DataFabricLineDeliveryTimeLuma - DisplayPipeLineDeliveryTimeLuma);
 505
 506        if (BytePerPixelDETC != 0) {
 507                DataFabricLineDeliveryTimeChroma = SwathWidthSingleDPPY / 2 * SwathHeightC * dml_ceil(BytePerPixelDETC, 2) / (mode_lib->vba.ReturnBW * ReadBandwidthPlaneChroma / TotalDataReadBandwidth);
 508                mode_lib->vba.LastPixelOfLineExtraWatermark = dml_max(mode_lib->vba.LastPixelOfLineExtraWatermark, DataFabricLineDeliveryTimeChroma - DisplayPipeLineDeliveryTimeChroma);
 509        }
 510
 511        if (ScalerEnabled)
 512                DPPCycles = DPPCLKDelaySubtotal + DPPCLKDelaySCL;
 513        else
 514                DPPCycles = DPPCLKDelaySubtotal + DPPCLKDelaySCLLBOnly;
 515
 516        DPPCycles = DPPCycles + DPPCLKDelayCNVCFormater + NumberOfCursors * DPPCLKDelayCNVCCursor;
 517
 518        DISPCLKCycles = DISPCLKDelaySubtotal;
 519
 520        if (DPPCLK == 0.0 || DISPCLK == 0.0)
 521                return true;
 522
 523        *DSTXAfterScaler = DPPCycles * PixelClock / DPPCLK + DISPCLKCycles * PixelClock / DISPCLK
 524                        + DSCDelay;
 525
 526        if (DPPPerPlane > 1)
 527                *DSTXAfterScaler = *DSTXAfterScaler + ScalerRecoutWidth;
 528
 529        if (OutputFormat == dm_420 || (Interlace && ProgressiveToInterlaceUnitInOPP))
 530                *DSTYAfterScaler = 1;
 531        else
 532                *DSTYAfterScaler = 0;
 533
 534        DSTTotalPixelsAfterScaler = ((double) (*DSTYAfterScaler * HTotal)) + *DSTXAfterScaler;
 535        *DSTYAfterScaler = dml_floor(DSTTotalPixelsAfterScaler / HTotal, 1);
 536        *DSTXAfterScaler = DSTTotalPixelsAfterScaler - ((double) (*DSTYAfterScaler * HTotal));
 537
 538        return true;
 539}
 540
 541static bool CalculatePrefetchSchedule(
 542                struct display_mode_lib *mode_lib,
 543                double DPPCLK,
 544                double DISPCLK,
 545                double PixelClock,
 546                double DCFCLKDeepSleep,
 547                unsigned int DPPPerPlane,
 548                unsigned int NumberOfCursors,
 549                unsigned int VBlank,
 550                unsigned int HTotal,
 551                unsigned int MaxInterDCNTileRepeaters,
 552                unsigned int VStartup,
 553                unsigned int PageTableLevels,
 554                bool GPUVMEnable,
 555                bool DynamicMetadataEnable,
 556                unsigned int DynamicMetadataLinesBeforeActiveRequired,
 557                unsigned int DynamicMetadataTransmittedBytes,
 558                bool DCCEnable,
 559                double UrgentLatencyPixelDataOnly,
 560                double UrgentExtraLatency,
 561                double TCalc,
 562                unsigned int PDEAndMetaPTEBytesFrame,
 563                unsigned int MetaRowByte,
 564                unsigned int PixelPTEBytesPerRow,
 565                double PrefetchSourceLinesY,
 566                unsigned int SwathWidthY,
 567                double BytePerPixelDETY,
 568                double VInitPreFillY,
 569                unsigned int MaxNumSwathY,
 570                double PrefetchSourceLinesC,
 571                double BytePerPixelDETC,
 572                double VInitPreFillC,
 573                unsigned int MaxNumSwathC,
 574                unsigned int SwathHeightY,
 575                unsigned int SwathHeightC,
 576                double TWait,
 577                bool XFCEnabled,
 578                double XFCRemoteSurfaceFlipDelay,
 579                bool InterlaceEnable,
 580                bool ProgressiveToInterlaceUnitInOPP,
 581                double DSTXAfterScaler,
 582                double DSTYAfterScaler,
 583                double *DestinationLinesForPrefetch,
 584                double *PrefetchBandwidth,
 585                double *DestinationLinesToRequestVMInVBlank,
 586                double *DestinationLinesToRequestRowInVBlank,
 587                double *VRatioPrefetchY,
 588                double *VRatioPrefetchC,
 589                double *RequiredPrefetchPixDataBW,
 590                double *Tno_bw,
 591                unsigned int *VUpdateOffsetPix,
 592                double *VUpdateWidthPix,
 593                double *VReadyOffsetPix)
 594{
 595        bool MyError = false;
 596        double TotalRepeaterDelayTime;
 597        double Tdm, LineTime, Tsetup;
 598        double dst_y_prefetch_equ;
 599        double Tsw_oto;
 600        double prefetch_bw_oto;
 601        double Tvm_oto;
 602        double Tr0_oto;
 603        double Tpre_oto;
 604        double dst_y_prefetch_oto;
 605        double TimeForFetchingMetaPTE = 0;
 606        double TimeForFetchingRowInVBlank = 0;
 607        double LinesToRequestPrefetchPixelData = 0;
 608
 609        *VUpdateOffsetPix = dml_ceil(HTotal / 4.0, 1);
 610        TotalRepeaterDelayTime = MaxInterDCNTileRepeaters * (2.0 / DPPCLK + 3.0 / DISPCLK);
 611        *VUpdateWidthPix = (14.0 / DCFCLKDeepSleep + 12.0 / DPPCLK + TotalRepeaterDelayTime)
 612                        * PixelClock;
 613
 614        *VReadyOffsetPix = dml_max(
 615                        150.0 / DPPCLK,
 616                        TotalRepeaterDelayTime + 20.0 / DCFCLKDeepSleep + 10.0 / DPPCLK)
 617                        * PixelClock;
 618
 619        Tsetup = (double) (*VUpdateOffsetPix + *VUpdateWidthPix + *VReadyOffsetPix) / PixelClock;
 620
 621        LineTime = (double) HTotal / PixelClock;
 622
 623        if (DynamicMetadataEnable) {
 624                double Tdmbf, Tdmec, Tdmsks;
 625
 626                Tdm = dml_max(0.0, UrgentExtraLatency - TCalc);
 627                Tdmbf = DynamicMetadataTransmittedBytes / 4.0 / DISPCLK;
 628                Tdmec = LineTime;
 629                if (DynamicMetadataLinesBeforeActiveRequired == 0)
 630                        Tdmsks = VBlank * LineTime / 2.0;
 631                else
 632                        Tdmsks = DynamicMetadataLinesBeforeActiveRequired * LineTime;
 633                if (InterlaceEnable && !ProgressiveToInterlaceUnitInOPP)
 634                        Tdmsks = Tdmsks / 2;
 635                if (VStartup * LineTime
 636                                < Tsetup + TWait + UrgentExtraLatency + Tdmbf + Tdmec + Tdmsks) {
 637                        MyError = true;
 638                }
 639        } else
 640                Tdm = 0;
 641
 642        if (GPUVMEnable) {
 643                if (PageTableLevels == 4)
 644                        *Tno_bw = UrgentExtraLatency + UrgentLatencyPixelDataOnly;
 645                else if (PageTableLevels == 3)
 646                        *Tno_bw = UrgentExtraLatency;
 647                else
 648                        *Tno_bw = 0;
 649        } else if (DCCEnable)
 650                *Tno_bw = LineTime;
 651        else
 652                *Tno_bw = LineTime / 4;
 653
 654        dst_y_prefetch_equ = VStartup - dml_max(TCalc + TWait, XFCRemoteSurfaceFlipDelay) / LineTime
 655                        - (Tsetup + Tdm) / LineTime
 656                        - (DSTYAfterScaler + DSTXAfterScaler / HTotal);
 657
 658        Tsw_oto = dml_max(PrefetchSourceLinesY, PrefetchSourceLinesC) * LineTime;
 659
 660        prefetch_bw_oto = (MetaRowByte + PixelPTEBytesPerRow
 661                        + PrefetchSourceLinesY * SwathWidthY * dml_ceil(BytePerPixelDETY, 1)
 662                        + PrefetchSourceLinesC * SwathWidthY / 2 * dml_ceil(BytePerPixelDETC, 2))
 663                        / Tsw_oto;
 664
 665        if (GPUVMEnable == true) {
 666                Tvm_oto =
 667                                dml_max(
 668                                                *Tno_bw + PDEAndMetaPTEBytesFrame / prefetch_bw_oto,
 669                                                dml_max(
 670                                                                UrgentExtraLatency
 671                                                                                + UrgentLatencyPixelDataOnly
 672                                                                                                * (PageTableLevels
 673                                                                                                                - 1),
 674                                                                LineTime / 4.0));
 675        } else
 676                Tvm_oto = LineTime / 4.0;
 677
 678        if ((GPUVMEnable == true || DCCEnable == true)) {
 679                Tr0_oto = dml_max(
 680                                (MetaRowByte + PixelPTEBytesPerRow) / prefetch_bw_oto,
 681                                dml_max(UrgentLatencyPixelDataOnly, dml_max(LineTime - Tvm_oto, LineTime / 4)));
 682        } else
 683                Tr0_oto = LineTime - Tvm_oto;
 684
 685        Tpre_oto = Tvm_oto + Tr0_oto + Tsw_oto;
 686
 687        dst_y_prefetch_oto = Tpre_oto / LineTime;
 688
 689        if (dst_y_prefetch_oto < dst_y_prefetch_equ)
 690                *DestinationLinesForPrefetch = dst_y_prefetch_oto;
 691        else
 692                *DestinationLinesForPrefetch = dst_y_prefetch_equ;
 693
 694        *DestinationLinesForPrefetch = dml_floor(4.0 * (*DestinationLinesForPrefetch + 0.125), 1)
 695                        / 4;
 696
 697        dml_print("DML: VStartup: %d\n", VStartup);
 698        dml_print("DML: TCalc: %f\n", TCalc);
 699        dml_print("DML: TWait: %f\n", TWait);
 700        dml_print("DML: XFCRemoteSurfaceFlipDelay: %f\n", XFCRemoteSurfaceFlipDelay);
 701        dml_print("DML: LineTime: %f\n", LineTime);
 702        dml_print("DML: Tsetup: %f\n", Tsetup);
 703        dml_print("DML: Tdm: %f\n", Tdm);
 704        dml_print("DML: DSTYAfterScaler: %f\n", DSTYAfterScaler);
 705        dml_print("DML: DSTXAfterScaler: %f\n", DSTXAfterScaler);
 706        dml_print("DML: HTotal: %d\n", HTotal);
 707
 708        *PrefetchBandwidth = 0;
 709        *DestinationLinesToRequestVMInVBlank = 0;
 710        *DestinationLinesToRequestRowInVBlank = 0;
 711        *VRatioPrefetchY = 0;
 712        *VRatioPrefetchC = 0;
 713        *RequiredPrefetchPixDataBW = 0;
 714        if (*DestinationLinesForPrefetch > 1) {
 715                *PrefetchBandwidth = (PDEAndMetaPTEBytesFrame + 2 * MetaRowByte
 716                                + 2 * PixelPTEBytesPerRow
 717                                + PrefetchSourceLinesY * SwathWidthY * dml_ceil(BytePerPixelDETY, 1)
 718                                + PrefetchSourceLinesC * SwathWidthY / 2
 719                                                * dml_ceil(BytePerPixelDETC, 2))
 720                                / (*DestinationLinesForPrefetch * LineTime - *Tno_bw);
 721                if (GPUVMEnable) {
 722                        TimeForFetchingMetaPTE =
 723                                        dml_max(
 724                                                        *Tno_bw
 725                                                                        + (double) PDEAndMetaPTEBytesFrame
 726                                                                                        / *PrefetchBandwidth,
 727                                                        dml_max(
 728                                                                        UrgentExtraLatency
 729                                                                                        + UrgentLatencyPixelDataOnly
 730                                                                                                        * (PageTableLevels
 731                                                                                                                        - 1),
 732                                                                        LineTime / 4));
 733                } else {
 734                        if (NumberOfCursors > 0 || XFCEnabled)
 735                                TimeForFetchingMetaPTE = LineTime / 4;
 736                        else
 737                                TimeForFetchingMetaPTE = 0.0;
 738                }
 739
 740                if ((GPUVMEnable == true || DCCEnable == true)) {
 741                        TimeForFetchingRowInVBlank =
 742                                        dml_max(
 743                                                        (MetaRowByte + PixelPTEBytesPerRow)
 744                                                                        / *PrefetchBandwidth,
 745                                                        dml_max(
 746                                                                        UrgentLatencyPixelDataOnly,
 747                                                                        dml_max(
 748                                                                                        LineTime
 749                                                                                                        - TimeForFetchingMetaPTE,
 750                                                                                        LineTime
 751                                                                                                        / 4.0)));
 752                } else {
 753                        if (NumberOfCursors > 0 || XFCEnabled)
 754                                TimeForFetchingRowInVBlank = LineTime - TimeForFetchingMetaPTE;
 755                        else
 756                                TimeForFetchingRowInVBlank = 0.0;
 757                }
 758
 759                *DestinationLinesToRequestVMInVBlank = dml_floor(
 760                                4.0 * (TimeForFetchingMetaPTE / LineTime + 0.125),
 761                                1) / 4.0;
 762
 763                *DestinationLinesToRequestRowInVBlank = dml_floor(
 764                                4.0 * (TimeForFetchingRowInVBlank / LineTime + 0.125),
 765                                1) / 4.0;
 766
 767                LinesToRequestPrefetchPixelData =
 768                                *DestinationLinesForPrefetch
 769                                                - ((NumberOfCursors > 0 || GPUVMEnable
 770                                                                || DCCEnable) ?
 771                                                                (*DestinationLinesToRequestVMInVBlank
 772                                                                                + *DestinationLinesToRequestRowInVBlank) :
 773                                                                0.0);
 774
 775                if (LinesToRequestPrefetchPixelData > 0) {
 776
 777                        *VRatioPrefetchY = (double) PrefetchSourceLinesY
 778                                        / LinesToRequestPrefetchPixelData;
 779                        *VRatioPrefetchY = dml_max(*VRatioPrefetchY, 1.0);
 780                        if ((SwathHeightY > 4) && (VInitPreFillY > 3)) {
 781                                if (LinesToRequestPrefetchPixelData > (VInitPreFillY - 3.0) / 2.0) {
 782                                        *VRatioPrefetchY =
 783                                                        dml_max(
 784                                                                        (double) PrefetchSourceLinesY
 785                                                                                        / LinesToRequestPrefetchPixelData,
 786                                                                        (double) MaxNumSwathY
 787                                                                                        * SwathHeightY
 788                                                                                        / (LinesToRequestPrefetchPixelData
 789                                                                                                        - (VInitPreFillY
 790                                                                                                                        - 3.0)
 791                                                                                                                        / 2.0));
 792                                        *VRatioPrefetchY = dml_max(*VRatioPrefetchY, 1.0);
 793                                } else {
 794                                        MyError = true;
 795                                        *VRatioPrefetchY = 0;
 796                                }
 797                        }
 798
 799                        *VRatioPrefetchC = (double) PrefetchSourceLinesC
 800                                        / LinesToRequestPrefetchPixelData;
 801                        *VRatioPrefetchC = dml_max(*VRatioPrefetchC, 1.0);
 802
 803                        if ((SwathHeightC > 4)) {
 804                                if (LinesToRequestPrefetchPixelData > (VInitPreFillC - 3.0) / 2.0) {
 805                                        *VRatioPrefetchC =
 806                                                        dml_max(
 807                                                                        *VRatioPrefetchC,
 808                                                                        (double) MaxNumSwathC
 809                                                                                        * SwathHeightC
 810                                                                                        / (LinesToRequestPrefetchPixelData
 811                                                                                                        - (VInitPreFillC
 812                                                                                                                        - 3.0)
 813                                                                                                                        / 2.0));
 814                                        *VRatioPrefetchC = dml_max(*VRatioPrefetchC, 1.0);
 815                                } else {
 816                                        MyError = true;
 817                                        *VRatioPrefetchC = 0;
 818                                }
 819                        }
 820
 821                        *RequiredPrefetchPixDataBW =
 822                                        DPPPerPlane
 823                                                        * ((double) PrefetchSourceLinesY
 824                                                                        / LinesToRequestPrefetchPixelData
 825                                                                        * dml_ceil(
 826                                                                                        BytePerPixelDETY,
 827                                                                                        1)
 828                                                                        + (double) PrefetchSourceLinesC
 829                                                                                        / LinesToRequestPrefetchPixelData
 830                                                                                        * dml_ceil(
 831                                                                                                        BytePerPixelDETC,
 832                                                                                                        2)
 833                                                                                        / 2)
 834                                                        * SwathWidthY / LineTime;
 835                } else {
 836                        MyError = true;
 837                        *VRatioPrefetchY = 0;
 838                        *VRatioPrefetchC = 0;
 839                        *RequiredPrefetchPixDataBW = 0;
 840                }
 841
 842        } else {
 843                MyError = true;
 844        }
 845
 846        if (MyError) {
 847                *PrefetchBandwidth = 0;
 848                TimeForFetchingMetaPTE = 0;
 849                TimeForFetchingRowInVBlank = 0;
 850                *DestinationLinesToRequestVMInVBlank = 0;
 851                *DestinationLinesToRequestRowInVBlank = 0;
 852                *DestinationLinesForPrefetch = 0;
 853                LinesToRequestPrefetchPixelData = 0;
 854                *VRatioPrefetchY = 0;
 855                *VRatioPrefetchC = 0;
 856                *RequiredPrefetchPixDataBW = 0;
 857        }
 858
 859        return MyError;
 860}
 861
 862static double RoundToDFSGranularityUp(double Clock, double VCOSpeed)
 863{
 864        return VCOSpeed * 4 / dml_floor(VCOSpeed * 4 / Clock, 1);
 865}
 866
 867static double RoundToDFSGranularityDown(double Clock, double VCOSpeed)
 868{
 869        return VCOSpeed * 4 / dml_ceil(VCOSpeed * 4 / Clock, 1);
 870}
 871
 872static double CalculatePrefetchSourceLines(
 873                struct display_mode_lib *mode_lib,
 874                double VRatio,
 875                double vtaps,
 876                bool Interlace,
 877                bool ProgressiveToInterlaceUnitInOPP,
 878                unsigned int SwathHeight,
 879                unsigned int ViewportYStart,
 880                double *VInitPreFill,
 881                unsigned int *MaxNumSwath)
 882{
 883        unsigned int MaxPartialSwath;
 884
 885        if (ProgressiveToInterlaceUnitInOPP)
 886                *VInitPreFill = dml_floor((VRatio + vtaps + 1) / 2.0, 1);
 887        else
 888                *VInitPreFill = dml_floor((VRatio + vtaps + 1 + Interlace * 0.5 * VRatio) / 2.0, 1);
 889
 890        if (!mode_lib->vba.IgnoreViewportPositioning) {
 891
 892                *MaxNumSwath = dml_ceil((*VInitPreFill - 1.0) / SwathHeight, 1) + 1.0;
 893
 894                if (*VInitPreFill > 1.0)
 895                        MaxPartialSwath = (unsigned int) (*VInitPreFill - 2) % SwathHeight;
 896                else
 897                        MaxPartialSwath = (unsigned int) (*VInitPreFill + SwathHeight - 2)
 898                                        % SwathHeight;
 899                MaxPartialSwath = dml_max(1U, MaxPartialSwath);
 900
 901        } else {
 902
 903                if (ViewportYStart != 0)
 904                        dml_print(
 905                                        "WARNING DML: using viewport y position of 0 even though actual viewport y position is non-zero in prefetch source lines calculation\n");
 906
 907                *MaxNumSwath = dml_ceil(*VInitPreFill / SwathHeight, 1);
 908
 909                if (*VInitPreFill > 1.0)
 910                        MaxPartialSwath = (unsigned int) (*VInitPreFill - 1) % SwathHeight;
 911                else
 912                        MaxPartialSwath = (unsigned int) (*VInitPreFill + SwathHeight - 1)
 913                                        % SwathHeight;
 914        }
 915
 916        return *MaxNumSwath * SwathHeight + MaxPartialSwath;
 917}
 918
 919static unsigned int CalculateVMAndRowBytes(
 920                struct display_mode_lib *mode_lib,
 921                bool DCCEnable,
 922                unsigned int BlockHeight256Bytes,
 923                unsigned int BlockWidth256Bytes,
 924                enum source_format_class SourcePixelFormat,
 925                unsigned int SurfaceTiling,
 926                unsigned int BytePerPixel,
 927                enum scan_direction_class ScanDirection,
 928                unsigned int ViewportWidth,
 929                unsigned int ViewportHeight,
 930                unsigned int SwathWidth,
 931                bool GPUVMEnable,
 932                unsigned int VMMPageSize,
 933                unsigned int PTEBufferSizeInRequestsLuma,
 934                unsigned int PDEProcessingBufIn64KBReqs,
 935                unsigned int Pitch,
 936                unsigned int DCCMetaPitch,
 937                unsigned int *MacroTileWidth,
 938                unsigned int *MetaRowByte,
 939                unsigned int *PixelPTEBytesPerRow,
 940                bool *PTEBufferSizeNotExceeded,
 941                unsigned int *dpte_row_height,
 942                unsigned int *meta_row_height)
 943{
 944        unsigned int MetaRequestHeight;
 945        unsigned int MetaRequestWidth;
 946        unsigned int MetaSurfWidth;
 947        unsigned int MetaSurfHeight;
 948        unsigned int MPDEBytesFrame;
 949        unsigned int MetaPTEBytesFrame;
 950        unsigned int DCCMetaSurfaceBytes;
 951
 952        unsigned int MacroTileSizeBytes;
 953        unsigned int MacroTileHeight;
 954        unsigned int DPDE0BytesFrame;
 955        unsigned int ExtraDPDEBytesFrame;
 956        unsigned int PDEAndMetaPTEBytesFrame;
 957
 958        if (DCCEnable == true) {
 959                MetaRequestHeight = 8 * BlockHeight256Bytes;
 960                MetaRequestWidth = 8 * BlockWidth256Bytes;
 961                if (ScanDirection == dm_horz) {
 962                        *meta_row_height = MetaRequestHeight;
 963                        MetaSurfWidth = dml_ceil((double) SwathWidth - 1, MetaRequestWidth)
 964                                        + MetaRequestWidth;
 965                        *MetaRowByte = MetaSurfWidth * MetaRequestHeight * BytePerPixel / 256.0;
 966                } else {
 967                        *meta_row_height = MetaRequestWidth;
 968                        MetaSurfHeight = dml_ceil((double) SwathWidth - 1, MetaRequestHeight)
 969                                        + MetaRequestHeight;
 970                        *MetaRowByte = MetaSurfHeight * MetaRequestWidth * BytePerPixel / 256.0;
 971                }
 972                if (ScanDirection == dm_horz) {
 973                        DCCMetaSurfaceBytes = DCCMetaPitch
 974                                        * (dml_ceil(ViewportHeight - 1, 64 * BlockHeight256Bytes)
 975                                                        + 64 * BlockHeight256Bytes) * BytePerPixel
 976                                        / 256;
 977                } else {
 978                        DCCMetaSurfaceBytes = DCCMetaPitch
 979                                        * (dml_ceil(
 980                                                        (double) ViewportHeight - 1,
 981                                                        64 * BlockHeight256Bytes)
 982                                                        + 64 * BlockHeight256Bytes) * BytePerPixel
 983                                        / 256;
 984                }
 985                if (GPUVMEnable == true) {
 986                        MetaPTEBytesFrame = (dml_ceil(
 987                                        (double) (DCCMetaSurfaceBytes - VMMPageSize)
 988                                                        / (8 * VMMPageSize),
 989                                        1) + 1) * 64;
 990                        MPDEBytesFrame = 128 * (mode_lib->vba.GPUVMMaxPageTableLevels - 1);
 991                } else {
 992                        MetaPTEBytesFrame = 0;
 993                        MPDEBytesFrame = 0;
 994                }
 995        } else {
 996                MetaPTEBytesFrame = 0;
 997                MPDEBytesFrame = 0;
 998                *MetaRowByte = 0;
 999        }
1000

1001        if (SurfaceTiling == dm_sw_linear || SurfaceTiling == dm_sw_gfx7_2d_thin_gl || SurfaceTiling == dm_sw_gfx7_2d_thin_l_vp) {
1002                MacroTileSizeBytes = 256;
1003                MacroTileHeight = BlockHeight256Bytes;
1004        } else if (SurfaceTiling == dm_sw_4kb_s || SurfaceTiling == dm_sw_4kb_s_x
1005                        || SurfaceTiling == dm_sw_4kb_d || SurfaceTiling == dm_sw_4kb_d_x) {
1006                MacroTileSizeBytes = 4096;
1007                MacroTileHeight = 4 * BlockHeight256Bytes;
1008        } else if (SurfaceTiling == dm_sw_64kb_s || SurfaceTiling == dm_sw_64kb_s_t
1009                        || SurfaceTiling == dm_sw_64kb_s_x || SurfaceTiling == dm_sw_64kb_d
1010                        || SurfaceTiling == dm_sw_64kb_d_t || SurfaceTiling == dm_sw_64kb_d_x
1011                        || SurfaceTiling == dm_sw_64kb_r_x) {
1012                MacroTileSizeBytes = 65536;
1013                MacroTileHeight = 16 * BlockHeight256Bytes;
1014        } else {
1015                MacroTileSizeBytes = 262144;
1016                MacroTileHeight = 32 * BlockHeight256Bytes;
1017        }
1018        *MacroTileWidth = MacroTileSizeBytes / BytePerPixel / MacroTileHeight;
1019
1020        if (GPUVMEnable == true && mode_lib->vba.GPUVMMaxPageTableLevels > 1) {
1021                if (ScanDirection == dm_horz) {
1022                        DPDE0BytesFrame =
1023                                        64
1024                                                        * (dml_ceil(
1025                                                                        ((Pitch
1026                                                                                        * (dml_ceil(
1027                                                                                                        ViewportHeight
1028                                                                                                                        - 1,
1029                                                                                                        MacroTileHeight)
1030                                                                                                        + MacroTileHeight)
1031                                                                                        * BytePerPixel)
1032                                                                                        - MacroTileSizeBytes)
1033                                                                                        / (8
1034                                                                                                        * 2097152),
1035                                                                        1) + 1);
1036                } else {
1037                        DPDE0BytesFrame =
1038                                        64
1039                                                        * (dml_ceil(
1040                                                                        ((Pitch
1041                                                                                        * (dml_ceil(
1042                                                                                                        (double) SwathWidth
1043                                                                                                                        - 1,
1044                                                                                                        MacroTileHeight)
1045                                                                                                        + MacroTileHeight)
1046                                                                                        * BytePerPixel)
1047                                                                                        - MacroTileSizeBytes)
1048                                                                                        / (8
1049                                                                                                        * 2097152),
1050                                                                        1) + 1);
1051                }
1052                ExtraDPDEBytesFrame = 128 * (mode_lib->vba.GPUVMMaxPageTableLevels - 2);
1053        } else {
1054                DPDE0BytesFrame = 0;
1055                ExtraDPDEBytesFrame = 0;
1056        }
1057
1058        PDEAndMetaPTEBytesFrame = MetaPTEBytesFrame + MPDEBytesFrame + DPDE0BytesFrame
1059                        + ExtraDPDEBytesFrame;
1060
1061        if (GPUVMEnable == true) {
1062                unsigned int PTERequestSize;
1063                unsigned int PixelPTEReqHeight;
1064                unsigned int PixelPTEReqWidth;
1065                double FractionOfPTEReturnDrop;
1066                unsigned int EffectivePDEProcessingBufIn64KBReqs;
1067
1068                if (SurfaceTiling == dm_sw_linear) {
1069                        PixelPTEReqHeight = 1;
1070                        PixelPTEReqWidth = 8.0 * VMMPageSize / BytePerPixel;
1071                        PTERequestSize = 64;
1072                        FractionOfPTEReturnDrop = 0;
1073                } else if (MacroTileSizeBytes == 4096) {
1074                        PixelPTEReqHeight = MacroTileHeight;
1075                        PixelPTEReqWidth = 8 * *MacroTileWidth;
1076                        PTERequestSize = 64;
1077                        if (ScanDirection == dm_horz)
1078                                FractionOfPTEReturnDrop = 0;
1079                        else
1080                                FractionOfPTEReturnDrop = 7 / 8;
1081                } else if (VMMPageSize == 4096 && MacroTileSizeBytes > 4096) {
1082                        PixelPTEReqHeight = 16 * BlockHeight256Bytes;
1083                        PixelPTEReqWidth = 16 * BlockWidth256Bytes;
1084                        PTERequestSize = 128;
1085                        FractionOfPTEReturnDrop = 0;
1086                } else {
1087                        PixelPTEReqHeight = MacroTileHeight;
1088                        PixelPTEReqWidth = 8 * *MacroTileWidth;
1089                        PTERequestSize = 64;
1090                        FractionOfPTEReturnDrop = 0;
1091                }
1092
1093                if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10)
1094                        EffectivePDEProcessingBufIn64KBReqs = PDEProcessingBufIn64KBReqs / 2;
1095                else
1096                        EffectivePDEProcessingBufIn64KBReqs = PDEProcessingBufIn64KBReqs;
1097
1098                if (SurfaceTiling == dm_sw_linear) {
1099                        *dpte_row_height =
1100                                        dml_min(
1101                                                        128,
1102                                                        1
1103                                                                        << (unsigned int) dml_floor(
1104                                                                                        dml_log2(
1105                                                                                                        dml_min(
1106                                                                                                                        (double) PTEBufferSizeInRequestsLuma
1107                                                                                                                                        * PixelPTEReqWidth,
1108                                                                                                                        EffectivePDEProcessingBufIn64KBReqs
1109                                                                                                                                        * 65536.0
1110                                                                                                                                        / BytePerPixel)
1111                                                                                                                        / Pitch),
1112                                                                                        1));
1113                        *PixelPTEBytesPerRow = PTERequestSize
1114                                        * (dml_ceil(
1115                                                        (double) (Pitch * *dpte_row_height - 1)
1116                                                                        / PixelPTEReqWidth,
1117                                                        1) + 1);
1118                } else if (ScanDirection == dm_horz) {
1119                        *dpte_row_height = PixelPTEReqHeight;
1120                        *PixelPTEBytesPerRow = PTERequestSize
1121                                        * (dml_ceil(((double) SwathWidth - 1) / PixelPTEReqWidth, 1)
1122                                                        + 1);
1123                } else {
1124                        *dpte_row_height = dml_min(PixelPTEReqWidth, *MacroTileWidth);
1125                        *PixelPTEBytesPerRow = PTERequestSize
1126                                        * (dml_ceil(
1127                                                        ((double) SwathWidth - 1)
1128                                                                        / PixelPTEReqHeight,
1129                                                        1) + 1);
1130                }
1131                if (*PixelPTEBytesPerRow * (1 - FractionOfPTEReturnDrop)
1132                                <= 64 * PTEBufferSizeInRequestsLuma) {
1133                        *PTEBufferSizeNotExceeded = true;
1134                } else {
1135                        *PTEBufferSizeNotExceeded = false;
1136                }
1137        } else {
1138                *PixelPTEBytesPerRow = 0;
1139                *PTEBufferSizeNotExceeded = true;
1140        }
1141
1142        return PDEAndMetaPTEBytesFrame;
1143}
1144
1145static void dml20v2_DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(
1146                struct display_mode_lib *mode_lib)
1147{
1148        unsigned int j, k;
1149
1150        mode_lib->vba.WritebackDISPCLK = 0.0;
1151        mode_lib->vba.DISPCLKWithRamping = 0;
1152        mode_lib->vba.DISPCLKWithoutRamping = 0;
1153        mode_lib->vba.GlobalDPPCLK = 0.0;
1154
1155        // dml_ml->vba.DISPCLK and dml_ml->vba.DPPCLK Calculation
1156        //
1157        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1158                if (mode_lib->vba.WritebackEnable[k]) {
1159                        mode_lib->vba.WritebackDISPCLK =
1160                                        dml_max(
1161                                                        mode_lib->vba.WritebackDISPCLK,
1162                                                        CalculateWriteBackDISPCLK(
1163                                                                        mode_lib->vba.WritebackPixelFormat[k],
1164                                                                        mode_lib->vba.PixelClock[k],
1165                                                                        mode_lib->vba.WritebackHRatio[k],
1166                                                                        mode_lib->vba.WritebackVRatio[k],
1167                                                                        mode_lib->vba.WritebackLumaHTaps[k],
1168                                                                        mode_lib->vba.WritebackLumaVTaps[k],
1169                                                                        mode_lib->vba.WritebackChromaHTaps[k],
1170                                                                        mode_lib->vba.WritebackChromaVTaps[k],
1171                                                                        mode_lib->vba.WritebackDestinationWidth[k],
1172                                                                        mode_lib->vba.HTotal[k],
1173                                                                        mode_lib->vba.WritebackChromaLineBufferWidth));
1174                }
1175        }
1176
1177        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1178                if (mode_lib->vba.HRatio[k] > 1) {
1179                        mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] = dml_min(
1180                                        mode_lib->vba.MaxDCHUBToPSCLThroughput,
1181                                        mode_lib->vba.MaxPSCLToLBThroughput
1182                                                        * mode_lib->vba.HRatio[k]
1183                                                        / dml_ceil(
1184                                                                        mode_lib->vba.htaps[k]
1185                                                                                        / 6.0,
1186                                                                        1));
1187                } else {
1188                        mode_lib->vba.PSCL_THROUGHPUT_LUMA[k] = dml_min(
1189                                        mode_lib->vba.MaxDCHUBToPSCLThroughput,
1190                                        mode_lib->vba.MaxPSCLToLBThroughput);
1191                }
1192
1193                mode_lib->vba.DPPCLKUsingSingleDPPLuma =
1194                                mode_lib->vba.PixelClock[k]
1195                                                * dml_max(
1196                                                                mode_lib->vba.vtaps[k] / 6.0
1197                                                                                * dml_min(
1198                                                                                                1.0,
1199                                                                                                mode_lib->vba.HRatio[k]),
1200                                                                dml_max(
1201                                                                                mode_lib->vba.HRatio[k]
1202                                                                                                * mode_lib->vba.VRatio[k]
1203                                                                                                / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k],
1204                                                                                1.0));
1205
1206                if ((mode_lib->vba.htaps[k] > 6 || mode_lib->vba.vtaps[k] > 6)
1207                                && mode_lib->vba.DPPCLKUsingSingleDPPLuma
1208                                                < 2 * mode_lib->vba.PixelClock[k]) {
1209                        mode_lib->vba.DPPCLKUsingSingleDPPLuma = 2 * mode_lib->vba.PixelClock[k];
1210                }
1211
1212                if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8
1213                                && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) {
1214                        mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] = 0.0;
1215                        mode_lib->vba.DPPCLKUsingSingleDPP[k] =
1216                                        mode_lib->vba.DPPCLKUsingSingleDPPLuma;
1217                } else {
1218                        if (mode_lib->vba.HRatio[k] > 1) {
1219                                mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] =
1220                                                dml_min(
1221                                                                mode_lib->vba.MaxDCHUBToPSCLThroughput,
1222                                                                mode_lib->vba.MaxPSCLToLBThroughput
1223                                                                                * mode_lib->vba.HRatio[k]
1224                                                                                / 2
1225                                                                                / dml_ceil(
1226                                                                                                mode_lib->vba.HTAPsChroma[k]
1227                                                                                                                / 6.0,
1228                                                                                                1.0));
1229                        } else {
1230                                mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k] = dml_min(
1231                                                mode_lib->vba.MaxDCHUBToPSCLThroughput,
1232                                                mode_lib->vba.MaxPSCLToLBThroughput);
1233                        }
1234                        mode_lib->vba.DPPCLKUsingSingleDPPChroma =
1235                                        mode_lib->vba.PixelClock[k]
1236                                                        * dml_max(
1237                                                                        mode_lib->vba.VTAPsChroma[k]
1238                                                                                        / 6.0
1239                                                                                        * dml_min(
1240                                                                                                        1.0,
1241                                                                                                        mode_lib->vba.HRatio[k]
1242                                                                                                                        / 2),
1243                                                                        dml_max(
1244                                                                                        mode_lib->vba.HRatio[k]
1245                                                                                                        * mode_lib->vba.VRatio[k]
1246                                                                                                        / 4
1247                                                                                                        / mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k],
1248                                                                                        1.0));
1249
1250                        if ((mode_lib->vba.HTAPsChroma[k] > 6 || mode_lib->vba.VTAPsChroma[k] > 6)
1251                                        && mode_lib->vba.DPPCLKUsingSingleDPPChroma
1252                                                        < 2 * mode_lib->vba.PixelClock[k]) {
1253                                mode_lib->vba.DPPCLKUsingSingleDPPChroma = 2
1254                                                * mode_lib->vba.PixelClock[k];
1255                        }
1256
1257                        mode_lib->vba.DPPCLKUsingSingleDPP[k] = dml_max(
1258                                        mode_lib->vba.DPPCLKUsingSingleDPPLuma,
1259                                        mode_lib->vba.DPPCLKUsingSingleDPPChroma);
1260                }
1261        }
1262
1263        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1264                if (mode_lib->vba.BlendingAndTiming[k] != k)
1265                        continue;
1266                if (mode_lib->vba.ODMCombineEnabled[k]) {
1267                        mode_lib->vba.DISPCLKWithRamping =
1268                                        dml_max(
1269                                                        mode_lib->vba.DISPCLKWithRamping,
1270                                                        mode_lib->vba.PixelClock[k] / 2
1271                                                                        * (1
1272                                                                                        + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading
1273                                                                                                        / 100)
1274                                                                        * (1
1275                                                                                        + mode_lib->vba.DISPCLKRampingMargin
1276                                                                                                        / 100));
1277                        mode_lib->vba.DISPCLKWithoutRamping =
1278                                        dml_max(
1279                                                        mode_lib->vba.DISPCLKWithoutRamping,
1280                                                        mode_lib->vba.PixelClock[k] / 2
1281                                                                        * (1
1282                                                                                        + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading
1283                                                                                                        / 100));
1284                } else if (!mode_lib->vba.ODMCombineEnabled[k]) {
1285                        mode_lib->vba.DISPCLKWithRamping =
1286                                        dml_max(
1287                                                        mode_lib->vba.DISPCLKWithRamping,
1288                                                        mode_lib->vba.PixelClock[k]
1289                                                                        * (1
1290                                                                                        + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading
1291                                                                                                        / 100)
1292                                                                        * (1
1293                                                                                        + mode_lib->vba.DISPCLKRampingMargin
1294                                                                                                        / 100));
1295                        mode_lib->vba.DISPCLKWithoutRamping =
1296                                        dml_max(
1297                                                        mode_lib->vba.DISPCLKWithoutRamping,
1298                                                        mode_lib->vba.PixelClock[k]
1299                                                                        * (1
1300                                                                                        + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading
1301                                                                                                        / 100));
1302                }
1303        }
1304
1305        mode_lib->vba.DISPCLKWithRamping = dml_max(
1306                        mode_lib->vba.DISPCLKWithRamping,
1307                        mode_lib->vba.WritebackDISPCLK);
1308        mode_lib->vba.DISPCLKWithoutRamping = dml_max(
1309                        mode_lib->vba.DISPCLKWithoutRamping,
1310                        mode_lib->vba.WritebackDISPCLK);
1311
1312        ASSERT(mode_lib->vba.DISPCLKDPPCLKVCOSpeed != 0);
1313        mode_lib->vba.DISPCLKWithRampingRoundedToDFSGranularity = RoundToDFSGranularityUp(
1314                        mode_lib->vba.DISPCLKWithRamping,
1315                        mode_lib->vba.DISPCLKDPPCLKVCOSpeed);
1316        mode_lib->vba.DISPCLKWithoutRampingRoundedToDFSGranularity = RoundToDFSGranularityUp(
1317                        mode_lib->vba.DISPCLKWithoutRamping,
1318                        mode_lib->vba.DISPCLKDPPCLKVCOSpeed);
1319        mode_lib->vba.MaxDispclkRoundedToDFSGranularity = RoundToDFSGranularityDown(
1320                        mode_lib->vba.soc.clock_limits[mode_lib->vba.soc.num_states].dispclk_mhz,
1321                        mode_lib->vba.DISPCLKDPPCLKVCOSpeed);
1322        if (mode_lib->vba.DISPCLKWithoutRampingRoundedToDFSGranularity
1323                        > mode_lib->vba.MaxDispclkRoundedToDFSGranularity) {
1324                mode_lib->vba.DISPCLK_calculated =
1325                                mode_lib->vba.DISPCLKWithoutRampingRoundedToDFSGranularity;
1326        } else if (mode_lib->vba.DISPCLKWithRampingRoundedToDFSGranularity
1327                        > mode_lib->vba.MaxDispclkRoundedToDFSGranularity) {
1328                mode_lib->vba.DISPCLK_calculated = mode_lib->vba.MaxDispclkRoundedToDFSGranularity;
1329        } else {
1330                mode_lib->vba.DISPCLK_calculated =
1331                                mode_lib->vba.DISPCLKWithRampingRoundedToDFSGranularity;
1332        }
1333        DTRACE("   dispclk_mhz (calculated) = %f", mode_lib->vba.DISPCLK_calculated);
1334
1335        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1336                if (mode_lib->vba.DPPPerPlane[k] == 0) {
1337                        mode_lib->vba.DPPCLK_calculated[k] = 0;
1338                } else {
1339                        mode_lib->vba.DPPCLK_calculated[k] = mode_lib->vba.DPPCLKUsingSingleDPP[k]
1340                                        / mode_lib->vba.DPPPerPlane[k]
1341                                        * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100);
1342                }
1343                mode_lib->vba.GlobalDPPCLK = dml_max(
1344                                mode_lib->vba.GlobalDPPCLK,
1345                                mode_lib->vba.DPPCLK_calculated[k]);
1346        }
1347        mode_lib->vba.GlobalDPPCLK = RoundToDFSGranularityUp(
1348                        mode_lib->vba.GlobalDPPCLK,
1349                        mode_lib->vba.DISPCLKDPPCLKVCOSpeed);
1350        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1351                mode_lib->vba.DPPCLK_calculated[k] = mode_lib->vba.GlobalDPPCLK / 255
1352                                * dml_ceil(
1353                                                mode_lib->vba.DPPCLK_calculated[k] * 255
1354                                                                / mode_lib->vba.GlobalDPPCLK,
1355                                                1);
1356                DTRACE("   dppclk_mhz[%i] (calculated) = %f", k, mode_lib->vba.DPPCLK_calculated[k]);
1357        }
1358
1359        // Urgent Watermark
1360        mode_lib->vba.DCCEnabledAnyPlane = false;
1361        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k)
1362                if (mode_lib->vba.DCCEnable[k])
1363                        mode_lib->vba.DCCEnabledAnyPlane = true;
1364
1365        mode_lib->vba.ReturnBandwidthToDCN = dml_min(
1366                        mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLK,
1367                        mode_lib->vba.FabricAndDRAMBandwidth * 1000)
1368                        * mode_lib->vba.PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly / 100;
1369
1370        mode_lib->vba.ReturnBW = mode_lib->vba.ReturnBandwidthToDCN;
1371        mode_lib->vba.ReturnBW = adjust_ReturnBW(
1372                        mode_lib,
1373                        mode_lib->vba.ReturnBW,
1374                        mode_lib->vba.DCCEnabledAnyPlane,
1375                        mode_lib->vba.ReturnBandwidthToDCN);
1376
1377        // Let's do this calculation again??
1378        mode_lib->vba.ReturnBandwidthToDCN = dml_min(
1379                        mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLK,
1380                        mode_lib->vba.FabricAndDRAMBandwidth * 1000);
1381        mode_lib->vba.ReturnBW = adjust_ReturnBW(
1382                        mode_lib,
1383                        mode_lib->vba.ReturnBW,
1384                        mode_lib->vba.DCCEnabledAnyPlane,
1385                        mode_lib->vba.ReturnBandwidthToDCN);
1386
1387        DTRACE("   dcfclk_mhz         = %f", mode_lib->vba.DCFCLK);
1388        DTRACE("   return_bw_to_dcn   = %f", mode_lib->vba.ReturnBandwidthToDCN);
1389        DTRACE("   return_bus_bw      = %f", mode_lib->vba.ReturnBW);
1390
1391        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1392                bool MainPlaneDoesODMCombine = false;
1393
1394                if (mode_lib->vba.SourceScan[k] == dm_horz)
1395                        mode_lib->vba.SwathWidthSingleDPPY[k] = mode_lib->vba.ViewportWidth[k];
1396                else
1397                        mode_lib->vba.SwathWidthSingleDPPY[k] = mode_lib->vba.ViewportHeight[k];
1398
1399                if (mode_lib->vba.ODMCombineEnabled[k] == dm_odm_combine_mode_2to1)
1400                        MainPlaneDoesODMCombine = true;
1401                for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j)
1402                        if (mode_lib->vba.BlendingAndTiming[k] == j
1403                                        && mode_lib->vba.ODMCombineEnabled[k] == dm_odm_combine_mode_2to1)
1404                                MainPlaneDoesODMCombine = true;
1405
1406                if (MainPlaneDoesODMCombine == true)
1407                        mode_lib->vba.SwathWidthY[k] = dml_min(
1408                                        (double) mode_lib->vba.SwathWidthSingleDPPY[k],
1409                                        dml_round(
1410                                                        mode_lib->vba.HActive[k] / 2.0
1411                                                                        * mode_lib->vba.HRatio[k]));
1412                else {
1413                        if (mode_lib->vba.DPPPerPlane[k] == 0) {
1414                                mode_lib->vba.SwathWidthY[k] = 0;
1415                        } else {
1416                                mode_lib->vba.SwathWidthY[k] = mode_lib->vba.SwathWidthSingleDPPY[k]
1417                                                / mode_lib->vba.DPPPerPlane[k];
1418                        }
1419                }
1420        }
1421
1422        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1423                if (mode_lib->vba.SourcePixelFormat[k] == dm_444_64) {
1424                        mode_lib->vba.BytePerPixelDETY[k] = 8;
1425                        mode_lib->vba.BytePerPixelDETC[k] = 0;
1426                } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_32) {
1427                        mode_lib->vba.BytePerPixelDETY[k] = 4;
1428                        mode_lib->vba.BytePerPixelDETC[k] = 0;
1429                } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_16) {
1430                        mode_lib->vba.BytePerPixelDETY[k] = 2;
1431                        mode_lib->vba.BytePerPixelDETC[k] = 0;
1432                } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_8) {
1433                        mode_lib->vba.BytePerPixelDETY[k] = 1;
1434                        mode_lib->vba.BytePerPixelDETC[k] = 0;
1435                } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8) {
1436                        mode_lib->vba.BytePerPixelDETY[k] = 1;
1437                        mode_lib->vba.BytePerPixelDETC[k] = 2;
1438                } else { // dm_420_10
1439                        mode_lib->vba.BytePerPixelDETY[k] = 4.0 / 3.0;
1440                        mode_lib->vba.BytePerPixelDETC[k] = 8.0 / 3.0;
1441                }
1442        }
1443
1444        mode_lib->vba.TotalDataReadBandwidth = 0.0;
1445        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1446                mode_lib->vba.ReadBandwidthPlaneLuma[k] = mode_lib->vba.SwathWidthSingleDPPY[k]
1447                                * dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1)
1448                                / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k])
1449                                * mode_lib->vba.VRatio[k];
1450                mode_lib->vba.ReadBandwidthPlaneChroma[k] = mode_lib->vba.SwathWidthSingleDPPY[k]
1451                                / 2 * dml_ceil(mode_lib->vba.BytePerPixelDETC[k], 2)
1452                                / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k])
1453                                * mode_lib->vba.VRatio[k] / 2;
1454                DTRACE(
1455                                "   read_bw[%i] = %fBps",
1456                                k,
1457                                mode_lib->vba.ReadBandwidthPlaneLuma[k]
1458                                                + mode_lib->vba.ReadBandwidthPlaneChroma[k]);
1459                mode_lib->vba.TotalDataReadBandwidth += mode_lib->vba.ReadBandwidthPlaneLuma[k]
1460                                + mode_lib->vba.ReadBandwidthPlaneChroma[k];
1461        }
1462
1463        mode_lib->vba.TotalDCCActiveDPP = 0;
1464        mode_lib->vba.TotalActiveDPP = 0;
1465        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1466                mode_lib->vba.TotalActiveDPP = mode_lib->vba.TotalActiveDPP
1467                                + mode_lib->vba.DPPPerPlane[k];
1468                if (mode_lib->vba.DCCEnable[k])
1469                        mode_lib->vba.TotalDCCActiveDPP = mode_lib->vba.TotalDCCActiveDPP
1470                                        + mode_lib->vba.DPPPerPlane[k];
1471        }
1472
1473        mode_lib->vba.UrgentRoundTripAndOutOfOrderLatency =
1474                        (mode_lib->vba.RoundTripPingLatencyCycles + 32) / mode_lib->vba.DCFCLK
1475                                        + mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelDataOnly
1476                                                        * mode_lib->vba.NumberOfChannels
1477                                                        / mode_lib->vba.ReturnBW;
1478
1479        mode_lib->vba.LastPixelOfLineExtraWatermark = 0;
1480        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1481                        if (mode_lib->vba.VRatio[k] <= 1.0)
1482                                mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k] =
1483                                                (double) mode_lib->vba.SwathWidthY[k]
1484                                                                * mode_lib->vba.DPPPerPlane[k]
1485                                                                / mode_lib->vba.HRatio[k]
1486                                                                / mode_lib->vba.PixelClock[k];
1487                        else
1488                                mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k] =
1489                                                (double) mode_lib->vba.SwathWidthY[k]
1490                                                                / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k]
1491                                                                / mode_lib->vba.DPPCLK[k];
1492
1493                        if (mode_lib->vba.BytePerPixelDETC[k] == 0)
1494                                mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k] = 0.0;
1495                        else if (mode_lib->vba.VRatio[k] / 2.0 <= 1.0)
1496                                mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k] =
1497                                                mode_lib->vba.SwathWidthY[k] / 2.0
1498                                                                * mode_lib->vba.DPPPerPlane[k]
1499                                                                / (mode_lib->vba.HRatio[k] / 2.0)
1500                                                                / mode_lib->vba.PixelClock[k];
1501                        else
1502                                mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k] =
1503                                                mode_lib->vba.SwathWidthY[k] / 2.0
1504                                                                / mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k]
1505                                                                / mode_lib->vba.DPPCLK[k];
1506                }
1507
1508        mode_lib->vba.UrgentExtraLatency = mode_lib->vba.UrgentRoundTripAndOutOfOrderLatency
1509                        + (mode_lib->vba.TotalActiveDPP * mode_lib->vba.PixelChunkSizeInKByte
1510                                        + mode_lib->vba.TotalDCCActiveDPP
1511                                                        * mode_lib->vba.MetaChunkSize) * 1024.0
1512                                        / mode_lib->vba.ReturnBW;
1513
1514        if (mode_lib->vba.GPUVMEnable)
1515                mode_lib->vba.UrgentExtraLatency += mode_lib->vba.TotalActiveDPP
1516                                * mode_lib->vba.PTEGroupSize / mode_lib->vba.ReturnBW;
1517
1518        mode_lib->vba.UrgentWatermark = mode_lib->vba.UrgentLatencyPixelDataOnly
1519                        + mode_lib->vba.LastPixelOfLineExtraWatermark
1520                        + mode_lib->vba.UrgentExtraLatency;
1521
1522        DTRACE("   urgent_extra_latency = %fus", mode_lib->vba.UrgentExtraLatency);
1523        DTRACE("   wm_urgent = %fus", mode_lib->vba.UrgentWatermark);
1524
1525        mode_lib->vba.UrgentLatency = mode_lib->vba.UrgentLatencyPixelDataOnly;
1526
1527        mode_lib->vba.TotalActiveWriteback = 0;
1528        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1529                if (mode_lib->vba.WritebackEnable[k])
1530                        mode_lib->vba.TotalActiveWriteback = mode_lib->vba.TotalActiveWriteback + mode_lib->vba.ActiveWritebacksPerPlane[k];
1531        }
1532
1533        if (mode_lib->vba.TotalActiveWriteback <= 1)
1534                mode_lib->vba.WritebackUrgentWatermark = mode_lib->vba.WritebackLatency;
1535        else
1536                mode_lib->vba.WritebackUrgentWatermark = mode_lib->vba.WritebackLatency
1537                                + mode_lib->vba.WritebackChunkSize * 1024.0 / 32
1538                                                / mode_lib->vba.SOCCLK;
1539
1540        DTRACE("   wm_wb_urgent = %fus", mode_lib->vba.WritebackUrgentWatermark);
1541
1542        // NB P-State/DRAM Clock Change Watermark
1543        mode_lib->vba.DRAMClockChangeWatermark = mode_lib->vba.DRAMClockChangeLatency
1544                        + mode_lib->vba.UrgentWatermark;
1545
1546        DTRACE("   wm_pstate_change = %fus", mode_lib->vba.DRAMClockChangeWatermark);
1547
1548        DTRACE("   calculating wb pstate watermark");
1549        DTRACE("      total wb outputs %d", mode_lib->vba.TotalActiveWriteback);
1550        DTRACE("      socclk frequency %f Mhz", mode_lib->vba.SOCCLK);
1551
1552        if (mode_lib->vba.TotalActiveWriteback <= 1)
1553                mode_lib->vba.WritebackDRAMClockChangeWatermark =
1554                                mode_lib->vba.DRAMClockChangeLatency
1555                                                + mode_lib->vba.WritebackLatency;
1556        else
1557                mode_lib->vba.WritebackDRAMClockChangeWatermark =
1558                                mode_lib->vba.DRAMClockChangeLatency
1559                                                + mode_lib->vba.WritebackLatency
1560                                                + mode_lib->vba.WritebackChunkSize * 1024.0 / 32
1561                                                                / mode_lib->vba.SOCCLK;
1562
1563        DTRACE("   wm_wb_pstate %fus", mode_lib->vba.WritebackDRAMClockChangeWatermark);
1564
1565        // Stutter Efficiency
1566        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1567                mode_lib->vba.LinesInDETY[k] = mode_lib->vba.DETBufferSizeY[k]
1568                                / mode_lib->vba.BytePerPixelDETY[k] / mode_lib->vba.SwathWidthY[k];
1569                mode_lib->vba.LinesInDETYRoundedDownToSwath[k] = dml_floor(
1570                                mode_lib->vba.LinesInDETY[k],
1571                                mode_lib->vba.SwathHeightY[k]);
1572                mode_lib->vba.FullDETBufferingTimeY[k] =
1573                                mode_lib->vba.LinesInDETYRoundedDownToSwath[k]
1574                                                * (mode_lib->vba.HTotal[k]
1575                                                                / mode_lib->vba.PixelClock[k])
1576                                                / mode_lib->vba.VRatio[k];
1577                if (mode_lib->vba.BytePerPixelDETC[k] > 0) {
1578                        mode_lib->vba.LinesInDETC[k] = mode_lib->vba.DETBufferSizeC[k]
1579                                        / mode_lib->vba.BytePerPixelDETC[k]
1580                                        / (mode_lib->vba.SwathWidthY[k] / 2);
1581                        mode_lib->vba.LinesInDETCRoundedDownToSwath[k] = dml_floor(
1582                                        mode_lib->vba.LinesInDETC[k],
1583                                        mode_lib->vba.SwathHeightC[k]);
1584                        mode_lib->vba.FullDETBufferingTimeC[k] =
1585                                        mode_lib->vba.LinesInDETCRoundedDownToSwath[k]
1586                                                        * (mode_lib->vba.HTotal[k]
1587                                                                        / mode_lib->vba.PixelClock[k])
1588                                                        / (mode_lib->vba.VRatio[k] / 2);
1589                } else {
1590                        mode_lib->vba.LinesInDETC[k] = 0;
1591                        mode_lib->vba.LinesInDETCRoundedDownToSwath[k] = 0;
1592                        mode_lib->vba.FullDETBufferingTimeC[k] = 999999;
1593                }
1594        }
1595
1596        mode_lib->vba.MinFullDETBufferingTime = 999999.0;
1597        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1598                if (mode_lib->vba.FullDETBufferingTimeY[k]
1599                                < mode_lib->vba.MinFullDETBufferingTime) {
1600                        mode_lib->vba.MinFullDETBufferingTime =
1601                                        mode_lib->vba.FullDETBufferingTimeY[k];
1602                        mode_lib->vba.FrameTimeForMinFullDETBufferingTime =
1603                                        (double) mode_lib->vba.VTotal[k] * mode_lib->vba.HTotal[k]
1604                                                        / mode_lib->vba.PixelClock[k];
1605                }
1606                if (mode_lib->vba.FullDETBufferingTimeC[k]
1607                                < mode_lib->vba.MinFullDETBufferingTime) {
1608                        mode_lib->vba.MinFullDETBufferingTime =
1609                                        mode_lib->vba.FullDETBufferingTimeC[k];
1610                        mode_lib->vba.FrameTimeForMinFullDETBufferingTime =
1611                                        (double) mode_lib->vba.VTotal[k] * mode_lib->vba.HTotal[k]
1612                                                        / mode_lib->vba.PixelClock[k];
1613                }
1614        }
1615
1616        mode_lib->vba.AverageReadBandwidthGBytePerSecond = 0.0;
1617        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1618                if (mode_lib->vba.DCCEnable[k]) {
1619                        mode_lib->vba.AverageReadBandwidthGBytePerSecond =
1620                                        mode_lib->vba.AverageReadBandwidthGBytePerSecond
1621                                                        + mode_lib->vba.ReadBandwidthPlaneLuma[k]
1622                                                                        / mode_lib->vba.DCCRate[k]
1623                                                                        / 1000
1624                                                        + mode_lib->vba.ReadBandwidthPlaneChroma[k]
1625                                                                        / mode_lib->vba.DCCRate[k]
1626                                                                        / 1000;
1627                } else {
1628                        mode_lib->vba.AverageReadBandwidthGBytePerSecond =
1629                                        mode_lib->vba.AverageReadBandwidthGBytePerSecond
1630                                                        + mode_lib->vba.ReadBandwidthPlaneLuma[k]
1631                                                                        / 1000
1632                                                        + mode_lib->vba.ReadBandwidthPlaneChroma[k]
1633                                                                        / 1000;
1634                }
1635                if (mode_lib->vba.DCCEnable[k]) {
1636                        mode_lib->vba.AverageReadBandwidthGBytePerSecond =
1637                                        mode_lib->vba.AverageReadBandwidthGBytePerSecond
1638                                                        + mode_lib->vba.ReadBandwidthPlaneLuma[k]
1639                                                                        / 1000 / 256
1640                                                        + mode_lib->vba.ReadBandwidthPlaneChroma[k]
1641                                                                        / 1000 / 256;
1642                }
1643                if (mode_lib->vba.GPUVMEnable) {
1644                        mode_lib->vba.AverageReadBandwidthGBytePerSecond =
1645                                        mode_lib->vba.AverageReadBandwidthGBytePerSecond
1646                                                        + mode_lib->vba.ReadBandwidthPlaneLuma[k]
1647                                                                        / 1000 / 512
1648                                                        + mode_lib->vba.ReadBandwidthPlaneChroma[k]
1649                                                                        / 1000 / 512;
1650                }
1651        }
1652
1653        mode_lib->vba.PartOfBurstThatFitsInROB =
1654                        dml_min(
1655                                        mode_lib->vba.MinFullDETBufferingTime
1656                                                        * mode_lib->vba.TotalDataReadBandwidth,
1657                                        mode_lib->vba.ROBBufferSizeInKByte * 1024
1658                                                        * mode_lib->vba.TotalDataReadBandwidth
1659                                                        / (mode_lib->vba.AverageReadBandwidthGBytePerSecond
1660                                                                        * 1000));
1661        mode_lib->vba.StutterBurstTime = mode_lib->vba.PartOfBurstThatFitsInROB
1662                        * (mode_lib->vba.AverageReadBandwidthGBytePerSecond * 1000)
1663                        / mode_lib->vba.TotalDataReadBandwidth / mode_lib->vba.ReturnBW
1664                        + (mode_lib->vba.MinFullDETBufferingTime
1665                                        * mode_lib->vba.TotalDataReadBandwidth
1666                                        - mode_lib->vba.PartOfBurstThatFitsInROB)
1667                                        / (mode_lib->vba.DCFCLK * 64);
1668        if (mode_lib->vba.TotalActiveWriteback == 0) {
1669                mode_lib->vba.StutterEfficiencyNotIncludingVBlank = (1
1670                                - (mode_lib->vba.SRExitTime + mode_lib->vba.StutterBurstTime)
1671                                                / mode_lib->vba.MinFullDETBufferingTime) * 100;
1672        } else {
1673                mode_lib->vba.StutterEfficiencyNotIncludingVBlank = 0;
1674        }
1675
1676        mode_lib->vba.SmallestVBlank = 999999;
1677        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1678                if (mode_lib->vba.SynchronizedVBlank || mode_lib->vba.NumberOfActivePlanes == 1) {
1679                        mode_lib->vba.VBlankTime = (double) (mode_lib->vba.VTotal[k]
1680                                        - mode_lib->vba.VActive[k]) * mode_lib->vba.HTotal[k]
1681                                        / mode_lib->vba.PixelClock[k];
1682                } else {
1683                        mode_lib->vba.VBlankTime = 0;
1684                }
1685                mode_lib->vba.SmallestVBlank = dml_min(
1686                                mode_lib->vba.SmallestVBlank,
1687                                mode_lib->vba.VBlankTime);
1688        }
1689
1690        mode_lib->vba.StutterEfficiency = (mode_lib->vba.StutterEfficiencyNotIncludingVBlank / 100
1691                        * (mode_lib->vba.FrameTimeForMinFullDETBufferingTime
1692                                        - mode_lib->vba.SmallestVBlank)
1693                        + mode_lib->vba.SmallestVBlank)
1694                        / mode_lib->vba.FrameTimeForMinFullDETBufferingTime * 100;
1695
1696        // dml_ml->vba.DCFCLK Deep Sleep
1697        mode_lib->vba.DCFCLKDeepSleep = 8.0;
1698
1699        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; k++) {
1700                if (mode_lib->vba.BytePerPixelDETC[k] > 0) {
1701                        mode_lib->vba.DCFCLKDeepSleepPerPlane[k] =
1702                                        dml_max(
1703                                                        1.1 * mode_lib->vba.SwathWidthY[k]
1704                                                                        * dml_ceil(
1705                                                                                        mode_lib->vba.BytePerPixelDETY[k],
1706                                                                                        1) / 32
1707                                                                        / mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k],
1708                                                        1.1 * mode_lib->vba.SwathWidthY[k] / 2.0
1709                                                                        * dml_ceil(
1710                                                                                        mode_lib->vba.BytePerPixelDETC[k],
1711                                                                                        2) / 32
1712                                                                        / mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k]);
1713                } else
1714                        mode_lib->vba.DCFCLKDeepSleepPerPlane[k] = 1.1 * mode_lib->vba.SwathWidthY[k]
1715                                        * dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1) / 64.0
1716                                        / mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k];
1717                mode_lib->vba.DCFCLKDeepSleepPerPlane[k] = dml_max(
1718                                mode_lib->vba.DCFCLKDeepSleepPerPlane[k],
1719                                mode_lib->vba.PixelClock[k] / 16.0);
1720                mode_lib->vba.DCFCLKDeepSleep = dml_max(
1721                                mode_lib->vba.DCFCLKDeepSleep,
1722                                mode_lib->vba.DCFCLKDeepSleepPerPlane[k]);
1723
1724                DTRACE(
1725                                "   dcfclk_deepsleep_per_plane[%i] = %fMHz",
1726                                k,
1727                                mode_lib->vba.DCFCLKDeepSleepPerPlane[k]);
1728        }
1729
1730        DTRACE("   dcfclk_deepsleep_mhz = %fMHz", mode_lib->vba.DCFCLKDeepSleep);
1731
1732        // Stutter Watermark
1733        mode_lib->vba.StutterExitWatermark = mode_lib->vba.SRExitTime
1734                        + mode_lib->vba.LastPixelOfLineExtraWatermark
1735                        + mode_lib->vba.UrgentExtraLatency + 10 / mode_lib->vba.DCFCLKDeepSleep;
1736        mode_lib->vba.StutterEnterPlusExitWatermark = mode_lib->vba.SREnterPlusExitTime
1737                        + mode_lib->vba.LastPixelOfLineExtraWatermark
1738                        + mode_lib->vba.UrgentExtraLatency;
1739
1740        DTRACE("   wm_cstate_exit       = %fus", mode_lib->vba.StutterExitWatermark);
1741        DTRACE("   wm_cstate_enter_exit = %fus", mode_lib->vba.StutterEnterPlusExitWatermark);
1742
1743        // Urgent Latency Supported
1744        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1745                mode_lib->vba.EffectiveDETPlusLBLinesLuma =
1746                                dml_floor(
1747                                                mode_lib->vba.LinesInDETY[k]
1748                                                                + dml_min(
1749                                                                                mode_lib->vba.LinesInDETY[k]
1750                                                                                                * mode_lib->vba.DPPCLK[k]
1751                                                                                                * mode_lib->vba.BytePerPixelDETY[k]
1752                                                                                                * mode_lib->vba.PSCL_THROUGHPUT_LUMA[k]
1753                                                                                                / (mode_lib->vba.ReturnBW
1754                                                                                                                / mode_lib->vba.DPPPerPlane[k]),
1755                                                                                (double) mode_lib->vba.EffectiveLBLatencyHidingSourceLinesLuma),
1756                                                mode_lib->vba.SwathHeightY[k]);
1757
1758                mode_lib->vba.UrgentLatencySupportUsLuma = mode_lib->vba.EffectiveDETPlusLBLinesLuma
1759                                * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k])
1760                                / mode_lib->vba.VRatio[k]
1761                                - mode_lib->vba.EffectiveDETPlusLBLinesLuma
1762                                                * mode_lib->vba.SwathWidthY[k]
1763                                                * mode_lib->vba.BytePerPixelDETY[k]
1764                                                / (mode_lib->vba.ReturnBW
1765                                                                / mode_lib->vba.DPPPerPlane[k]);
1766
1767                if (mode_lib->vba.BytePerPixelDETC[k] > 0) {
1768                        mode_lib->vba.EffectiveDETPlusLBLinesChroma =
1769                                        dml_floor(
1770                                                        mode_lib->vba.LinesInDETC[k]
1771                                                                        + dml_min(
1772                                                                                        mode_lib->vba.LinesInDETC[k]
1773                                                                                                        * mode_lib->vba.DPPCLK[k]
1774                                                                                                        * mode_lib->vba.BytePerPixelDETC[k]
1775                                                                                                        * mode_lib->vba.PSCL_THROUGHPUT_CHROMA[k]
1776                                                                                                        / (mode_lib->vba.ReturnBW
1777                                                                                                                        / mode_lib->vba.DPPPerPlane[k]),
1778                                                                                        (double) mode_lib->vba.EffectiveLBLatencyHidingSourceLinesChroma),
1779                                                        mode_lib->vba.SwathHeightC[k]);
1780                        mode_lib->vba.UrgentLatencySupportUsChroma =
1781                                        mode_lib->vba.EffectiveDETPlusLBLinesChroma
1782                                                        * (mode_lib->vba.HTotal[k]
1783                                                                        / mode_lib->vba.PixelClock[k])
1784                                                        / (mode_lib->vba.VRatio[k] / 2)
1785                                                        - mode_lib->vba.EffectiveDETPlusLBLinesChroma
1786                                                                        * (mode_lib->vba.SwathWidthY[k]
1787                                                                                        / 2)
1788                                                                        * mode_lib->vba.BytePerPixelDETC[k]
1789                                                                        / (mode_lib->vba.ReturnBW
1790                                                                                        / mode_lib->vba.DPPPerPlane[k]);
1791                        mode_lib->vba.UrgentLatencySupportUs[k] = dml_min(
1792                                        mode_lib->vba.UrgentLatencySupportUsLuma,
1793                                        mode_lib->vba.UrgentLatencySupportUsChroma);
1794                } else {
1795                        mode_lib->vba.UrgentLatencySupportUs[k] =
1796                                        mode_lib->vba.UrgentLatencySupportUsLuma;
1797                }
1798        }
1799
1800        mode_lib->vba.MinUrgentLatencySupportUs = 999999;
1801        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1802                mode_lib->vba.MinUrgentLatencySupportUs = dml_min(
1803                                mode_lib->vba.MinUrgentLatencySupportUs,
1804                                mode_lib->vba.UrgentLatencySupportUs[k]);
1805        }
1806
1807        // Non-Urgent Latency Tolerance
1808        mode_lib->vba.NonUrgentLatencyTolerance = mode_lib->vba.MinUrgentLatencySupportUs
1809                        - mode_lib->vba.UrgentWatermark;
1810
1811        // DSCCLK
1812        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1813                if ((mode_lib->vba.BlendingAndTiming[k] != k) || !mode_lib->vba.DSCEnabled[k]) {
1814                        mode_lib->vba.DSCCLK_calculated[k] = 0.0;
1815                } else {
1816                        if (mode_lib->vba.OutputFormat[k] == dm_420
1817                                        || mode_lib->vba.OutputFormat[k] == dm_n422)
1818                                mode_lib->vba.DSCFormatFactor = 2;
1819                        else
1820                                mode_lib->vba.DSCFormatFactor = 1;
1821                        if (mode_lib->vba.ODMCombineEnabled[k])
1822                                mode_lib->vba.DSCCLK_calculated[k] =
1823                                                mode_lib->vba.PixelClockBackEnd[k] / 6
1824                                                                / mode_lib->vba.DSCFormatFactor
1825                                                                / (1
1826                                                                                - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading
1827                                                                                                / 100);
1828                        else
1829                                mode_lib->vba.DSCCLK_calculated[k] =
1830                                                mode_lib->vba.PixelClockBackEnd[k] / 3
1831                                                                / mode_lib->vba.DSCFormatFactor
1832                                                                / (1
1833                                                                                - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading
1834                                                                                                / 100);
1835                }
1836        }
1837
1838        // DSC Delay
1839        // TODO
1840        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1841                double bpp = mode_lib->vba.OutputBpp[k];
1842                unsigned int slices = mode_lib->vba.NumberOfDSCSlices[k];
1843
1844                if (mode_lib->vba.DSCEnabled[k] && bpp != 0) {
1845                        if (!mode_lib->vba.ODMCombineEnabled[k]) {
1846                                mode_lib->vba.DSCDelay[k] =
1847                                                dscceComputeDelay(
1848                                                                mode_lib->vba.DSCInputBitPerComponent[k],
1849                                                                bpp,
1850                                                                dml_ceil(
1851                                                                                (double) mode_lib->vba.HActive[k]
1852                                                                                                / mode_lib->vba.NumberOfDSCSlices[k],
1853                                                                                1),
1854                                                                slices,
1855                                                                mode_lib->vba.OutputFormat[k])
1856                                                                + dscComputeDelay(
1857                                                                                mode_lib->vba.OutputFormat[k]);
1858                        } else {
1859                                mode_lib->vba.DSCDelay[k] =
1860                                                2
1861                                                                * (dscceComputeDelay(
1862                                                                                mode_lib->vba.DSCInputBitPerComponent[k],
1863                                                                                bpp,
1864                                                                                dml_ceil(
1865                                                                                                (double) mode_lib->vba.HActive[k]
1866                                                                                                                / mode_lib->vba.NumberOfDSCSlices[k],
1867                                                                                                1),
1868                                                                                slices / 2.0,
1869                                                                                mode_lib->vba.OutputFormat[k])
1870                                                                                + dscComputeDelay(
1871                                                                                                mode_lib->vba.OutputFormat[k]));
1872                        }
1873                        mode_lib->vba.DSCDelay[k] = mode_lib->vba.DSCDelay[k]
1874                                        * mode_lib->vba.PixelClock[k]
1875                                        / mode_lib->vba.PixelClockBackEnd[k];
1876                } else {
1877                        mode_lib->vba.DSCDelay[k] = 0;
1878                }
1879        }
1880
1881        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k)
1882                for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) // NumberOfPlanes
1883                        if (j != k && mode_lib->vba.BlendingAndTiming[k] == j
1884                                        && mode_lib->vba.DSCEnabled[j])
1885                                mode_lib->vba.DSCDelay[k] = mode_lib->vba.DSCDelay[j];
1886
1887        // Prefetch
1888        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
1889                unsigned int PDEAndMetaPTEBytesFrameY;
1890                unsigned int PixelPTEBytesPerRowY;
1891                unsigned int MetaRowByteY;
1892                unsigned int MetaRowByteC;
1893                unsigned int PDEAndMetaPTEBytesFrameC;
1894                unsigned int PixelPTEBytesPerRowC;
1895
1896                Calculate256BBlockSizes(
1897                                mode_lib->vba.SourcePixelFormat[k],
1898                                mode_lib->vba.SurfaceTiling[k],
1899                                dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1),
1900                                dml_ceil(mode_lib->vba.BytePerPixelDETC[k], 2),
1901                                &mode_lib->vba.BlockHeight256BytesY[k],
1902                                &mode_lib->vba.BlockHeight256BytesC[k],
1903                                &mode_lib->vba.BlockWidth256BytesY[k],
1904                                &mode_lib->vba.BlockWidth256BytesC[k]);
1905                PDEAndMetaPTEBytesFrameY = CalculateVMAndRowBytes(
1906                                mode_lib,
1907                                mode_lib->vba.DCCEnable[k],
1908                                mode_lib->vba.BlockHeight256BytesY[k],
1909                                mode_lib->vba.BlockWidth256BytesY[k],
1910                                mode_lib->vba.SourcePixelFormat[k],
1911                                mode_lib->vba.SurfaceTiling[k],
1912                                dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1),
1913                                mode_lib->vba.SourceScan[k],
1914                                mode_lib->vba.ViewportWidth[k],
1915                                mode_lib->vba.ViewportHeight[k],
1916                                mode_lib->vba.SwathWidthY[k],
1917                                mode_lib->vba.GPUVMEnable,
1918                                mode_lib->vba.VMMPageSize,
1919                                mode_lib->vba.PTEBufferSizeInRequestsLuma,
1920                                mode_lib->vba.PDEProcessingBufIn64KBReqs,
1921                                mode_lib->vba.PitchY[k],
1922                                mode_lib->vba.DCCMetaPitchY[k],
1923                                &mode_lib->vba.MacroTileWidthY[k],
1924                                &MetaRowByteY,
1925                                &PixelPTEBytesPerRowY,
1926                                &mode_lib->vba.PTEBufferSizeNotExceeded[mode_lib->vba.VoltageLevel][0],
1927                                &mode_lib->vba.dpte_row_height[k],
1928                                &mode_lib->vba.meta_row_height[k]);
1929                mode_lib->vba.PrefetchSourceLinesY[k] = CalculatePrefetchSourceLines(
1930                                mode_lib,
1931                                mode_lib->vba.VRatio[k],
1932                                mode_lib->vba.vtaps[k],
1933                                mode_lib->vba.Interlace[k],
1934                                mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
1935                                mode_lib->vba.SwathHeightY[k],
1936                                mode_lib->vba.ViewportYStartY[k],
1937                                &mode_lib->vba.VInitPreFillY[k],
1938                                &mode_lib->vba.MaxNumSwathY[k]);
1939
1940                if ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64
1941                                && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
1942                                && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
1943                                && mode_lib->vba.SourcePixelFormat[k] != dm_444_8)) {
1944                        PDEAndMetaPTEBytesFrameC =
1945                                        CalculateVMAndRowBytes(
1946                                                        mode_lib,
1947                                                        mode_lib->vba.DCCEnable[k],
1948                                                        mode_lib->vba.BlockHeight256BytesC[k],
1949                                                        mode_lib->vba.BlockWidth256BytesC[k],
1950                                                        mode_lib->vba.SourcePixelFormat[k],
1951                                                        mode_lib->vba.SurfaceTiling[k],
1952                                                        dml_ceil(
1953                                                                        mode_lib->vba.BytePerPixelDETC[k],
1954                                                                        2),
1955                                                        mode_lib->vba.SourceScan[k],
1956                                                        mode_lib->vba.ViewportWidth[k] / 2,
1957                                                        mode_lib->vba.ViewportHeight[k] / 2,
1958                                                        mode_lib->vba.SwathWidthY[k] / 2,
1959                                                        mode_lib->vba.GPUVMEnable,
1960                                                        mode_lib->vba.VMMPageSize,
1961                                                        mode_lib->vba.PTEBufferSizeInRequestsLuma,
1962                                                        mode_lib->vba.PDEProcessingBufIn64KBReqs,
1963                                                        mode_lib->vba.PitchC[k],
1964                                                        0,
1965                                                        &mode_lib->vba.MacroTileWidthC[k],
1966                                                        &MetaRowByteC,
1967                                                        &PixelPTEBytesPerRowC,
1968                                                        &mode_lib->vba.PTEBufferSizeNotExceeded[mode_lib->vba.VoltageLevel][0],
1969                                                        &mode_lib->vba.dpte_row_height_chroma[k],
1970                                                        &mode_lib->vba.meta_row_height_chroma[k]);
1971                        mode_lib->vba.PrefetchSourceLinesC[k] = CalculatePrefetchSourceLines(
1972                                        mode_lib,
1973                                        mode_lib->vba.VRatio[k] / 2,
1974                                        mode_lib->vba.VTAPsChroma[k],
1975                                        mode_lib->vba.Interlace[k],
1976                                        mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
1977                                        mode_lib->vba.SwathHeightC[k],
1978                                        mode_lib->vba.ViewportYStartC[k],
1979                                        &mode_lib->vba.VInitPreFillC[k],
1980                                        &mode_lib->vba.MaxNumSwathC[k]);
1981                } else {
1982                        PixelPTEBytesPerRowC = 0;
1983                        PDEAndMetaPTEBytesFrameC = 0;
1984                        MetaRowByteC = 0;
1985                        mode_lib->vba.MaxNumSwathC[k] = 0;
1986                        mode_lib->vba.PrefetchSourceLinesC[k] = 0;
1987                }
1988
1989                mode_lib->vba.PixelPTEBytesPerRow[k] = PixelPTEBytesPerRowY + PixelPTEBytesPerRowC;
1990                mode_lib->vba.PDEAndMetaPTEBytesFrame[k] = PDEAndMetaPTEBytesFrameY
1991                                + PDEAndMetaPTEBytesFrameC;
1992                mode_lib->vba.MetaRowByte[k] = MetaRowByteY + MetaRowByteC;
1993
1994                CalculateActiveRowBandwidth(
1995                                mode_lib->vba.GPUVMEnable,
1996                                mode_lib->vba.SourcePixelFormat[k],
1997                                mode_lib->vba.VRatio[k],
1998                                mode_lib->vba.DCCEnable[k],
1999                                mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
2000                                MetaRowByteY,

2001                                MetaRowByteC,
2002                                mode_lib->vba.meta_row_height[k],
2003                                mode_lib->vba.meta_row_height_chroma[k],
2004                                PixelPTEBytesPerRowY,
2005                                PixelPTEBytesPerRowC,
2006                                mode_lib->vba.dpte_row_height[k],
2007                                mode_lib->vba.dpte_row_height_chroma[k],
2008                                &mode_lib->vba.meta_row_bw[k],
2009                                &mode_lib->vba.dpte_row_bw[k],
2010                                &mode_lib->vba.qual_row_bw[k]);
2011        }
2012
2013        mode_lib->vba.TCalc = 24.0 / mode_lib->vba.DCFCLKDeepSleep;
2014
2015        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2016                if (mode_lib->vba.BlendingAndTiming[k] == k) {
2017                        if (mode_lib->vba.WritebackEnable[k] == true) {
2018                                mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] =
2019                                                mode_lib->vba.WritebackLatency
2020                                                                + CalculateWriteBackDelay(
2021                                                                                mode_lib->vba.WritebackPixelFormat[k],
2022                                                                                mode_lib->vba.WritebackHRatio[k],
2023                                                                                mode_lib->vba.WritebackVRatio[k],
2024                                                                                mode_lib->vba.WritebackLumaHTaps[k],
2025                                                                                mode_lib->vba.WritebackLumaVTaps[k],
2026                                                                                mode_lib->vba.WritebackChromaHTaps[k],
2027                                                                                mode_lib->vba.WritebackChromaVTaps[k],
2028                                                                                mode_lib->vba.WritebackDestinationWidth[k])
2029                                                                                / mode_lib->vba.DISPCLK;
2030                        } else
2031                                mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] = 0;
2032                        for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) {
2033                                if (mode_lib->vba.BlendingAndTiming[j] == k
2034                                                && mode_lib->vba.WritebackEnable[j] == true) {
2035                                        mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] =
2036                                                        dml_max(
2037                                                                        mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k],
2038                                                                        mode_lib->vba.WritebackLatency
2039                                                                                        + CalculateWriteBackDelay(
2040                                                                                                        mode_lib->vba.WritebackPixelFormat[j],
2041                                                                                                        mode_lib->vba.WritebackHRatio[j],
2042                                                                                                        mode_lib->vba.WritebackVRatio[j],
2043                                                                                                        mode_lib->vba.WritebackLumaHTaps[j],
2044                                                                                                        mode_lib->vba.WritebackLumaVTaps[j],
2045                                                                                                        mode_lib->vba.WritebackChromaHTaps[j],
2046                                                                                                        mode_lib->vba.WritebackChromaVTaps[j],
2047                                                                                                        mode_lib->vba.WritebackDestinationWidth[j])
2048                                                                                                        / mode_lib->vba.DISPCLK);
2049                                }
2050                        }
2051                }
2052        }
2053
2054        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k)
2055                for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j)
2056                        if (mode_lib->vba.BlendingAndTiming[k] == j)
2057                                mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k] =
2058                                                mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][j];
2059
2060        mode_lib->vba.VStartupLines = 13;
2061        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2062                mode_lib->vba.MaxVStartupLines[k] =
2063                                mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]
2064                                                - dml_max(
2065                                                                1.0,
2066                                                                dml_ceil(
2067                                                                                mode_lib->vba.WritebackDelay[mode_lib->vba.VoltageLevel][k]
2068                                                                                                / (mode_lib->vba.HTotal[k]
2069                                                                                                                / mode_lib->vba.PixelClock[k]),
2070                                                                                1));
2071        }
2072
2073        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k)
2074                mode_lib->vba.MaximumMaxVStartupLines = dml_max(
2075                                mode_lib->vba.MaximumMaxVStartupLines,
2076                                mode_lib->vba.MaxVStartupLines[k]);
2077
2078        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2079                mode_lib->vba.cursor_bw[k] = 0.0;
2080                for (j = 0; j < mode_lib->vba.NumberOfCursors[k]; ++j)
2081                        mode_lib->vba.cursor_bw[k] += mode_lib->vba.CursorWidth[k][j]
2082                                        * mode_lib->vba.CursorBPP[k][j] / 8.0
2083                                        / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k])
2084                                        * mode_lib->vba.VRatio[k];
2085        }
2086
2087        do {
2088                double MaxTotalRDBandwidth = 0;
2089                bool DestinationLineTimesForPrefetchLessThan2 = false;
2090                bool VRatioPrefetchMoreThan4 = false;
2091                bool prefetch_vm_bw_valid = true;
2092                bool prefetch_row_bw_valid = true;
2093                double TWait = CalculateTWait(
2094                                mode_lib->vba.PrefetchMode[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb],
2095                                mode_lib->vba.DRAMClockChangeLatency,
2096                                mode_lib->vba.UrgentLatencyPixelDataOnly,
2097                                mode_lib->vba.SREnterPlusExitTime);
2098
2099                for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2100                        if (mode_lib->vba.XFCEnabled[k] == true) {
2101                                mode_lib->vba.XFCRemoteSurfaceFlipDelay =
2102                                                CalculateRemoteSurfaceFlipDelay(
2103                                                                mode_lib,
2104                                                                mode_lib->vba.VRatio[k],
2105                                                                mode_lib->vba.SwathWidthY[k],
2106                                                                dml_ceil(
2107                                                                                mode_lib->vba.BytePerPixelDETY[k],
2108                                                                                1),
2109                                                                mode_lib->vba.HTotal[k]
2110                                                                                / mode_lib->vba.PixelClock[k],
2111                                                                mode_lib->vba.XFCTSlvVupdateOffset,
2112                                                                mode_lib->vba.XFCTSlvVupdateWidth,
2113                                                                mode_lib->vba.XFCTSlvVreadyOffset,
2114                                                                mode_lib->vba.XFCXBUFLatencyTolerance,
2115                                                                mode_lib->vba.XFCFillBWOverhead,
2116                                                                mode_lib->vba.XFCSlvChunkSize,
2117                                                                mode_lib->vba.XFCBusTransportTime,
2118                                                                mode_lib->vba.TCalc,
2119                                                                TWait,
2120                                                                &mode_lib->vba.SrcActiveDrainRate,
2121                                                                &mode_lib->vba.TInitXFill,
2122                                                                &mode_lib->vba.TslvChk);
2123                        } else {
2124                                mode_lib->vba.XFCRemoteSurfaceFlipDelay = 0;
2125                        }
2126
2127                        CalculateDelayAfterScaler(mode_lib, mode_lib->vba.ReturnBW, mode_lib->vba.ReadBandwidthPlaneLuma[k], mode_lib->vba.ReadBandwidthPlaneChroma[k], mode_lib->vba.TotalDataReadBandwidth,
2128                                        mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k], mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k],
2129                                        mode_lib->vba.DPPCLK[k], mode_lib->vba.DISPCLK, mode_lib->vba.PixelClock[k], mode_lib->vba.DSCDelay[k], mode_lib->vba.DPPPerPlane[k], mode_lib->vba.ScalerEnabled[k], mode_lib->vba.NumberOfCursors[k],
2130                                        mode_lib->vba.DPPCLKDelaySubtotal, mode_lib->vba.DPPCLKDelaySCL, mode_lib->vba.DPPCLKDelaySCLLBOnly, mode_lib->vba.DPPCLKDelayCNVCFormater, mode_lib->vba.DPPCLKDelayCNVCCursor, mode_lib->vba.DISPCLKDelaySubtotal,
2131                                        mode_lib->vba.SwathWidthY[k] / mode_lib->vba.HRatio[k], mode_lib->vba.OutputFormat[k], mode_lib->vba.HTotal[k],
2132                                        mode_lib->vba.SwathWidthSingleDPPY[k], mode_lib->vba.BytePerPixelDETY[k], mode_lib->vba.BytePerPixelDETC[k], mode_lib->vba.SwathHeightY[k], mode_lib->vba.SwathHeightC[k], mode_lib->vba.Interlace[k],
2133                                        mode_lib->vba.ProgressiveToInterlaceUnitInOPP, &mode_lib->vba.DSTXAfterScaler[k], &mode_lib->vba.DSTYAfterScaler[k]);
2134
2135                        mode_lib->vba.ErrorResult[k] =
2136                                        CalculatePrefetchSchedule(
2137                                                        mode_lib,
2138                                                        mode_lib->vba.DPPCLK[k],
2139                                                        mode_lib->vba.DISPCLK,
2140                                                        mode_lib->vba.PixelClock[k],
2141                                                        mode_lib->vba.DCFCLKDeepSleep,
2142                                                        mode_lib->vba.DPPPerPlane[k],
2143                                                        mode_lib->vba.NumberOfCursors[k],
2144                                                        mode_lib->vba.VTotal[k]
2145                                                                        - mode_lib->vba.VActive[k],
2146                                                        mode_lib->vba.HTotal[k],
2147                                                        mode_lib->vba.MaxInterDCNTileRepeaters,
2148                                                        dml_min(
2149                                                                        mode_lib->vba.VStartupLines,
2150                                                                        mode_lib->vba.MaxVStartupLines[k]),
2151                                                        mode_lib->vba.GPUVMMaxPageTableLevels,
2152                                                        mode_lib->vba.GPUVMEnable,
2153                                                        mode_lib->vba.DynamicMetadataEnable[k],
2154                                                        mode_lib->vba.DynamicMetadataLinesBeforeActiveRequired[k],
2155                                                        mode_lib->vba.DynamicMetadataTransmittedBytes[k],
2156                                                        mode_lib->vba.DCCEnable[k],
2157                                                        mode_lib->vba.UrgentLatencyPixelDataOnly,
2158                                                        mode_lib->vba.UrgentExtraLatency,
2159                                                        mode_lib->vba.TCalc,
2160                                                        mode_lib->vba.PDEAndMetaPTEBytesFrame[k],
2161                                                        mode_lib->vba.MetaRowByte[k],
2162                                                        mode_lib->vba.PixelPTEBytesPerRow[k],
2163                                                        mode_lib->vba.PrefetchSourceLinesY[k],
2164                                                        mode_lib->vba.SwathWidthY[k],
2165                                                        mode_lib->vba.BytePerPixelDETY[k],
2166                                                        mode_lib->vba.VInitPreFillY[k],
2167                                                        mode_lib->vba.MaxNumSwathY[k],
2168                                                        mode_lib->vba.PrefetchSourceLinesC[k],
2169                                                        mode_lib->vba.BytePerPixelDETC[k],
2170                                                        mode_lib->vba.VInitPreFillC[k],
2171                                                        mode_lib->vba.MaxNumSwathC[k],
2172                                                        mode_lib->vba.SwathHeightY[k],
2173                                                        mode_lib->vba.SwathHeightC[k],
2174                                                        TWait,
2175                                                        mode_lib->vba.XFCEnabled[k],
2176                                                        mode_lib->vba.XFCRemoteSurfaceFlipDelay,
2177                                                        mode_lib->vba.Interlace[k],
2178                                                        mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
2179                                                        mode_lib->vba.DSTXAfterScaler[k],
2180                                                        mode_lib->vba.DSTYAfterScaler[k],
2181                                                        &mode_lib->vba.DestinationLinesForPrefetch[k],
2182                                                        &mode_lib->vba.PrefetchBandwidth[k],
2183                                                        &mode_lib->vba.DestinationLinesToRequestVMInVBlank[k],
2184                                                        &mode_lib->vba.DestinationLinesToRequestRowInVBlank[k],
2185                                                        &mode_lib->vba.VRatioPrefetchY[k],
2186                                                        &mode_lib->vba.VRatioPrefetchC[k],
2187                                                        &mode_lib->vba.RequiredPrefetchPixDataBWLuma[k],
2188                                                        &mode_lib->vba.Tno_bw[k],
2189                                                        &mode_lib->vba.VUpdateOffsetPix[k],
2190                                                        &mode_lib->vba.VUpdateWidthPix[k],
2191                                                        &mode_lib->vba.VReadyOffsetPix[k]);
2192
2193                        if (mode_lib->vba.BlendingAndTiming[k] == k) {
2194                                mode_lib->vba.VStartup[k] = dml_min(
2195                                                mode_lib->vba.VStartupLines,
2196                                                mode_lib->vba.MaxVStartupLines[k]);
2197                                if (mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata
2198                                                != 0) {
2199                                        mode_lib->vba.VStartup[k] =
2200                                                        mode_lib->vba.VStartupRequiredWhenNotEnoughTimeForDynamicMetadata;
2201                                }
2202                        } else {
2203                                mode_lib->vba.VStartup[k] =
2204                                                dml_min(
2205                                                                mode_lib->vba.VStartupLines,
2206                                                                mode_lib->vba.MaxVStartupLines[mode_lib->vba.BlendingAndTiming[k]]);
2207                        }
2208                }
2209
2210                for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2211
2212                        if (mode_lib->vba.PDEAndMetaPTEBytesFrame[k] == 0)
2213                                mode_lib->vba.prefetch_vm_bw[k] = 0;
2214                        else if (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k] > 0) {
2215                                mode_lib->vba.prefetch_vm_bw[k] =
2216                                                (double) mode_lib->vba.PDEAndMetaPTEBytesFrame[k]
2217                                                                / (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k]
2218                                                                                * mode_lib->vba.HTotal[k]
2219                                                                                / mode_lib->vba.PixelClock[k]);
2220                        } else {
2221                                mode_lib->vba.prefetch_vm_bw[k] = 0;
2222                                prefetch_vm_bw_valid = false;
2223                        }
2224                        if (mode_lib->vba.MetaRowByte[k] + mode_lib->vba.PixelPTEBytesPerRow[k]
2225                                        == 0)
2226                                mode_lib->vba.prefetch_row_bw[k] = 0;
2227                        else if (mode_lib->vba.DestinationLinesToRequestRowInVBlank[k] > 0) {
2228                                mode_lib->vba.prefetch_row_bw[k] =
2229                                                (double) (mode_lib->vba.MetaRowByte[k]
2230                                                                + mode_lib->vba.PixelPTEBytesPerRow[k])
2231                                                                / (mode_lib->vba.DestinationLinesToRequestRowInVBlank[k]
2232                                                                                * mode_lib->vba.HTotal[k]
2233                                                                                / mode_lib->vba.PixelClock[k]);
2234                        } else {
2235                                mode_lib->vba.prefetch_row_bw[k] = 0;
2236                                prefetch_row_bw_valid = false;
2237                        }
2238
2239                        MaxTotalRDBandwidth =
2240                                        MaxTotalRDBandwidth + mode_lib->vba.cursor_bw[k]
2241                                                        + dml_max(
2242                                                                        mode_lib->vba.prefetch_vm_bw[k],
2243                                                                        dml_max(
2244                                                                                        mode_lib->vba.prefetch_row_bw[k],
2245                                                                                        dml_max(
2246                                                                                                        mode_lib->vba.ReadBandwidthPlaneLuma[k]
2247                                                                                                                        + mode_lib->vba.ReadBandwidthPlaneChroma[k],
2248                                                                                                        mode_lib->vba.RequiredPrefetchPixDataBWLuma[k])
2249                                                                                                        + mode_lib->vba.meta_row_bw[k]
2250                                                                                                        + mode_lib->vba.dpte_row_bw[k]));
2251
2252                        if (mode_lib->vba.DestinationLinesForPrefetch[k] < 2)
2253                                DestinationLineTimesForPrefetchLessThan2 = true;
2254                        if (mode_lib->vba.VRatioPrefetchY[k] > 4
2255                                        || mode_lib->vba.VRatioPrefetchC[k] > 4)
2256                                VRatioPrefetchMoreThan4 = true;
2257                }
2258
2259                if (MaxTotalRDBandwidth <= mode_lib->vba.ReturnBW && prefetch_vm_bw_valid
2260                                && prefetch_row_bw_valid && !VRatioPrefetchMoreThan4
2261                                && !DestinationLineTimesForPrefetchLessThan2)
2262                        mode_lib->vba.PrefetchModeSupported = true;
2263                else {
2264                        mode_lib->vba.PrefetchModeSupported = false;
2265                        dml_print(
2266                                        "DML: CalculatePrefetchSchedule ***failed***. Bandwidth violation. Results are NOT valid\n");
2267                }
2268
2269                if (mode_lib->vba.PrefetchModeSupported == true) {
2270                        double final_flip_bw[DC__NUM_DPP__MAX];
2271                        unsigned int ImmediateFlipBytes[DC__NUM_DPP__MAX];
2272                        double total_dcn_read_bw_with_flip = 0;
2273
2274                        mode_lib->vba.BandwidthAvailableForImmediateFlip = mode_lib->vba.ReturnBW;
2275                        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2276                                mode_lib->vba.BandwidthAvailableForImmediateFlip =
2277                                                mode_lib->vba.BandwidthAvailableForImmediateFlip
2278                                                                - mode_lib->vba.cursor_bw[k]
2279                                                                - dml_max(
2280                                                                                mode_lib->vba.ReadBandwidthPlaneLuma[k]
2281                                                                                                + mode_lib->vba.ReadBandwidthPlaneChroma[k]
2282                                                                                                + mode_lib->vba.qual_row_bw[k],
2283                                                                                mode_lib->vba.PrefetchBandwidth[k]);
2284                        }
2285
2286                        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2287                                ImmediateFlipBytes[k] = 0;
2288                                if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8
2289                                                && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) {
2290                                        ImmediateFlipBytes[k] =
2291                                                        mode_lib->vba.PDEAndMetaPTEBytesFrame[k]
2292                                                                        + mode_lib->vba.MetaRowByte[k]
2293                                                                        + mode_lib->vba.PixelPTEBytesPerRow[k];
2294                                }
2295                        }
2296                        mode_lib->vba.TotImmediateFlipBytes = 0;
2297                        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2298                                if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8
2299                                                && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) {
2300                                        mode_lib->vba.TotImmediateFlipBytes =
2301                                                        mode_lib->vba.TotImmediateFlipBytes
2302                                                                        + ImmediateFlipBytes[k];
2303                                }
2304                        }
2305                        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2306                                CalculateFlipSchedule(
2307                                                mode_lib,
2308                                                mode_lib->vba.UrgentExtraLatency,
2309                                                mode_lib->vba.UrgentLatencyPixelDataOnly,
2310                                                mode_lib->vba.GPUVMMaxPageTableLevels,
2311                                                mode_lib->vba.GPUVMEnable,
2312                                                mode_lib->vba.BandwidthAvailableForImmediateFlip,
2313                                                mode_lib->vba.TotImmediateFlipBytes,
2314                                                mode_lib->vba.SourcePixelFormat[k],
2315                                                ImmediateFlipBytes[k],
2316                                                mode_lib->vba.HTotal[k]
2317                                                                / mode_lib->vba.PixelClock[k],
2318                                                mode_lib->vba.VRatio[k],
2319                                                mode_lib->vba.Tno_bw[k],
2320                                                mode_lib->vba.PDEAndMetaPTEBytesFrame[k],
2321                                                mode_lib->vba.MetaRowByte[k],
2322                                                mode_lib->vba.PixelPTEBytesPerRow[k],
2323                                                mode_lib->vba.DCCEnable[k],
2324                                                mode_lib->vba.dpte_row_height[k],
2325                                                mode_lib->vba.meta_row_height[k],
2326                                                mode_lib->vba.qual_row_bw[k],
2327                                                &mode_lib->vba.DestinationLinesToRequestVMInImmediateFlip[k],
2328                                                &mode_lib->vba.DestinationLinesToRequestRowInImmediateFlip[k],
2329                                                &final_flip_bw[k],
2330                                                &mode_lib->vba.ImmediateFlipSupportedForPipe[k]);
2331                        }
2332                        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2333                                total_dcn_read_bw_with_flip =
2334                                                total_dcn_read_bw_with_flip
2335                                                                + mode_lib->vba.cursor_bw[k]
2336                                                                + dml_max(
2337                                                                                mode_lib->vba.prefetch_vm_bw[k],
2338                                                                                dml_max(
2339                                                                                                mode_lib->vba.prefetch_row_bw[k],
2340                                                                                                final_flip_bw[k]
2341                                                                                                                + dml_max(
2342                                                                                                                                mode_lib->vba.ReadBandwidthPlaneLuma[k]
2343                                                                                                                                                + mode_lib->vba.ReadBandwidthPlaneChroma[k],
2344                                                                                                                                mode_lib->vba.RequiredPrefetchPixDataBWLuma[k])));
2345                        }
2346                        mode_lib->vba.ImmediateFlipSupported = true;
2347                        if (total_dcn_read_bw_with_flip > mode_lib->vba.ReturnBW) {
2348                                mode_lib->vba.ImmediateFlipSupported = false;
2349                        }
2350                        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2351                                if (mode_lib->vba.ImmediateFlipSupportedForPipe[k] == false) {
2352                                        mode_lib->vba.ImmediateFlipSupported = false;
2353                                }
2354                        }
2355                } else {
2356                        mode_lib->vba.ImmediateFlipSupported = false;
2357                }
2358
2359                for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2360                        if (mode_lib->vba.ErrorResult[k]) {
2361                                mode_lib->vba.PrefetchModeSupported = false;
2362                                dml_print(
2363                                                "DML: CalculatePrefetchSchedule ***failed***. Prefetch schedule violation. Results are NOT valid\n");
2364                        }
2365                }
2366
2367                mode_lib->vba.VStartupLines = mode_lib->vba.VStartupLines + 1;
2368        } while (!((mode_lib->vba.PrefetchModeSupported
2369                        && (!mode_lib->vba.ImmediateFlipSupport
2370                                        || mode_lib->vba.ImmediateFlipSupported))
2371                        || mode_lib->vba.MaximumMaxVStartupLines < mode_lib->vba.VStartupLines));
2372
2373        //Display Pipeline Delivery Time in Prefetch
2374        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2375                if (mode_lib->vba.VRatioPrefetchY[k] <= 1) {
2376                        mode_lib->vba.DisplayPipeLineDeliveryTimeLumaPrefetch[k] =
2377                                        mode_lib->vba.SwathWidthY[k] * mode_lib->vba.DPPPerPlane[k]
2378                                                        / mode_lib->vba.HRatio[k]
2379                                                        / mode_lib->vba.PixelClock[k];
2380                } else {
2381                        mode_lib->vba.DisplayPipeLineDeliveryTimeLumaPrefetch[k] =
2382                                        mode_lib->vba.SwathWidthY[k]
2383                                                        / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k]
2384                                                        / mode_lib->vba.DPPCLK[k];
2385                }
2386                if (mode_lib->vba.BytePerPixelDETC[k] == 0) {
2387                        mode_lib->vba.DisplayPipeLineDeliveryTimeChromaPrefetch[k] = 0;
2388                } else {
2389                        if (mode_lib->vba.VRatioPrefetchC[k] <= 1) {
2390                                mode_lib->vba.DisplayPipeLineDeliveryTimeChromaPrefetch[k] =
2391                                                mode_lib->vba.SwathWidthY[k]
2392                                                                * mode_lib->vba.DPPPerPlane[k]
2393                                                                / mode_lib->vba.HRatio[k]
2394                                                                / mode_lib->vba.PixelClock[k];
2395                        } else {
2396                                mode_lib->vba.DisplayPipeLineDeliveryTimeChromaPrefetch[k] =
2397                                                mode_lib->vba.SwathWidthY[k]
2398                                                                / mode_lib->vba.PSCL_THROUGHPUT_LUMA[k]
2399                                                                / mode_lib->vba.DPPCLK[k];
2400                        }
2401                }
2402        }
2403
2404        // Min TTUVBlank
2405        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2406                if (mode_lib->vba.PrefetchMode[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb] == 0) {
2407                        mode_lib->vba.AllowDRAMClockChangeDuringVBlank[k] = true;
2408                        mode_lib->vba.AllowDRAMSelfRefreshDuringVBlank[k] = true;
2409                        mode_lib->vba.MinTTUVBlank[k] = dml_max(
2410                                        mode_lib->vba.DRAMClockChangeWatermark,
2411                                        dml_max(
2412                                                        mode_lib->vba.StutterEnterPlusExitWatermark,
2413                                                        mode_lib->vba.UrgentWatermark));
2414                } else if (mode_lib->vba.PrefetchMode[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb] == 1) {
2415                        mode_lib->vba.AllowDRAMClockChangeDuringVBlank[k] = false;
2416                        mode_lib->vba.AllowDRAMSelfRefreshDuringVBlank[k] = true;
2417                        mode_lib->vba.MinTTUVBlank[k] = dml_max(
2418                                        mode_lib->vba.StutterEnterPlusExitWatermark,
2419                                        mode_lib->vba.UrgentWatermark);
2420                } else {
2421                        mode_lib->vba.AllowDRAMClockChangeDuringVBlank[k] = false;
2422                        mode_lib->vba.AllowDRAMSelfRefreshDuringVBlank[k] = false;
2423                        mode_lib->vba.MinTTUVBlank[k] = mode_lib->vba.UrgentWatermark;
2424                }
2425                if (!mode_lib->vba.DynamicMetadataEnable[k])
2426                        mode_lib->vba.MinTTUVBlank[k] = mode_lib->vba.TCalc
2427                                        + mode_lib->vba.MinTTUVBlank[k];
2428        }
2429
2430        // DCC Configuration
2431        mode_lib->vba.ActiveDPPs = 0;
2432        // NB P-State/DRAM Clock Change Support
2433        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2434                mode_lib->vba.ActiveDPPs = mode_lib->vba.ActiveDPPs + mode_lib->vba.DPPPerPlane[k];
2435        }
2436
2437        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2438                double EffectiveLBLatencyHidingY;
2439                double EffectiveLBLatencyHidingC;
2440                double DPPOutputBufferLinesY;
2441                double DPPOutputBufferLinesC;
2442                double DPPOPPBufferingY;
2443                double MaxDETBufferingTimeY;
2444                double ActiveDRAMClockChangeLatencyMarginY;
2445
2446                mode_lib->vba.LBLatencyHidingSourceLinesY =
2447                                dml_min(
2448                                                mode_lib->vba.MaxLineBufferLines,
2449                                                (unsigned int) dml_floor(
2450                                                                (double) mode_lib->vba.LineBufferSize
2451                                                                                / mode_lib->vba.LBBitPerPixel[k]
2452                                                                                / (mode_lib->vba.SwathWidthY[k]
2453                                                                                                / dml_max(
2454                                                                                                                mode_lib->vba.HRatio[k],
2455                                                                                                                1.0)),
2456                                                                1)) - (mode_lib->vba.vtaps[k] - 1);
2457
2458                mode_lib->vba.LBLatencyHidingSourceLinesC =
2459                                dml_min(
2460                                                mode_lib->vba.MaxLineBufferLines,
2461                                                (unsigned int) dml_floor(
2462                                                                (double) mode_lib->vba.LineBufferSize
2463                                                                                / mode_lib->vba.LBBitPerPixel[k]
2464                                                                                / (mode_lib->vba.SwathWidthY[k]
2465                                                                                                / 2.0
2466                                                                                                / dml_max(
2467                                                                                                                mode_lib->vba.HRatio[k]
2468                                                                                                                                / 2,
2469                                                                                                                1.0)),
2470                                                                1))
2471                                                - (mode_lib->vba.VTAPsChroma[k] - 1);
2472
2473                EffectiveLBLatencyHidingY = mode_lib->vba.LBLatencyHidingSourceLinesY
2474                                / mode_lib->vba.VRatio[k]
2475                                * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]);
2476
2477                EffectiveLBLatencyHidingC = mode_lib->vba.LBLatencyHidingSourceLinesC
2478                                / (mode_lib->vba.VRatio[k] / 2)
2479                                * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]);
2480
2481                if (mode_lib->vba.SwathWidthY[k] > 2 * mode_lib->vba.DPPOutputBufferPixels) {
2482                        DPPOutputBufferLinesY = mode_lib->vba.DPPOutputBufferPixels
2483                                        / mode_lib->vba.SwathWidthY[k];
2484                } else if (mode_lib->vba.SwathWidthY[k] > mode_lib->vba.DPPOutputBufferPixels) {
2485                        DPPOutputBufferLinesY = 0.5;
2486                } else {
2487                        DPPOutputBufferLinesY = 1;
2488                }
2489
2490                if (mode_lib->vba.SwathWidthY[k] / 2 > 2 * mode_lib->vba.DPPOutputBufferPixels) {
2491                        DPPOutputBufferLinesC = mode_lib->vba.DPPOutputBufferPixels
2492                                        / (mode_lib->vba.SwathWidthY[k] / 2);
2493                } else if (mode_lib->vba.SwathWidthY[k] / 2 > mode_lib->vba.DPPOutputBufferPixels) {
2494                        DPPOutputBufferLinesC = 0.5;
2495                } else {
2496                        DPPOutputBufferLinesC = 1;
2497                }
2498
2499                DPPOPPBufferingY = (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k])
2500                                * (DPPOutputBufferLinesY + mode_lib->vba.OPPOutputBufferLines);
2501                MaxDETBufferingTimeY = mode_lib->vba.FullDETBufferingTimeY[k]
2502                                + (mode_lib->vba.LinesInDETY[k]
2503                                                - mode_lib->vba.LinesInDETYRoundedDownToSwath[k])
2504                                                / mode_lib->vba.SwathHeightY[k]
2505                                                * (mode_lib->vba.HTotal[k]
2506                                                                / mode_lib->vba.PixelClock[k]);
2507
2508                ActiveDRAMClockChangeLatencyMarginY = DPPOPPBufferingY + EffectiveLBLatencyHidingY
2509                                + MaxDETBufferingTimeY - mode_lib->vba.DRAMClockChangeWatermark;
2510
2511                if (mode_lib->vba.ActiveDPPs > 1) {
2512                        ActiveDRAMClockChangeLatencyMarginY =
2513                                        ActiveDRAMClockChangeLatencyMarginY
2514                                                        - (1 - 1 / (mode_lib->vba.ActiveDPPs - 1))
2515                                                                        * mode_lib->vba.SwathHeightY[k]
2516                                                                        * (mode_lib->vba.HTotal[k]
2517                                                                                        / mode_lib->vba.PixelClock[k]);
2518                }
2519
2520                if (mode_lib->vba.BytePerPixelDETC[k] > 0) {
2521                        double DPPOPPBufferingC = (mode_lib->vba.HTotal[k]
2522                                        / mode_lib->vba.PixelClock[k])
2523                                        * (DPPOutputBufferLinesC
2524                                                        + mode_lib->vba.OPPOutputBufferLines);
2525                        double MaxDETBufferingTimeC =
2526                                        mode_lib->vba.FullDETBufferingTimeC[k]
2527                                                        + (mode_lib->vba.LinesInDETC[k]
2528                                                                        - mode_lib->vba.LinesInDETCRoundedDownToSwath[k])
2529                                                                        / mode_lib->vba.SwathHeightC[k]
2530                                                                        * (mode_lib->vba.HTotal[k]
2531                                                                                        / mode_lib->vba.PixelClock[k]);
2532                        double ActiveDRAMClockChangeLatencyMarginC = DPPOPPBufferingC
2533                                        + EffectiveLBLatencyHidingC + MaxDETBufferingTimeC
2534                                        - mode_lib->vba.DRAMClockChangeWatermark;
2535
2536                        if (mode_lib->vba.ActiveDPPs > 1) {
2537                                ActiveDRAMClockChangeLatencyMarginC =
2538                                                ActiveDRAMClockChangeLatencyMarginC
2539                                                                - (1
2540                                                                                - 1
2541                                                                                                / (mode_lib->vba.ActiveDPPs
2542                                                                                                                - 1))
2543                                                                                * mode_lib->vba.SwathHeightC[k]
2544                                                                                * (mode_lib->vba.HTotal[k]
2545                                                                                                / mode_lib->vba.PixelClock[k]);
2546                        }
2547                        mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = dml_min(
2548                                        ActiveDRAMClockChangeLatencyMarginY,
2549                                        ActiveDRAMClockChangeLatencyMarginC);
2550                } else {
2551                        mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] =
2552                                        ActiveDRAMClockChangeLatencyMarginY;
2553                }
2554
2555                if (mode_lib->vba.WritebackEnable[k]) {
2556                        double WritebackDRAMClockChangeLatencyMargin;
2557
2558                        if (mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) {
2559                                WritebackDRAMClockChangeLatencyMargin =
2560                                                (double) (mode_lib->vba.WritebackInterfaceLumaBufferSize
2561                                                                + mode_lib->vba.WritebackInterfaceChromaBufferSize)
2562                                                                / (mode_lib->vba.WritebackDestinationWidth[k]
2563                                                                                * mode_lib->vba.WritebackDestinationHeight[k]
2564                                                                                / (mode_lib->vba.WritebackSourceHeight[k]
2565                                                                                                * mode_lib->vba.HTotal[k]
2566                                                                                                / mode_lib->vba.PixelClock[k])
2567                                                                                * 4)
2568                                                                - mode_lib->vba.WritebackDRAMClockChangeWatermark;
2569                        } else if (mode_lib->vba.WritebackPixelFormat[k] == dm_420_10) {
2570                                WritebackDRAMClockChangeLatencyMargin =
2571                                                dml_min(
2572                                                                (double) mode_lib->vba.WritebackInterfaceLumaBufferSize
2573                                                                                * 8.0 / 10,
2574                                                                2.0
2575                                                                                * mode_lib->vba.WritebackInterfaceChromaBufferSize
2576                                                                                * 8 / 10)
2577                                                                / (mode_lib->vba.WritebackDestinationWidth[k]
2578                                                                                * mode_lib->vba.WritebackDestinationHeight[k]
2579                                                                                / (mode_lib->vba.WritebackSourceHeight[k]
2580                                                                                                * mode_lib->vba.HTotal[k]
2581                                                                                                / mode_lib->vba.PixelClock[k]))
2582                                                                - mode_lib->vba.WritebackDRAMClockChangeWatermark;
2583                        } else {
2584                                WritebackDRAMClockChangeLatencyMargin =
2585                                                dml_min(
2586                                                                (double) mode_lib->vba.WritebackInterfaceLumaBufferSize,
2587                                                                2.0
2588                                                                                * mode_lib->vba.WritebackInterfaceChromaBufferSize)
2589                                                                / (mode_lib->vba.WritebackDestinationWidth[k]
2590                                                                                * mode_lib->vba.WritebackDestinationHeight[k]
2591                                                                                / (mode_lib->vba.WritebackSourceHeight[k]
2592                                                                                                * mode_lib->vba.HTotal[k]
2593                                                                                                / mode_lib->vba.PixelClock[k]))
2594                                                                - mode_lib->vba.WritebackDRAMClockChangeWatermark;
2595                        }
2596                        mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k] = dml_min(
2597                                        mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k],
2598                                        WritebackDRAMClockChangeLatencyMargin);
2599                }
2600        }
2601
2602        {
2603        float SecondMinActiveDRAMClockChangeMarginOneDisplayInVBLank = 999999;
2604        int PlaneWithMinActiveDRAMClockChangeMargin = -1;
2605
2606        mode_lib->vba.MinActiveDRAMClockChangeMargin = 999999;
2607        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2608                if (mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k]
2609                                < mode_lib->vba.MinActiveDRAMClockChangeMargin) {
2610                        mode_lib->vba.MinActiveDRAMClockChangeMargin =
2611                                        mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k];
2612                        if (mode_lib->vba.BlendingAndTiming[k] == k) {
2613                                PlaneWithMinActiveDRAMClockChangeMargin = k;
2614                        } else {
2615                                for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) {
2616                                        if (mode_lib->vba.BlendingAndTiming[k] == j) {
2617                                                PlaneWithMinActiveDRAMClockChangeMargin = j;
2618                                        }
2619                                }
2620                        }
2621                }
2622        }
2623
2624        mode_lib->vba.MinActiveDRAMClockChangeLatencySupported =
2625                        mode_lib->vba.MinActiveDRAMClockChangeMargin
2626                                        + mode_lib->vba.DRAMClockChangeLatency;
2627        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2628                if (!((k == PlaneWithMinActiveDRAMClockChangeMargin) && (mode_lib->vba.BlendingAndTiming[k] == k))
2629                                && !(mode_lib->vba.BlendingAndTiming[k] == PlaneWithMinActiveDRAMClockChangeMargin)
2630                                && mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k]
2631                                                < SecondMinActiveDRAMClockChangeMarginOneDisplayInVBLank) {
2632                        SecondMinActiveDRAMClockChangeMarginOneDisplayInVBLank =
2633                                        mode_lib->vba.ActiveDRAMClockChangeLatencyMargin[k];
2634                }
2635        }
2636
2637        if (mode_lib->vba.DRAMClockChangeSupportsVActive &&
2638                        mode_lib->vba.MinActiveDRAMClockChangeMargin > 60) {
2639                mode_lib->vba.DRAMClockChangeWatermark += 25;
2640
2641                for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2642                        if (mode_lib->vba.PrefetchMode[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb] == 0) {
2643                                if (mode_lib->vba.DRAMClockChangeWatermark >
2644                                        dml_max(mode_lib->vba.StutterEnterPlusExitWatermark, mode_lib->vba.UrgentWatermark))
2645                                        mode_lib->vba.MinTTUVBlank[k] += 25;
2646                        }
2647                }
2648
2649                mode_lib->vba.DRAMClockChangeSupport[0][0] = dm_dram_clock_change_vactive;
2650        } else if (mode_lib->vba.DummyPStateCheck &&
2651                        mode_lib->vba.MinActiveDRAMClockChangeMargin > 0) {
2652                mode_lib->vba.DRAMClockChangeSupport[0][0] = dm_dram_clock_change_vactive;
2653        } else {
2654                if ((mode_lib->vba.SynchronizedVBlank
2655                                || mode_lib->vba.NumberOfActivePlanes == 1
2656                                || (SecondMinActiveDRAMClockChangeMarginOneDisplayInVBLank > 0 &&
2657                                                mode_lib->vba.AllowDramClockChangeOneDisplayVactive))
2658                                        && mode_lib->vba.PrefetchMode[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb] == 0) {
2659                        mode_lib->vba.DRAMClockChangeSupport[0][0] = dm_dram_clock_change_vblank;
2660                        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2661                                if (!mode_lib->vba.AllowDRAMClockChangeDuringVBlank[k]) {
2662                                        mode_lib->vba.DRAMClockChangeSupport[0][0] =
2663                                                        dm_dram_clock_change_unsupported;
2664                                }
2665                        }
2666                } else {
2667                        mode_lib->vba.DRAMClockChangeSupport[0][0] = dm_dram_clock_change_unsupported;
2668                }
2669        }
2670        }
2671        for (k = 0; k <= mode_lib->vba.soc.num_states; k++)
2672                for (j = 0; j < 2; j++)
2673                        mode_lib->vba.DRAMClockChangeSupport[k][j] = mode_lib->vba.DRAMClockChangeSupport[0][0];
2674
2675        //XFC Parameters:
2676        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2677                if (mode_lib->vba.XFCEnabled[k] == true) {
2678                        double TWait;
2679
2680                        mode_lib->vba.XFCSlaveVUpdateOffset[k] = mode_lib->vba.XFCTSlvVupdateOffset;
2681                        mode_lib->vba.XFCSlaveVupdateWidth[k] = mode_lib->vba.XFCTSlvVupdateWidth;
2682                        mode_lib->vba.XFCSlaveVReadyOffset[k] = mode_lib->vba.XFCTSlvVreadyOffset;
2683                        TWait = CalculateTWait(
2684                                        mode_lib->vba.PrefetchMode[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb],
2685                                        mode_lib->vba.DRAMClockChangeLatency,
2686                                        mode_lib->vba.UrgentLatencyPixelDataOnly,
2687                                        mode_lib->vba.SREnterPlusExitTime);
2688                        mode_lib->vba.XFCRemoteSurfaceFlipDelay = CalculateRemoteSurfaceFlipDelay(
2689                                        mode_lib,
2690                                        mode_lib->vba.VRatio[k],
2691                                        mode_lib->vba.SwathWidthY[k],
2692                                        dml_ceil(mode_lib->vba.BytePerPixelDETY[k], 1),
2693                                        mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
2694                                        mode_lib->vba.XFCTSlvVupdateOffset,
2695                                        mode_lib->vba.XFCTSlvVupdateWidth,
2696                                        mode_lib->vba.XFCTSlvVreadyOffset,
2697                                        mode_lib->vba.XFCXBUFLatencyTolerance,
2698                                        mode_lib->vba.XFCFillBWOverhead,
2699                                        mode_lib->vba.XFCSlvChunkSize,
2700                                        mode_lib->vba.XFCBusTransportTime,
2701                                        mode_lib->vba.TCalc,
2702                                        TWait,
2703                                        &mode_lib->vba.SrcActiveDrainRate,
2704                                        &mode_lib->vba.TInitXFill,
2705                                        &mode_lib->vba.TslvChk);
2706                        mode_lib->vba.XFCRemoteSurfaceFlipLatency[k] =
2707                                        dml_floor(
2708                                                        mode_lib->vba.XFCRemoteSurfaceFlipDelay
2709                                                                        / (mode_lib->vba.HTotal[k]
2710                                                                                        / mode_lib->vba.PixelClock[k]),
2711                                                        1);
2712                        mode_lib->vba.XFCTransferDelay[k] =
2713                                        dml_ceil(
2714                                                        mode_lib->vba.XFCBusTransportTime
2715                                                                        / (mode_lib->vba.HTotal[k]
2716                                                                                        / mode_lib->vba.PixelClock[k]),
2717                                                        1);
2718                        mode_lib->vba.XFCPrechargeDelay[k] =
2719                                        dml_ceil(
2720                                                        (mode_lib->vba.XFCBusTransportTime
2721                                                                        + mode_lib->vba.TInitXFill
2722                                                                        + mode_lib->vba.TslvChk)
2723                                                                        / (mode_lib->vba.HTotal[k]
2724                                                                                        / mode_lib->vba.PixelClock[k]),
2725                                                        1);
2726                        mode_lib->vba.InitFillLevel = mode_lib->vba.XFCXBUFLatencyTolerance
2727                                        * mode_lib->vba.SrcActiveDrainRate;
2728                        mode_lib->vba.FinalFillMargin =
2729                                        (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k]
2730                                                        + mode_lib->vba.DestinationLinesToRequestRowInVBlank[k])
2731                                                        * mode_lib->vba.HTotal[k]
2732                                                        / mode_lib->vba.PixelClock[k]
2733                                                        * mode_lib->vba.SrcActiveDrainRate
2734                                                        + mode_lib->vba.XFCFillConstant;
2735                        mode_lib->vba.FinalFillLevel = mode_lib->vba.XFCRemoteSurfaceFlipDelay
2736                                        * mode_lib->vba.SrcActiveDrainRate
2737                                        + mode_lib->vba.FinalFillMargin;
2738                        mode_lib->vba.RemainingFillLevel = dml_max(
2739                                        0.0,
2740                                        mode_lib->vba.FinalFillLevel - mode_lib->vba.InitFillLevel);
2741                        mode_lib->vba.TFinalxFill = mode_lib->vba.RemainingFillLevel
2742                                        / (mode_lib->vba.SrcActiveDrainRate
2743                                                        * mode_lib->vba.XFCFillBWOverhead / 100);
2744                        mode_lib->vba.XFCPrefetchMargin[k] =
2745                                        mode_lib->vba.XFCRemoteSurfaceFlipDelay
2746                                                        + mode_lib->vba.TFinalxFill
2747                                                        + (mode_lib->vba.DestinationLinesToRequestVMInVBlank[k]
2748                                                                        + mode_lib->vba.DestinationLinesToRequestRowInVBlank[k])
2749                                                                        * mode_lib->vba.HTotal[k]
2750                                                                        / mode_lib->vba.PixelClock[k];
2751                } else {
2752                        mode_lib->vba.XFCSlaveVUpdateOffset[k] = 0;
2753                        mode_lib->vba.XFCSlaveVupdateWidth[k] = 0;
2754                        mode_lib->vba.XFCSlaveVReadyOffset[k] = 0;
2755                        mode_lib->vba.XFCRemoteSurfaceFlipLatency[k] = 0;
2756                        mode_lib->vba.XFCPrechargeDelay[k] = 0;
2757                        mode_lib->vba.XFCTransferDelay[k] = 0;
2758                        mode_lib->vba.XFCPrefetchMargin[k] = 0;
2759                }
2760        }
2761        {
2762                unsigned int VStartupMargin = 0;
2763                bool FirstMainPlane = true;
2764
2765                for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2766                        if (mode_lib->vba.BlendingAndTiming[k] == k) {
2767                                unsigned int Margin = (mode_lib->vba.MaxVStartupLines[k] - mode_lib->vba.VStartup[k])
2768                                                * mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k];
2769
2770                                if (FirstMainPlane) {
2771                                        VStartupMargin = Margin;
2772                                        FirstMainPlane = false;
2773                                } else
2774                                        VStartupMargin = dml_min(VStartupMargin, Margin);
2775                }
2776
2777                if (mode_lib->vba.UseMaximumVStartup) {
2778                        if (mode_lib->vba.VTotal_Max[k] == mode_lib->vba.VTotal[k]) {
2779                                //only use max vstart if it is not drr or lateflip.
2780                                mode_lib->vba.VStartup[k] = mode_lib->vba.MaxVStartupLines[mode_lib->vba.BlendingAndTiming[k]];
2781                        }
2782                }
2783        }
2784}
2785}
2786
2787static void dml20v2_DisplayPipeConfiguration(struct display_mode_lib *mode_lib)
2788{
2789        double BytePerPixDETY;
2790        double BytePerPixDETC;
2791        double Read256BytesBlockHeightY;
2792        double Read256BytesBlockHeightC;
2793        double Read256BytesBlockWidthY;
2794        double Read256BytesBlockWidthC;
2795        double MaximumSwathHeightY;
2796        double MaximumSwathHeightC;
2797        double MinimumSwathHeightY;
2798        double MinimumSwathHeightC;
2799        double SwathWidth;
2800        double SwathWidthGranularityY;
2801        double SwathWidthGranularityC;
2802        double RoundedUpMaxSwathSizeBytesY;
2803        double RoundedUpMaxSwathSizeBytesC;
2804        unsigned int j, k;
2805
2806        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
2807                bool MainPlaneDoesODMCombine = false;
2808
2809                if (mode_lib->vba.SourcePixelFormat[k] == dm_444_64) {
2810                        BytePerPixDETY = 8;
2811                        BytePerPixDETC = 0;
2812                } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_32) {
2813                        BytePerPixDETY = 4;
2814                        BytePerPixDETC = 0;
2815                } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_16) {
2816                        BytePerPixDETY = 2;
2817                        BytePerPixDETC = 0;
2818                } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_8) {
2819                        BytePerPixDETY = 1;
2820                        BytePerPixDETC = 0;
2821                } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8) {
2822                        BytePerPixDETY = 1;
2823                        BytePerPixDETC = 2;
2824                } else {
2825                        BytePerPixDETY = 4.0 / 3.0;
2826                        BytePerPixDETC = 8.0 / 3.0;
2827                }
2828
2829                if ((mode_lib->vba.SourcePixelFormat[k] == dm_444_64
2830                                || mode_lib->vba.SourcePixelFormat[k] == dm_444_32
2831                                || mode_lib->vba.SourcePixelFormat[k] == dm_444_16
2832                                || mode_lib->vba.SourcePixelFormat[k] == dm_444_8)) {
2833                        if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
2834                                Read256BytesBlockHeightY = 1;
2835                        } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_64) {
2836                                Read256BytesBlockHeightY = 4;
2837                        } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_32
2838                                        || mode_lib->vba.SourcePixelFormat[k] == dm_444_16) {
2839                                Read256BytesBlockHeightY = 8;
2840                        } else {
2841                                Read256BytesBlockHeightY = 16;
2842                        }
2843                        Read256BytesBlockWidthY = 256 / dml_ceil(BytePerPixDETY, 1)
2844                                        / Read256BytesBlockHeightY;
2845                        Read256BytesBlockHeightC = 0;
2846                        Read256BytesBlockWidthC = 0;
2847                } else {
2848                        if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
2849                                Read256BytesBlockHeightY = 1;
2850                                Read256BytesBlockHeightC = 1;
2851                        } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8) {
2852                                Read256BytesBlockHeightY = 16;
2853                                Read256BytesBlockHeightC = 8;
2854                        } else {
2855                                Read256BytesBlockHeightY = 8;
2856                                Read256BytesBlockHeightC = 8;
2857                        }
2858                        Read256BytesBlockWidthY = 256 / dml_ceil(BytePerPixDETY, 1)
2859                                        / Read256BytesBlockHeightY;
2860                        Read256BytesBlockWidthC = 256 / dml_ceil(BytePerPixDETC, 2)
2861                                        / Read256BytesBlockHeightC;
2862                }
2863
2864                if (mode_lib->vba.SourceScan[k] == dm_horz) {
2865                        MaximumSwathHeightY = Read256BytesBlockHeightY;
2866                        MaximumSwathHeightC = Read256BytesBlockHeightC;
2867                } else {
2868                        MaximumSwathHeightY = Read256BytesBlockWidthY;
2869                        MaximumSwathHeightC = Read256BytesBlockWidthC;
2870                }
2871
2872                if ((mode_lib->vba.SourcePixelFormat[k] == dm_444_64
2873                                || mode_lib->vba.SourcePixelFormat[k] == dm_444_32
2874                                || mode_lib->vba.SourcePixelFormat[k] == dm_444_16
2875                                || mode_lib->vba.SourcePixelFormat[k] == dm_444_8)) {
2876                        if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear
2877                                        || (mode_lib->vba.SourcePixelFormat[k] == dm_444_64
2878                                                        && (mode_lib->vba.SurfaceTiling[k]
2879                                                                        == dm_sw_4kb_s
2880                                                                        || mode_lib->vba.SurfaceTiling[k]
2881                                                                                        == dm_sw_4kb_s_x
2882                                                                        || mode_lib->vba.SurfaceTiling[k]
2883                                                                                        == dm_sw_64kb_s
2884                                                                        || mode_lib->vba.SurfaceTiling[k]
2885                                                                                        == dm_sw_64kb_s_t
2886                                                                        || mode_lib->vba.SurfaceTiling[k]
2887                                                                                        == dm_sw_64kb_s_x
2888                                                                        || mode_lib->vba.SurfaceTiling[k]
2889                                                                                        == dm_sw_var_s
2890                                                                        || mode_lib->vba.SurfaceTiling[k]
2891                                                                                        == dm_sw_var_s_x)
2892                                                        && mode_lib->vba.SourceScan[k] == dm_horz)) {
2893                                MinimumSwathHeightY = MaximumSwathHeightY;
2894                        } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_8
2895                                        && mode_lib->vba.SourceScan[k] != dm_horz) {
2896                                MinimumSwathHeightY = MaximumSwathHeightY;
2897                        } else {
2898                                MinimumSwathHeightY = MaximumSwathHeightY / 2.0;
2899                        }
2900                        MinimumSwathHeightC = MaximumSwathHeightC;
2901                } else {
2902                        if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
2903                                MinimumSwathHeightY = MaximumSwathHeightY;
2904                                MinimumSwathHeightC = MaximumSwathHeightC;
2905                        } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8
2906                                        && mode_lib->vba.SourceScan[k] == dm_horz) {
2907                                MinimumSwathHeightY = MaximumSwathHeightY / 2.0;
2908                                MinimumSwathHeightC = MaximumSwathHeightC;
2909                        } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10
2910                                        && mode_lib->vba.SourceScan[k] == dm_horz) {
2911                                MinimumSwathHeightC = MaximumSwathHeightC / 2.0;
2912                                MinimumSwathHeightY = MaximumSwathHeightY;
2913                        } else {
2914                                MinimumSwathHeightY = MaximumSwathHeightY;
2915                                MinimumSwathHeightC = MaximumSwathHeightC;
2916                        }
2917                }
2918
2919                if (mode_lib->vba.SourceScan[k] == dm_horz) {
2920                        SwathWidth = mode_lib->vba.ViewportWidth[k];
2921                } else {
2922                        SwathWidth = mode_lib->vba.ViewportHeight[k];
2923                }
2924
2925                if (mode_lib->vba.ODMCombineEnabled[k] == dm_odm_combine_mode_2to1) {
2926                        MainPlaneDoesODMCombine = true;
2927                }
2928                for (j = 0; j < mode_lib->vba.NumberOfActivePlanes; ++j) {
2929                        if (mode_lib->vba.BlendingAndTiming[k] == j
2930                                        && mode_lib->vba.ODMCombineEnabled[k] == dm_odm_combine_mode_2to1) {
2931                                MainPlaneDoesODMCombine = true;
2932                        }
2933                }
2934
2935                if (MainPlaneDoesODMCombine == true) {
2936                        SwathWidth = dml_min(
2937                                        SwathWidth,
2938                                        mode_lib->vba.HActive[k] / 2.0 * mode_lib->vba.HRatio[k]);
2939                } else {
2940                        if (mode_lib->vba.DPPPerPlane[k] == 0)
2941                                SwathWidth = 0;
2942                        else
2943                                SwathWidth = SwathWidth / mode_lib->vba.DPPPerPlane[k];
2944                }
2945
2946                SwathWidthGranularityY = 256 / dml_ceil(BytePerPixDETY, 1) / MaximumSwathHeightY;
2947                RoundedUpMaxSwathSizeBytesY = (dml_ceil(
2948                                (double) (SwathWidth - 1),
2949                                SwathWidthGranularityY) + SwathWidthGranularityY) * BytePerPixDETY
2950                                * MaximumSwathHeightY;
2951                if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10) {
2952                        RoundedUpMaxSwathSizeBytesY = dml_ceil(RoundedUpMaxSwathSizeBytesY, 256)
2953                                        + 256;
2954                }
2955                if (MaximumSwathHeightC > 0) {
2956                        SwathWidthGranularityC = 256.0 / dml_ceil(BytePerPixDETC, 2)
2957                                        / MaximumSwathHeightC;
2958                        RoundedUpMaxSwathSizeBytesC = (dml_ceil(
2959                                        (double) (SwathWidth / 2.0 - 1),
2960                                        SwathWidthGranularityC) + SwathWidthGranularityC)
2961                                        * BytePerPixDETC * MaximumSwathHeightC;
2962                        if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10) {
2963                                RoundedUpMaxSwathSizeBytesC = dml_ceil(
2964                                                RoundedUpMaxSwathSizeBytesC,
2965                                                256) + 256;
2966                        }
2967                } else
2968                        RoundedUpMaxSwathSizeBytesC = 0.0;
2969
2970                if (RoundedUpMaxSwathSizeBytesY + RoundedUpMaxSwathSizeBytesC
2971                                <= mode_lib->vba.DETBufferSizeInKByte[0] * 1024.0 / 2.0) {
2972                        mode_lib->vba.SwathHeightY[k] = MaximumSwathHeightY;
2973                        mode_lib->vba.SwathHeightC[k] = MaximumSwathHeightC;
2974                } else {
2975                        mode_lib->vba.SwathHeightY[k] = MinimumSwathHeightY;
2976                        mode_lib->vba.SwathHeightC[k] = MinimumSwathHeightC;
2977                }
2978
2979                if (mode_lib->vba.SwathHeightC[k] == 0) {
2980                        mode_lib->vba.DETBufferSizeY[k] = mode_lib->vba.DETBufferSizeInKByte[0] * 1024;
2981                        mode_lib->vba.DETBufferSizeC[k] = 0;
2982                } else if (mode_lib->vba.SwathHeightY[k] <= mode_lib->vba.SwathHeightC[k]) {
2983                        mode_lib->vba.DETBufferSizeY[k] = mode_lib->vba.DETBufferSizeInKByte[0]
2984                                        * 1024.0 / 2;
2985                        mode_lib->vba.DETBufferSizeC[k] = mode_lib->vba.DETBufferSizeInKByte[0]
2986                                        * 1024.0 / 2;
2987                } else {
2988                        mode_lib->vba.DETBufferSizeY[k] = mode_lib->vba.DETBufferSizeInKByte[0]
2989                                        * 1024.0 * 2 / 3;
2990                        mode_lib->vba.DETBufferSizeC[k] = mode_lib->vba.DETBufferSizeInKByte[0]
2991                                        * 1024.0 / 3;
2992                }
2993        }
2994}
2995
2996static double CalculateTWait(
2997                unsigned int PrefetchMode,
2998                double DRAMClockChangeLatency,
2999                double UrgentLatencyPixelDataOnly,
3000                double SREnterPlusExitTime)

3001{
3002        if (PrefetchMode == 0) {
3003                return dml_max(
3004                                DRAMClockChangeLatency + UrgentLatencyPixelDataOnly,
3005                                dml_max(SREnterPlusExitTime, UrgentLatencyPixelDataOnly));
3006        } else if (PrefetchMode == 1) {
3007                return dml_max(SREnterPlusExitTime, UrgentLatencyPixelDataOnly);
3008        } else {
3009                return UrgentLatencyPixelDataOnly;
3010        }
3011}
3012
3013static double CalculateRemoteSurfaceFlipDelay(
3014                struct display_mode_lib *mode_lib,
3015                double VRatio,
3016                double SwathWidth,
3017                double Bpp,
3018                double LineTime,
3019                double XFCTSlvVupdateOffset,
3020                double XFCTSlvVupdateWidth,
3021                double XFCTSlvVreadyOffset,
3022                double XFCXBUFLatencyTolerance,
3023                double XFCFillBWOverhead,
3024                double XFCSlvChunkSize,
3025                double XFCBusTransportTime,
3026                double TCalc,
3027                double TWait,
3028                double *SrcActiveDrainRate,
3029                double *TInitXFill,
3030                double *TslvChk)
3031{
3032        double TSlvSetup, AvgfillRate, result;
3033
3034        *SrcActiveDrainRate = VRatio * SwathWidth * Bpp / LineTime;
3035        TSlvSetup = XFCTSlvVupdateOffset + XFCTSlvVupdateWidth + XFCTSlvVreadyOffset;
3036        *TInitXFill = XFCXBUFLatencyTolerance / (1 + XFCFillBWOverhead / 100);
3037        AvgfillRate = *SrcActiveDrainRate * (1 + XFCFillBWOverhead / 100);
3038        *TslvChk = XFCSlvChunkSize / AvgfillRate;
3039        dml_print(
3040                        "DML::CalculateRemoteSurfaceFlipDelay: SrcActiveDrainRate: %f\n",
3041                        *SrcActiveDrainRate);
3042        dml_print("DML::CalculateRemoteSurfaceFlipDelay: TSlvSetup: %f\n", TSlvSetup);
3043        dml_print("DML::CalculateRemoteSurfaceFlipDelay: TInitXFill: %f\n", *TInitXFill);
3044        dml_print("DML::CalculateRemoteSurfaceFlipDelay: AvgfillRate: %f\n", AvgfillRate);
3045        dml_print("DML::CalculateRemoteSurfaceFlipDelay: TslvChk: %f\n", *TslvChk);
3046        result = 2 * XFCBusTransportTime + TSlvSetup + TCalc + TWait + *TslvChk + *TInitXFill; // TODO: This doesn't seem to match programming guide
3047        dml_print("DML::CalculateRemoteSurfaceFlipDelay: RemoteSurfaceFlipDelay: %f\n", result);
3048        return result;
3049}
3050
3051static double CalculateWriteBackDelay(
3052                enum source_format_class WritebackPixelFormat,
3053                double WritebackHRatio,
3054                double WritebackVRatio,
3055                unsigned int WritebackLumaHTaps,
3056                unsigned int WritebackLumaVTaps,
3057                unsigned int WritebackChromaHTaps,
3058                unsigned int WritebackChromaVTaps,
3059                unsigned int WritebackDestinationWidth)
3060{
3061        double CalculateWriteBackDelay =
3062                        dml_max(
3063                                        dml_ceil(WritebackLumaHTaps / 4.0, 1) / WritebackHRatio,
3064                                        WritebackLumaVTaps * dml_ceil(1.0 / WritebackVRatio, 1)
3065                                                        * dml_ceil(
3066                                                                        WritebackDestinationWidth
3067                                                                                        / 4.0,
3068                                                                        1)
3069                                                        + dml_ceil(1.0 / WritebackVRatio, 1)
3070                                                                        * (dml_ceil(
3071                                                                                        WritebackLumaVTaps
3072                                                                                                        / 4.0,
3073                                                                                        1) + 4));
3074
3075        if (WritebackPixelFormat != dm_444_32) {
3076                CalculateWriteBackDelay =
3077                                dml_max(
3078                                                CalculateWriteBackDelay,
3079                                                dml_max(
3080                                                                dml_ceil(
3081                                                                                WritebackChromaHTaps
3082                                                                                                / 2.0,
3083                                                                                1)
3084                                                                                / (2
3085                                                                                                * WritebackHRatio),
3086                                                                WritebackChromaVTaps
3087                                                                                * dml_ceil(
3088                                                                                                1
3089                                                                                                                / (2
3090                                                                                                                                * WritebackVRatio),
3091                                                                                                1)
3092                                                                                * dml_ceil(
3093                                                                                                WritebackDestinationWidth
3094                                                                                                                / 2.0
3095                                                                                                                / 2.0,
3096                                                                                                1)
3097                                                                                + dml_ceil(
3098                                                                                                1
3099                                                                                                                / (2
3100                                                                                                                                * WritebackVRatio),
3101                                                                                                1)
3102                                                                                                * (dml_ceil(
3103                                                                                                                WritebackChromaVTaps
3104                                                                                                                                / 4.0,
3105                                                                                                                1)
3106                                                                                                                + 4)));
3107        }
3108        return CalculateWriteBackDelay;
3109}
3110
3111static void CalculateActiveRowBandwidth(
3112                bool GPUVMEnable,
3113                enum source_format_class SourcePixelFormat,
3114                double VRatio,
3115                bool DCCEnable,
3116                double LineTime,
3117                unsigned int MetaRowByteLuma,
3118                unsigned int MetaRowByteChroma,
3119                unsigned int meta_row_height_luma,
3120                unsigned int meta_row_height_chroma,
3121                unsigned int PixelPTEBytesPerRowLuma,
3122                unsigned int PixelPTEBytesPerRowChroma,
3123                unsigned int dpte_row_height_luma,
3124                unsigned int dpte_row_height_chroma,
3125                double *meta_row_bw,
3126                double *dpte_row_bw,
3127                double *qual_row_bw)
3128{
3129        if (DCCEnable != true) {
3130                *meta_row_bw = 0;
3131        } else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10) {
3132                *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime)
3133                                + VRatio / 2 * MetaRowByteChroma
3134                                                / (meta_row_height_chroma * LineTime);
3135        } else {
3136                *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime);
3137        }
3138
3139        if (GPUVMEnable != true) {
3140                *dpte_row_bw = 0;
3141        } else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10) {
3142                *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime)
3143                                + VRatio / 2 * PixelPTEBytesPerRowChroma
3144                                                / (dpte_row_height_chroma * LineTime);
3145        } else {
3146                *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime);
3147        }
3148
3149        if ((SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10)) {
3150                *qual_row_bw = *meta_row_bw + *dpte_row_bw;
3151        } else {
3152                *qual_row_bw = 0;
3153        }
3154}
3155
3156static void CalculateFlipSchedule(
3157                struct display_mode_lib *mode_lib,
3158                double UrgentExtraLatency,
3159                double UrgentLatencyPixelDataOnly,
3160                unsigned int GPUVMMaxPageTableLevels,
3161                bool GPUVMEnable,
3162                double BandwidthAvailableForImmediateFlip,
3163                unsigned int TotImmediateFlipBytes,
3164                enum source_format_class SourcePixelFormat,
3165                unsigned int ImmediateFlipBytes,
3166                double LineTime,
3167                double VRatio,
3168                double Tno_bw,
3169                double PDEAndMetaPTEBytesFrame,
3170                unsigned int MetaRowByte,
3171                unsigned int PixelPTEBytesPerRow,
3172                bool DCCEnable,
3173                unsigned int dpte_row_height,
3174                unsigned int meta_row_height,
3175                double qual_row_bw,
3176                double *DestinationLinesToRequestVMInImmediateFlip,
3177                double *DestinationLinesToRequestRowInImmediateFlip,
3178                double *final_flip_bw,
3179                bool *ImmediateFlipSupportedForPipe)
3180{
3181        double min_row_time = 0.0;
3182
3183        if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10) {
3184                *DestinationLinesToRequestVMInImmediateFlip = 0.0;
3185                *DestinationLinesToRequestRowInImmediateFlip = 0.0;
3186                *final_flip_bw = qual_row_bw;
3187                *ImmediateFlipSupportedForPipe = true;
3188        } else {
3189                double TimeForFetchingMetaPTEImmediateFlip;
3190                double TimeForFetchingRowInVBlankImmediateFlip;
3191
3192                if (GPUVMEnable == true) {
3193                        mode_lib->vba.ImmediateFlipBW[0] = BandwidthAvailableForImmediateFlip
3194                                        * ImmediateFlipBytes / TotImmediateFlipBytes;
3195                        TimeForFetchingMetaPTEImmediateFlip =
3196                                        dml_max(
3197                                                        Tno_bw
3198                                                                        + PDEAndMetaPTEBytesFrame
3199                                                                                        / mode_lib->vba.ImmediateFlipBW[0],
3200                                                        dml_max(
3201                                                                        UrgentExtraLatency
3202                                                                                        + UrgentLatencyPixelDataOnly
3203                                                                                                        * (GPUVMMaxPageTableLevels
3204                                                                                                                        - 1),
3205                                                                        LineTime / 4.0));
3206                } else {
3207                        TimeForFetchingMetaPTEImmediateFlip = 0;
3208                }
3209
3210                *DestinationLinesToRequestVMInImmediateFlip = dml_floor(
3211                                4.0 * (TimeForFetchingMetaPTEImmediateFlip / LineTime + 0.125),
3212                                1) / 4.0;
3213
3214                if ((GPUVMEnable == true || DCCEnable == true)) {
3215                        mode_lib->vba.ImmediateFlipBW[0] = BandwidthAvailableForImmediateFlip
3216                                        * ImmediateFlipBytes / TotImmediateFlipBytes;
3217                        TimeForFetchingRowInVBlankImmediateFlip = dml_max(
3218                                        (MetaRowByte + PixelPTEBytesPerRow)
3219                                                        / mode_lib->vba.ImmediateFlipBW[0],
3220                                        dml_max(UrgentLatencyPixelDataOnly, LineTime / 4.0));
3221                } else {
3222                        TimeForFetchingRowInVBlankImmediateFlip = 0;
3223                }
3224
3225                *DestinationLinesToRequestRowInImmediateFlip = dml_floor(
3226                                4.0 * (TimeForFetchingRowInVBlankImmediateFlip / LineTime + 0.125),
3227                                1) / 4.0;
3228
3229                if (GPUVMEnable == true) {
3230                        *final_flip_bw =
3231                                        dml_max(
3232                                                        PDEAndMetaPTEBytesFrame
3233                                                                        / (*DestinationLinesToRequestVMInImmediateFlip
3234                                                                                        * LineTime),
3235                                                        (MetaRowByte + PixelPTEBytesPerRow)
3236                                                                        / (TimeForFetchingRowInVBlankImmediateFlip
3237                                                                                        * LineTime));
3238                } else if (MetaRowByte + PixelPTEBytesPerRow > 0) {
3239                        *final_flip_bw = (MetaRowByte + PixelPTEBytesPerRow)
3240                                        / (TimeForFetchingRowInVBlankImmediateFlip * LineTime);
3241                } else {
3242                        *final_flip_bw = 0;
3243                }
3244
3245                if (GPUVMEnable && !DCCEnable)
3246                        min_row_time = dpte_row_height * LineTime / VRatio;
3247                else if (!GPUVMEnable && DCCEnable)
3248                        min_row_time = meta_row_height * LineTime / VRatio;
3249                else
3250                        min_row_time = dml_min(dpte_row_height, meta_row_height) * LineTime
3251                                        / VRatio;
3252
3253                if (*DestinationLinesToRequestVMInImmediateFlip >= 8
3254                                || *DestinationLinesToRequestRowInImmediateFlip >= 16
3255                                || TimeForFetchingMetaPTEImmediateFlip
3256                                                + 2 * TimeForFetchingRowInVBlankImmediateFlip
3257                                                > min_row_time)
3258                        *ImmediateFlipSupportedForPipe = false;
3259                else
3260                        *ImmediateFlipSupportedForPipe = true;
3261        }
3262}
3263
3264static unsigned int TruncToValidBPP(
3265                double DecimalBPP,
3266                double DesiredBPP,
3267                bool DSCEnabled,
3268                enum output_encoder_class Output,
3269                enum output_format_class Format,
3270                unsigned int DSCInputBitPerComponent)
3271{
3272        if (Output == dm_hdmi) {
3273                if (Format == dm_420) {
3274                        if (DecimalBPP >= 18 && (DesiredBPP == 0 || DesiredBPP == 18))
3275                                return 18;
3276                        else if (DecimalBPP >= 15 && (DesiredBPP == 0 || DesiredBPP == 15))
3277                                return 15;
3278                        else if (DecimalBPP >= 12 && (DesiredBPP == 0 || DesiredBPP == 12))
3279                                return 12;
3280                        else
3281                                return BPP_INVALID;
3282                } else if (Format == dm_444) {
3283                        if (DecimalBPP >= 36 && (DesiredBPP == 0 || DesiredBPP == 36))
3284                                return 36;
3285                        else if (DecimalBPP >= 30 && (DesiredBPP == 0 || DesiredBPP == 30))
3286                                return 30;
3287                        else if (DecimalBPP >= 24 && (DesiredBPP == 0 || DesiredBPP == 24))
3288                                return 24;
3289                        else if (DecimalBPP >= 18 && (DesiredBPP == 0 || DesiredBPP == 18))
3290                                return 18;
3291                        else
3292                                return BPP_INVALID;
3293                } else {
3294                        if (DecimalBPP / 1.5 >= 24 && (DesiredBPP == 0 || DesiredBPP == 24))
3295                                return 24;
3296                        else if (DecimalBPP / 1.5 >= 20 && (DesiredBPP == 0 || DesiredBPP == 20))
3297                                return 20;
3298                        else if (DecimalBPP / 1.5 >= 16 && (DesiredBPP == 0 || DesiredBPP == 16))
3299                                return 16;
3300                        else
3301                                return BPP_INVALID;
3302                }
3303        } else {
3304                if (DSCEnabled) {
3305                        if (Format == dm_420) {
3306                                if (DesiredBPP == 0) {
3307                                        if (DecimalBPP < 6)
3308                                                return BPP_INVALID;
3309                                        else if (DecimalBPP >= 1.5 * DSCInputBitPerComponent - 1.0 / 16.0)
3310                                                return 1.5 * DSCInputBitPerComponent - 1.0 / 16.0;
3311                                        else
3312                                                return dml_floor(16 * DecimalBPP, 1) / 16.0;
3313                                } else {
3314                                        if (DecimalBPP < 6
3315                                                        || DesiredBPP < 6
3316                                                        || DesiredBPP > 1.5 * DSCInputBitPerComponent - 1.0 / 16.0
3317                                                        || DecimalBPP < DesiredBPP) {
3318                                                return BPP_INVALID;
3319                                        } else {
3320                                                return DesiredBPP;
3321                                        }
3322                                }
3323                        } else if (Format == dm_n422) {
3324                                if (DesiredBPP == 0) {
3325                                        if (DecimalBPP < 7)
3326                                                return BPP_INVALID;
3327                                        else if (DecimalBPP >= 2 * DSCInputBitPerComponent - 1.0 / 16.0)
3328                                                return 2 * DSCInputBitPerComponent - 1.0 / 16.0;
3329                                        else
3330                                                return dml_floor(16 * DecimalBPP, 1) / 16.0;
3331                                } else {
3332                                        if (DecimalBPP < 7
3333                                                        || DesiredBPP < 7
3334                                                        || DesiredBPP > 2 * DSCInputBitPerComponent - 1.0 / 16.0
3335                                                        || DecimalBPP < DesiredBPP) {
3336                                                return BPP_INVALID;
3337                                        } else {
3338                                                return DesiredBPP;
3339                                        }
3340                                }
3341                        } else {
3342                                if (DesiredBPP == 0) {
3343                                        if (DecimalBPP < 8)
3344                                                return BPP_INVALID;
3345                                        else if (DecimalBPP >= 3 * DSCInputBitPerComponent - 1.0 / 16.0)
3346                                                return 3 * DSCInputBitPerComponent - 1.0 / 16.0;
3347                                        else
3348                                                return dml_floor(16 * DecimalBPP, 1) / 16.0;
3349                                } else {
3350                                        if (DecimalBPP < 8
3351                                                        || DesiredBPP < 8
3352                                                        || DesiredBPP > 3 * DSCInputBitPerComponent - 1.0 / 16.0
3353                                                        || DecimalBPP < DesiredBPP) {
3354                                                return BPP_INVALID;
3355                                        } else {
3356                                                return DesiredBPP;
3357                                        }
3358                                }
3359                        }
3360                } else if (Format == dm_420) {
3361                        if (DecimalBPP >= 18 && (DesiredBPP == 0 || DesiredBPP == 18))
3362                                return 18;
3363                        else if (DecimalBPP >= 15 && (DesiredBPP == 0 || DesiredBPP == 15))
3364                                return 15;
3365                        else if (DecimalBPP >= 12 && (DesiredBPP == 0 || DesiredBPP == 12))
3366                                return 12;
3367                        else
3368                                return BPP_INVALID;
3369                } else if (Format == dm_s422 || Format == dm_n422) {
3370                        if (DecimalBPP >= 24 && (DesiredBPP == 0 || DesiredBPP == 24))
3371                                return 24;
3372                        else if (DecimalBPP >= 20 && (DesiredBPP == 0 || DesiredBPP == 20))
3373                                return 20;
3374                        else if (DecimalBPP >= 16 && (DesiredBPP == 0 || DesiredBPP == 16))
3375                                return 16;
3376                        else
3377                                return BPP_INVALID;
3378                } else {
3379                        if (DecimalBPP >= 36 && (DesiredBPP == 0 || DesiredBPP == 36))
3380                                return 36;
3381                        else if (DecimalBPP >= 30 && (DesiredBPP == 0 || DesiredBPP == 30))
3382                                return 30;
3383                        else if (DecimalBPP >= 24 && (DesiredBPP == 0 || DesiredBPP == 24))
3384                                return 24;
3385                        else if (DecimalBPP >= 18 && (DesiredBPP == 0 || DesiredBPP == 18))
3386                                return 18;
3387                        else
3388                                return BPP_INVALID;
3389                }
3390        }
3391}
3392
3393void dml20v2_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_lib)
3394{
3395        struct vba_vars_st *locals = &mode_lib->vba;
3396
3397        int i;
3398        unsigned int j, k, m;
3399
3400        /*MODE SUPPORT, VOLTAGE STATE AND SOC CONFIGURATION*/
3401
3402        /*Scale Ratio, taps Support Check*/
3403
3404        mode_lib->vba.ScaleRatioAndTapsSupport = true;
3405        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3406                if (mode_lib->vba.ScalerEnabled[k] == false
3407                                && ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64
3408                                                && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
3409                                                && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
3410                                                && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
3411                                                && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8)
3412                                                || mode_lib->vba.HRatio[k] != 1.0
3413                                                || mode_lib->vba.htaps[k] != 1.0
3414                                                || mode_lib->vba.VRatio[k] != 1.0
3415                                                || mode_lib->vba.vtaps[k] != 1.0)) {
3416                        mode_lib->vba.ScaleRatioAndTapsSupport = false;
3417                } else if (mode_lib->vba.vtaps[k] < 1.0 || mode_lib->vba.vtaps[k] > 8.0
3418                                || mode_lib->vba.htaps[k] < 1.0 || mode_lib->vba.htaps[k] > 8.0
3419                                || (mode_lib->vba.htaps[k] > 1.0
3420                                                && (mode_lib->vba.htaps[k] % 2) == 1)
3421                                || mode_lib->vba.HRatio[k] > mode_lib->vba.MaxHSCLRatio
3422                                || mode_lib->vba.VRatio[k] > mode_lib->vba.MaxVSCLRatio
3423                                || mode_lib->vba.HRatio[k] > mode_lib->vba.htaps[k]
3424                                || mode_lib->vba.VRatio[k] > mode_lib->vba.vtaps[k]
3425                                || (mode_lib->vba.SourcePixelFormat[k] != dm_444_64
3426                                                && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
3427                                                && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
3428                                                && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
3429                                                && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8
3430                                                && (mode_lib->vba.HRatio[k] / 2.0
3431                                                                > mode_lib->vba.HTAPsChroma[k]
3432                                                                || mode_lib->vba.VRatio[k] / 2.0
3433                                                                                > mode_lib->vba.VTAPsChroma[k]))) {
3434                        mode_lib->vba.ScaleRatioAndTapsSupport = false;
3435                }
3436        }
3437        /*Source Format, Pixel Format and Scan Support Check*/
3438
3439        mode_lib->vba.SourceFormatPixelAndScanSupport = true;
3440        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3441                if ((mode_lib->vba.SurfaceTiling[k] == dm_sw_linear
3442                                && mode_lib->vba.SourceScan[k] != dm_horz)
3443                                || ((mode_lib->vba.SurfaceTiling[k] == dm_sw_4kb_d
3444                                                || mode_lib->vba.SurfaceTiling[k] == dm_sw_4kb_d_x
3445                                                || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d
3446                                                || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d_t
3447                                                || mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_d_x
3448                                                || mode_lib->vba.SurfaceTiling[k] == dm_sw_var_d
3449                                                || mode_lib->vba.SurfaceTiling[k] == dm_sw_var_d_x)
3450                                                && mode_lib->vba.SourcePixelFormat[k] != dm_444_64)
3451                                || (mode_lib->vba.SurfaceTiling[k] == dm_sw_64kb_r_x
3452                                                && (mode_lib->vba.SourcePixelFormat[k] == dm_mono_8
3453                                                                || mode_lib->vba.SourcePixelFormat[k]
3454                                                                                == dm_420_8
3455                                                                || mode_lib->vba.SourcePixelFormat[k]
3456                                                                                == dm_420_10))
3457                                || (((mode_lib->vba.SurfaceTiling[k] == dm_sw_gfx7_2d_thin_gl
3458                                                || mode_lib->vba.SurfaceTiling[k]
3459                                                                == dm_sw_gfx7_2d_thin_l_vp)
3460                                                && !((mode_lib->vba.SourcePixelFormat[k]
3461                                                                == dm_444_64
3462                                                                || mode_lib->vba.SourcePixelFormat[k]
3463                                                                                == dm_444_32)
3464                                                                && mode_lib->vba.SourceScan[k]
3465                                                                                == dm_horz
3466                                                                && mode_lib->vba.SupportGFX7CompatibleTilingIn32bppAnd64bpp
3467                                                                                == true
3468                                                                && mode_lib->vba.DCCEnable[k]
3469                                                                                == false))
3470                                                || (mode_lib->vba.DCCEnable[k] == true
3471                                                                && (mode_lib->vba.SurfaceTiling[k]
3472                                                                                == dm_sw_linear
3473                                                                                || mode_lib->vba.SourcePixelFormat[k]
3474                                                                                                == dm_420_8
3475                                                                                || mode_lib->vba.SourcePixelFormat[k]
3476                                                                                                == dm_420_10)))) {
3477                        mode_lib->vba.SourceFormatPixelAndScanSupport = false;
3478                }
3479        }
3480        /*Bandwidth Support Check*/
3481
3482        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3483                if (mode_lib->vba.SourcePixelFormat[k] == dm_444_64) {
3484                        locals->BytePerPixelInDETY[k] = 8.0;
3485                        locals->BytePerPixelInDETC[k] = 0.0;
3486                } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_32) {
3487                        locals->BytePerPixelInDETY[k] = 4.0;
3488                        locals->BytePerPixelInDETC[k] = 0.0;
3489                } else if (mode_lib->vba.SourcePixelFormat[k] == dm_444_16
3490                                || mode_lib->vba.SourcePixelFormat[k] == dm_mono_16) {
3491                        locals->BytePerPixelInDETY[k] = 2.0;
3492                        locals->BytePerPixelInDETC[k] = 0.0;
3493                } else if (mode_lib->vba.SourcePixelFormat[k] == dm_mono_8) {
3494                        locals->BytePerPixelInDETY[k] = 1.0;
3495                        locals->BytePerPixelInDETC[k] = 0.0;
3496                } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8) {
3497                        locals->BytePerPixelInDETY[k] = 1.0;
3498                        locals->BytePerPixelInDETC[k] = 2.0;
3499                } else {
3500                        locals->BytePerPixelInDETY[k] = 4.0 / 3;
3501                        locals->BytePerPixelInDETC[k] = 8.0 / 3;
3502                }
3503                if (mode_lib->vba.SourceScan[k] == dm_horz) {
3504                        locals->SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportWidth[k];
3505                } else {
3506                        locals->SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportHeight[k];
3507                }
3508        }
3509        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3510                locals->ReadBandwidthLuma[k] = locals->SwathWidthYSingleDPP[k] * dml_ceil(locals->BytePerPixelInDETY[k], 1.0)
3511                                / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k];
3512                locals->ReadBandwidthChroma[k] = locals->SwathWidthYSingleDPP[k] / 2 * dml_ceil(locals->BytePerPixelInDETC[k], 2.0)
3513                                / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k] / 2.0;
3514                locals->ReadBandwidth[k] = locals->ReadBandwidthLuma[k] + locals->ReadBandwidthChroma[k];
3515        }
3516        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3517                if (mode_lib->vba.WritebackEnable[k] == true
3518                                && mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) {
3519                        locals->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k]
3520                                        * mode_lib->vba.WritebackDestinationHeight[k]
3521                                        / (mode_lib->vba.WritebackSourceHeight[k]
3522                                                        * mode_lib->vba.HTotal[k]
3523                                                        / mode_lib->vba.PixelClock[k]) * 4.0;
3524                } else if (mode_lib->vba.WritebackEnable[k] == true
3525                                && mode_lib->vba.WritebackPixelFormat[k] == dm_420_10) {
3526                        locals->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k]
3527                                        * mode_lib->vba.WritebackDestinationHeight[k]
3528                                        / (mode_lib->vba.WritebackSourceHeight[k]
3529                                                        * mode_lib->vba.HTotal[k]
3530                                                        / mode_lib->vba.PixelClock[k]) * 3.0;
3531                } else if (mode_lib->vba.WritebackEnable[k] == true) {
3532                        locals->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k]
3533                                        * mode_lib->vba.WritebackDestinationHeight[k]
3534                                        / (mode_lib->vba.WritebackSourceHeight[k]
3535                                                        * mode_lib->vba.HTotal[k]
3536                                                        / mode_lib->vba.PixelClock[k]) * 1.5;
3537                } else {
3538                        locals->WriteBandwidth[k] = 0.0;
3539                }
3540        }
3541        mode_lib->vba.DCCEnabledInAnyPlane = false;
3542        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3543                if (mode_lib->vba.DCCEnable[k] == true) {
3544                        mode_lib->vba.DCCEnabledInAnyPlane = true;
3545                }
3546        }
3547        mode_lib->vba.UrgentLatency = mode_lib->vba.UrgentLatencyPixelDataOnly;
3548        for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
3549                locals->FabricAndDRAMBandwidthPerState[i] = dml_min(
3550                                mode_lib->vba.DRAMSpeedPerState[i] * mode_lib->vba.NumberOfChannels
3551                                                * mode_lib->vba.DRAMChannelWidth,
3552                                mode_lib->vba.FabricClockPerState[i]
3553                                                * mode_lib->vba.FabricDatapathToDCNDataReturn) / 1000;
3554                locals->ReturnBWToDCNPerState = dml_min(locals->ReturnBusWidth * locals->DCFCLKPerState[i],
3555                                locals->FabricAndDRAMBandwidthPerState[i] * 1000)
3556                                * locals->PercentOfIdealDRAMFabricAndSDPPortBWReceivedAfterUrgLatencyPixelDataOnly / 100;
3557
3558                locals->ReturnBWPerState[i][0] = locals->ReturnBWToDCNPerState;
3559
3560                if (locals->DCCEnabledInAnyPlane == true && locals->ReturnBWToDCNPerState > locals->DCFCLKPerState[i] * locals->ReturnBusWidth / 4) {
3561                        locals->ReturnBWPerState[i][0] = dml_min(locals->ReturnBWPerState[i][0],
3562                                        locals->ReturnBWToDCNPerState * 4 * (1 - locals->UrgentLatency /
3563                                        ((locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024
3564                                        / (locals->ReturnBWToDCNPerState - locals->DCFCLKPerState[i]
3565                                        * locals->ReturnBusWidth / 4) + locals->UrgentLatency)));
3566                }
3567                locals->CriticalPoint = 2 * locals->ReturnBusWidth * locals->DCFCLKPerState[i] *
3568                                locals->UrgentLatency / (locals->ReturnBWToDCNPerState * locals->UrgentLatency
3569                                + (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024);
3570
3571                if (locals->DCCEnabledInAnyPlane && locals->CriticalPoint > 1 && locals->CriticalPoint < 4) {
3572                        locals->ReturnBWPerState[i][0] = dml_min(locals->ReturnBWPerState[i][0],
3573                                4 * locals->ReturnBWToDCNPerState *
3574                                (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024
3575                                * locals->ReturnBusWidth * locals->DCFCLKPerState[i] * locals->UrgentLatency /
3576                                dml_pow((locals->ReturnBWToDCNPerState * locals->UrgentLatency
3577                                + (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024), 2));
3578                }
3579
3580                locals->ReturnBWToDCNPerState = dml_min(locals->ReturnBusWidth *
3581                                locals->DCFCLKPerState[i], locals->FabricAndDRAMBandwidthPerState[i] * 1000);
3582
3583                if (locals->DCCEnabledInAnyPlane == true && locals->ReturnBWToDCNPerState > locals->DCFCLKPerState[i] * locals->ReturnBusWidth / 4) {
3584                        locals->ReturnBWPerState[i][0] = dml_min(locals->ReturnBWPerState[i][0],
3585                                        locals->ReturnBWToDCNPerState * 4 * (1 - locals->UrgentLatency /
3586                                        ((locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024
3587                                        / (locals->ReturnBWToDCNPerState - locals->DCFCLKPerState[i]
3588                                        * locals->ReturnBusWidth / 4) + locals->UrgentLatency)));
3589                }
3590                locals->CriticalPoint = 2 * locals->ReturnBusWidth * locals->DCFCLKPerState[i] *
3591                                locals->UrgentLatency / (locals->ReturnBWToDCNPerState * locals->UrgentLatency
3592                                + (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024);
3593
3594                if (locals->DCCEnabledInAnyPlane && locals->CriticalPoint > 1 && locals->CriticalPoint < 4) {
3595                        locals->ReturnBWPerState[i][0] = dml_min(locals->ReturnBWPerState[i][0],
3596                                4 * locals->ReturnBWToDCNPerState *
3597                                (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024
3598                                * locals->ReturnBusWidth * locals->DCFCLKPerState[i] * locals->UrgentLatency /
3599                                dml_pow((locals->ReturnBWToDCNPerState * locals->UrgentLatency
3600                                + (locals->ROBBufferSizeInKByte - locals->PixelChunkSizeInKByte) * 1024), 2));
3601                }
3602        }
3603        /*Writeback Latency support check*/
3604
3605        mode_lib->vba.WritebackLatencySupport = true;
3606        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3607                if (mode_lib->vba.WritebackEnable[k] == true) {
3608                        if (mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) {
3609                                if (locals->WriteBandwidth[k]
3610                                                > (mode_lib->vba.WritebackInterfaceLumaBufferSize
3611                                                                + mode_lib->vba.WritebackInterfaceChromaBufferSize)
3612                                                                / mode_lib->vba.WritebackLatency) {
3613                                        mode_lib->vba.WritebackLatencySupport = false;
3614                                }
3615                        } else {
3616                                if (locals->WriteBandwidth[k]
3617                                                > 1.5
3618                                                                * dml_min(
3619                                                                                mode_lib->vba.WritebackInterfaceLumaBufferSize,
3620                                                                                2.0
3621                                                                                                * mode_lib->vba.WritebackInterfaceChromaBufferSize)
3622                                                                / mode_lib->vba.WritebackLatency) {
3623                                        mode_lib->vba.WritebackLatencySupport = false;
3624                                }
3625                        }
3626                }
3627        }
3628        /*Re-ordering Buffer Support Check*/
3629
3630        for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
3631                locals->UrgentRoundTripAndOutOfOrderLatencyPerState[i] =
3632                                (mode_lib->vba.RoundTripPingLatencyCycles + 32.0) / mode_lib->vba.DCFCLKPerState[i]
3633                                + locals->UrgentOutOfOrderReturnPerChannel * mode_lib->vba.NumberOfChannels / locals->ReturnBWPerState[i][0];
3634                if ((mode_lib->vba.ROBBufferSizeInKByte - mode_lib->vba.PixelChunkSizeInKByte) * 1024.0 / locals->ReturnBWPerState[i][0]
3635                                > locals->UrgentRoundTripAndOutOfOrderLatencyPerState[i]) {
3636                        locals->ROBSupport[i][0] = true;
3637                } else {
3638                        locals->ROBSupport[i][0] = false;
3639                }
3640        }
3641        /*Writeback Mode Support Check*/
3642
3643        mode_lib->vba.TotalNumberOfActiveWriteback = 0;
3644        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3645                if (mode_lib->vba.WritebackEnable[k] == true) {
3646                        if (mode_lib->vba.ActiveWritebacksPerPlane[k] == 0)
3647                                mode_lib->vba.ActiveWritebacksPerPlane[k] = 1;
3648                        mode_lib->vba.TotalNumberOfActiveWriteback =
3649                                        mode_lib->vba.TotalNumberOfActiveWriteback
3650                                                        + mode_lib->vba.ActiveWritebacksPerPlane[k];
3651                }
3652        }
3653        mode_lib->vba.WritebackModeSupport = true;
3654        if (mode_lib->vba.TotalNumberOfActiveWriteback > mode_lib->vba.MaxNumWriteback) {
3655                mode_lib->vba.WritebackModeSupport = false;
3656        }
3657        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3658                if (mode_lib->vba.WritebackEnable[k] == true
3659                                && mode_lib->vba.Writeback10bpc420Supported != true
3660                                && mode_lib->vba.WritebackPixelFormat[k] == dm_420_10) {
3661                        mode_lib->vba.WritebackModeSupport = false;
3662                }
3663        }
3664        /*Writeback Scale Ratio and Taps Support Check*/
3665
3666        mode_lib->vba.WritebackScaleRatioAndTapsSupport = true;
3667        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3668                if (mode_lib->vba.WritebackEnable[k] == true) {
3669                        if (mode_lib->vba.WritebackLumaAndChromaScalingSupported == false
3670                                        && (mode_lib->vba.WritebackHRatio[k] != 1.0
3671                                                        || mode_lib->vba.WritebackVRatio[k] != 1.0)) {
3672                                mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
3673                        }
3674                        if (mode_lib->vba.WritebackHRatio[k] > mode_lib->vba.WritebackMaxHSCLRatio
3675                                        || mode_lib->vba.WritebackVRatio[k]
3676                                                        > mode_lib->vba.WritebackMaxVSCLRatio
3677                                        || mode_lib->vba.WritebackHRatio[k]
3678                                                        < mode_lib->vba.WritebackMinHSCLRatio
3679                                        || mode_lib->vba.WritebackVRatio[k]
3680                                                        < mode_lib->vba.WritebackMinVSCLRatio
3681                                        || mode_lib->vba.WritebackLumaHTaps[k]
3682                                                        > mode_lib->vba.WritebackMaxHSCLTaps
3683                                        || mode_lib->vba.WritebackLumaVTaps[k]
3684                                                        > mode_lib->vba.WritebackMaxVSCLTaps
3685                                        || mode_lib->vba.WritebackHRatio[k]
3686                                                        > mode_lib->vba.WritebackLumaHTaps[k]
3687                                        || mode_lib->vba.WritebackVRatio[k]
3688                                                        > mode_lib->vba.WritebackLumaVTaps[k]
3689                                        || (mode_lib->vba.WritebackLumaHTaps[k] > 2.0
3690                                                        && ((mode_lib->vba.WritebackLumaHTaps[k] % 2)
3691                                                                        == 1))
3692                                        || (mode_lib->vba.WritebackPixelFormat[k] != dm_444_32
3693                                                        && (mode_lib->vba.WritebackChromaHTaps[k]
3694                                                                        > mode_lib->vba.WritebackMaxHSCLTaps
3695                                                                        || mode_lib->vba.WritebackChromaVTaps[k]
3696                                                                                        > mode_lib->vba.WritebackMaxVSCLTaps
3697                                                                        || 2.0
3698                                                                                        * mode_lib->vba.WritebackHRatio[k]
3699                                                                                        > mode_lib->vba.WritebackChromaHTaps[k]
3700                                                                        || 2.0
3701                                                                                        * mode_lib->vba.WritebackVRatio[k]
3702                                                                                        > mode_lib->vba.WritebackChromaVTaps[k]
3703                                                                        || (mode_lib->vba.WritebackChromaHTaps[k] > 2.0
3704                                                                                && ((mode_lib->vba.WritebackChromaHTaps[k] % 2) == 1))))) {
3705                                mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
3706                        }
3707                        if (mode_lib->vba.WritebackVRatio[k] < 1.0) {
3708                                mode_lib->vba.WritebackLumaVExtra =
3709                                                dml_max(1.0 - 2.0 / dml_ceil(1.0 / mode_lib->vba.WritebackVRatio[k], 1.0), 0.0);
3710                        } else {
3711                                mode_lib->vba.WritebackLumaVExtra = -1;
3712                        }
3713                        if ((mode_lib->vba.WritebackPixelFormat[k] == dm_444_32
3714                                        && mode_lib->vba.WritebackLumaVTaps[k]
3715                                                        > (mode_lib->vba.WritebackLineBufferLumaBufferSize
3716                                                                        + mode_lib->vba.WritebackLineBufferChromaBufferSize)
3717                                                                        / 3.0
3718                                                                        / mode_lib->vba.WritebackDestinationWidth[k]
3719                                                                        - mode_lib->vba.WritebackLumaVExtra)
3720                                        || (mode_lib->vba.WritebackPixelFormat[k] == dm_420_8
3721                                                        && mode_lib->vba.WritebackLumaVTaps[k]
3722                                                                        > mode_lib->vba.WritebackLineBufferLumaBufferSize
3723                                                                                        * 8.0 / 10.0 / mode_lib->vba.WritebackDestinationWidth[k]
3724                                                                                        - mode_lib->vba.WritebackLumaVExtra)
3725                                        || (mode_lib->vba.WritebackPixelFormat[k] == dm_420_10
3726                                                        && mode_lib->vba.WritebackLumaVTaps[k]
3727                                                                        > mode_lib->vba.WritebackLineBufferLumaBufferSize
3728                                                                                        * 8.0 / 10.0
3729                                                                                        / mode_lib->vba.WritebackDestinationWidth[k]
3730                                                                                        - mode_lib->vba.WritebackLumaVExtra)) {
3731                                mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
3732                        }
3733                        if (2.0 * mode_lib->vba.WritebackVRatio[k] < 1) {
3734                                mode_lib->vba.WritebackChromaVExtra = 0.0;
3735                        } else {
3736                                mode_lib->vba.WritebackChromaVExtra = -1;
3737                        }
3738                        if ((mode_lib->vba.WritebackPixelFormat[k] == dm_420_8
3739                                        && mode_lib->vba.WritebackChromaVTaps[k]
3740                                                        > mode_lib->vba.WritebackLineBufferChromaBufferSize
3741                                                                        * 8.0 / 10.0 / mode_lib->vba.WritebackDestinationWidth[k]
3742                                                                        - mode_lib->vba.WritebackChromaVExtra)
3743                                        || (mode_lib->vba.WritebackPixelFormat[k] == dm_420_10
3744                                                        && mode_lib->vba.WritebackChromaVTaps[k]
3745                                                                        > mode_lib->vba.WritebackLineBufferChromaBufferSize
3746                                                                                        * 8.0 / 10.0
3747                                                                                        / mode_lib->vba.WritebackDestinationWidth[k]
3748                                                                                        - mode_lib->vba.WritebackChromaVExtra)) {
3749                                mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
3750                        }
3751                }
3752        }
3753        /*Maximum DISPCLK/DPPCLK Support check*/
3754
3755        mode_lib->vba.WritebackRequiredDISPCLK = 0.0;
3756        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3757                if (mode_lib->vba.WritebackEnable[k] == true) {
3758                        mode_lib->vba.WritebackRequiredDISPCLK =
3759                                        dml_max(
3760                                                        mode_lib->vba.WritebackRequiredDISPCLK,
3761                                                        CalculateWriteBackDISPCLK(
3762                                                                        mode_lib->vba.WritebackPixelFormat[k],
3763                                                                        mode_lib->vba.PixelClock[k],
3764                                                                        mode_lib->vba.WritebackHRatio[k],
3765                                                                        mode_lib->vba.WritebackVRatio[k],
3766                                                                        mode_lib->vba.WritebackLumaHTaps[k],
3767                                                                        mode_lib->vba.WritebackLumaVTaps[k],
3768                                                                        mode_lib->vba.WritebackChromaHTaps[k],
3769                                                                        mode_lib->vba.WritebackChromaVTaps[k],
3770                                                                        mode_lib->vba.WritebackDestinationWidth[k],
3771                                                                        mode_lib->vba.HTotal[k],
3772                                                                        mode_lib->vba.WritebackChromaLineBufferWidth));
3773                }
3774        }
3775        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3776                if (mode_lib->vba.HRatio[k] > 1.0) {
3777                        locals->PSCL_FACTOR[k] = dml_min(
3778                                        mode_lib->vba.MaxDCHUBToPSCLThroughput,
3779                                        mode_lib->vba.MaxPSCLToLBThroughput
3780                                                        * mode_lib->vba.HRatio[k]
3781                                                        / dml_ceil(
3782                                                                        mode_lib->vba.htaps[k]
3783                                                                                        / 6.0,
3784                                                                        1.0));
3785                } else {
3786                        locals->PSCL_FACTOR[k] = dml_min(
3787                                        mode_lib->vba.MaxDCHUBToPSCLThroughput,
3788                                        mode_lib->vba.MaxPSCLToLBThroughput);
3789                }
3790                if (locals->BytePerPixelInDETC[k] == 0.0) {
3791                        locals->PSCL_FACTOR_CHROMA[k] = 0.0;
3792                        locals->MinDPPCLKUsingSingleDPP[k] =
3793                                        mode_lib->vba.PixelClock[k]
3794                                                        * dml_max3(
3795                                                                        mode_lib->vba.vtaps[k] / 6.0
3796                                                                                        * dml_min(
3797                                                                                                        1.0,
3798                                                                                                        mode_lib->vba.HRatio[k]),
3799                                                                        mode_lib->vba.HRatio[k]
3800                                                                                        * mode_lib->vba.VRatio[k]
3801                                                                                        / locals->PSCL_FACTOR[k],
3802                                                                        1.0);
3803                        if ((mode_lib->vba.htaps[k] > 6.0 || mode_lib->vba.vtaps[k] > 6.0)
3804                                        && locals->MinDPPCLKUsingSingleDPP[k]
3805                                                        < 2.0 * mode_lib->vba.PixelClock[k]) {
3806                                locals->MinDPPCLKUsingSingleDPP[k] = 2.0
3807                                                * mode_lib->vba.PixelClock[k];
3808                        }
3809                } else {
3810                        if (mode_lib->vba.HRatio[k] / 2.0 > 1.0) {
3811                                locals->PSCL_FACTOR_CHROMA[k] =
3812                                                dml_min(
3813                                                                mode_lib->vba.MaxDCHUBToPSCLThroughput,
3814                                                                mode_lib->vba.MaxPSCLToLBThroughput
3815                                                                                * mode_lib->vba.HRatio[k]
3816                                                                                / 2.0
3817                                                                                / dml_ceil(
3818                                                                                                mode_lib->vba.HTAPsChroma[k]
3819                                                                                                                / 6.0,
3820                                                                                                1.0));
3821                        } else {
3822                                locals->PSCL_FACTOR_CHROMA[k] = dml_min(
3823                                                mode_lib->vba.MaxDCHUBToPSCLThroughput,
3824                                                mode_lib->vba.MaxPSCLToLBThroughput);
3825                        }
3826                        locals->MinDPPCLKUsingSingleDPP[k] =
3827                                        mode_lib->vba.PixelClock[k]
3828                                                        * dml_max5(
3829                                                                        mode_lib->vba.vtaps[k] / 6.0
3830                                                                                        * dml_min(
3831                                                                                                        1.0,
3832                                                                                                        mode_lib->vba.HRatio[k]),
3833                                                                        mode_lib->vba.HRatio[k]
3834                                                                                        * mode_lib->vba.VRatio[k]
3835                                                                                        / locals->PSCL_FACTOR[k],
3836                                                                        mode_lib->vba.VTAPsChroma[k]
3837                                                                                        / 6.0
3838                                                                                        * dml_min(
3839                                                                                                        1.0,
3840                                                                                                        mode_lib->vba.HRatio[k]
3841                                                                                                                        / 2.0),
3842                                                                        mode_lib->vba.HRatio[k]
3843                                                                                        * mode_lib->vba.VRatio[k]
3844                                                                                        / 4.0
3845                                                                                        / locals->PSCL_FACTOR_CHROMA[k],
3846                                                                        1.0);
3847                        if ((mode_lib->vba.htaps[k] > 6.0 || mode_lib->vba.vtaps[k] > 6.0
3848                                        || mode_lib->vba.HTAPsChroma[k] > 6.0
3849                                        || mode_lib->vba.VTAPsChroma[k] > 6.0)
3850                                        && locals->MinDPPCLKUsingSingleDPP[k]
3851                                                        < 2.0 * mode_lib->vba.PixelClock[k]) {
3852                                locals->MinDPPCLKUsingSingleDPP[k] = 2.0
3853                                                * mode_lib->vba.PixelClock[k];
3854                        }
3855                }
3856        }
3857        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3858                Calculate256BBlockSizes(
3859                                mode_lib->vba.SourcePixelFormat[k],
3860                                mode_lib->vba.SurfaceTiling[k],
3861                                dml_ceil(locals->BytePerPixelInDETY[k], 1.0),
3862                                dml_ceil(locals->BytePerPixelInDETC[k], 2.0),
3863                                &locals->Read256BlockHeightY[k],
3864                                &locals->Read256BlockHeightC[k],
3865                                &locals->Read256BlockWidthY[k],
3866                                &locals->Read256BlockWidthC[k]);
3867                if (mode_lib->vba.SourceScan[k] == dm_horz) {
3868                        locals->MaxSwathHeightY[k] = locals->Read256BlockHeightY[k];
3869                        locals->MaxSwathHeightC[k] = locals->Read256BlockHeightC[k];
3870                } else {
3871                        locals->MaxSwathHeightY[k] = locals->Read256BlockWidthY[k];
3872                        locals->MaxSwathHeightC[k] = locals->Read256BlockWidthC[k];
3873                }
3874                if ((mode_lib->vba.SourcePixelFormat[k] == dm_444_64
3875                                || mode_lib->vba.SourcePixelFormat[k] == dm_444_32
3876                                || mode_lib->vba.SourcePixelFormat[k] == dm_444_16
3877                                || mode_lib->vba.SourcePixelFormat[k] == dm_mono_16
3878                                || mode_lib->vba.SourcePixelFormat[k] == dm_mono_8)) {
3879                        if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear
3880                                        || (mode_lib->vba.SourcePixelFormat[k] == dm_444_64
3881                                                        && (mode_lib->vba.SurfaceTiling[k]
3882                                                                        == dm_sw_4kb_s
3883                                                                        || mode_lib->vba.SurfaceTiling[k]
3884                                                                                        == dm_sw_4kb_s_x
3885                                                                        || mode_lib->vba.SurfaceTiling[k]
3886                                                                                        == dm_sw_64kb_s
3887                                                                        || mode_lib->vba.SurfaceTiling[k]
3888                                                                                        == dm_sw_64kb_s_t
3889                                                                        || mode_lib->vba.SurfaceTiling[k]
3890                                                                                        == dm_sw_64kb_s_x
3891                                                                        || mode_lib->vba.SurfaceTiling[k]
3892                                                                                        == dm_sw_var_s
3893                                                                        || mode_lib->vba.SurfaceTiling[k]
3894                                                                                        == dm_sw_var_s_x)
3895                                                        && mode_lib->vba.SourceScan[k] == dm_horz)) {
3896                                locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k];
3897                        } else {
3898                                locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k]
3899                                                / 2.0;
3900                        }
3901                        locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k];
3902                } else {
3903                        if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
3904                                locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k];
3905                                locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k];
3906                        } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8
3907                                        && mode_lib->vba.SourceScan[k] == dm_horz) {
3908                                locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k]
3909                                                / 2.0;
3910                                locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k];
3911                        } else if (mode_lib->vba.SourcePixelFormat[k] == dm_420_10
3912                                        && mode_lib->vba.SourceScan[k] == dm_horz) {
3913                                locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k]
3914                                                / 2.0;
3915                                locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k];
3916                        } else {
3917                                locals->MinSwathHeightY[k] = locals->MaxSwathHeightY[k];
3918                                locals->MinSwathHeightC[k] = locals->MaxSwathHeightC[k];
3919                        }
3920                }
3921                if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
3922                        mode_lib->vba.MaximumSwathWidthSupport = 8192.0;
3923                } else {
3924                        mode_lib->vba.MaximumSwathWidthSupport = 5120.0;
3925                }
3926                mode_lib->vba.MaximumSwathWidthInDETBuffer =
3927                                dml_min(
3928                                                mode_lib->vba.MaximumSwathWidthSupport,
3929                                                mode_lib->vba.DETBufferSizeInKByte[0] * 1024.0 / 2.0
3930                                                                / (locals->BytePerPixelInDETY[k]
3931                                                                                * locals->MinSwathHeightY[k]
3932                                                                                + locals->BytePerPixelInDETC[k]
3933                                                                                                / 2.0
3934                                                                                                * locals->MinSwathHeightC[k]));
3935                if (locals->BytePerPixelInDETC[k] == 0.0) {
3936                        mode_lib->vba.MaximumSwathWidthInLineBuffer =
3937                                        mode_lib->vba.LineBufferSize
3938                                                        * dml_max(mode_lib->vba.HRatio[k], 1.0)
3939                                                        / mode_lib->vba.LBBitPerPixel[k]
3940                                                        / (mode_lib->vba.vtaps[k]
3941                                                                        + dml_max(
3942                                                                                        dml_ceil(
3943                                                                                                        mode_lib->vba.VRatio[k],
3944                                                                                                        1.0)
3945                                                                                                        - 2,
3946                                                                                        0.0));
3947                } else {
3948                        mode_lib->vba.MaximumSwathWidthInLineBuffer =
3949                                        dml_min(
3950                                                        mode_lib->vba.LineBufferSize
3951                                                                        * dml_max(
3952                                                                                        mode_lib->vba.HRatio[k],
3953                                                                                        1.0)
3954                                                                        / mode_lib->vba.LBBitPerPixel[k]
3955                                                                        / (mode_lib->vba.vtaps[k]
3956                                                                                        + dml_max(
3957                                                                                                        dml_ceil(
3958                                                                                                                        mode_lib->vba.VRatio[k],
3959                                                                                                                        1.0)
3960                                                                                                                        - 2,
3961                                                                                                        0.0)),
3962                                                        2.0 * mode_lib->vba.LineBufferSize
3963                                                                        * dml_max(
3964                                                                                        mode_lib->vba.HRatio[k]
3965                                                                                                        / 2.0,
3966                                                                                        1.0)
3967                                                                        / mode_lib->vba.LBBitPerPixel[k]
3968                                                                        / (mode_lib->vba.VTAPsChroma[k]
3969                                                                                        + dml_max(
3970                                                                                                        dml_ceil(
3971                                                                                                                        mode_lib->vba.VRatio[k]
3972                                                                                                                                        / 2.0,
3973                                                                                                                        1.0)
3974                                                                                                                        - 2,
3975                                                                                                        0.0)));
3976                }
3977                locals->MaximumSwathWidth[k] = dml_min(
3978                                mode_lib->vba.MaximumSwathWidthInDETBuffer,
3979                                mode_lib->vba.MaximumSwathWidthInLineBuffer);
3980        }
3981        for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
3982                double MaxMaxDispclkRoundedDown = RoundToDFSGranularityDown(
3983                        mode_lib->vba.MaxDispclk[mode_lib->vba.soc.num_states],
3984                        mode_lib->vba.DISPCLKDPPCLKVCOSpeed);
3985
3986                for (j = 0; j < 2; j++) {
3987                        mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity = RoundToDFSGranularityDown(
3988                                mode_lib->vba.MaxDispclk[i],
3989                                mode_lib->vba.DISPCLKDPPCLKVCOSpeed);
3990                        mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity = RoundToDFSGranularityDown(
3991                                mode_lib->vba.MaxDppclk[i],
3992                                mode_lib->vba.DISPCLKDPPCLKVCOSpeed);
3993                        locals->RequiredDISPCLK[i][j] = 0.0;
3994                        locals->DISPCLK_DPPCLK_Support[i][j] = true;
3995                        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
3996                                mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine =
3997                                                mode_lib->vba.PixelClock[k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
3998                                                                * (1.0 + mode_lib->vba.DISPCLKRampingMargin / 100.0);
3999                                if (mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine >= mode_lib->vba.MaxDispclk[i]
4000                                                && i == mode_lib->vba.soc.num_states)

4001                                        mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine = mode_lib->vba.PixelClock[k]
4002                                                        * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
4003
4004                                mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine = mode_lib->vba.PixelClock[k] / 2
4005                                        * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * (1 + mode_lib->vba.DISPCLKRampingMargin / 100.0);
4006                                if (mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine >= mode_lib->vba.MaxDispclk[i]
4007                                                && i == mode_lib->vba.soc.num_states)
4008                                        mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine = mode_lib->vba.PixelClock[k] / 2
4009                                                        * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
4010
4011                                locals->ODMCombineEnablePerState[i][k] = false;
4012                                mode_lib->vba.PlaneRequiredDISPCLK = mode_lib->vba.PlaneRequiredDISPCLKWithoutODMCombine;
4013                                if (mode_lib->vba.ODMCapability) {
4014                                        if (locals->PlaneRequiredDISPCLKWithoutODMCombine > MaxMaxDispclkRoundedDown) {
4015                                                locals->ODMCombineEnablePerState[i][k] = true;
4016                                                mode_lib->vba.PlaneRequiredDISPCLK = mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine;
4017                                        } else if (locals->DSCEnabled[k] && (locals->HActive[k] > DCN20_MAX_DSC_IMAGE_WIDTH)) {
4018                                                locals->ODMCombineEnablePerState[i][k] = true;
4019                                                mode_lib->vba.PlaneRequiredDISPCLK = mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine;
4020                                        } else if (locals->HActive[k] > DCN20_MAX_420_IMAGE_WIDTH && locals->OutputFormat[k] == dm_420) {
4021                                                locals->ODMCombineEnablePerState[i][k] = true;
4022                                                mode_lib->vba.PlaneRequiredDISPCLK = mode_lib->vba.PlaneRequiredDISPCLKWithODMCombine;
4023                                        }
4024                                }
4025
4026                                if (locals->MinDPPCLKUsingSingleDPP[k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) <= mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity
4027                                                && locals->SwathWidthYSingleDPP[k] <= locals->MaximumSwathWidth[k]
4028                                                && locals->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_disabled) {
4029                                        locals->NoOfDPP[i][j][k] = 1;
4030                                        locals->RequiredDPPCLK[i][j][k] =
4031                                                locals->MinDPPCLKUsingSingleDPP[k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
4032                                } else {
4033                                        locals->NoOfDPP[i][j][k] = 2;
4034                                        locals->RequiredDPPCLK[i][j][k] =
4035                                                locals->MinDPPCLKUsingSingleDPP[k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 2.0;
4036                                }
4037                                locals->RequiredDISPCLK[i][j] = dml_max(
4038                                                locals->RequiredDISPCLK[i][j],
4039                                                mode_lib->vba.PlaneRequiredDISPCLK);
4040                                if ((locals->MinDPPCLKUsingSingleDPP[k] / locals->NoOfDPP[i][j][k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
4041                                                > mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity)
4042                                                || (mode_lib->vba.PlaneRequiredDISPCLK > mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity)) {
4043                                        locals->DISPCLK_DPPCLK_Support[i][j] = false;
4044                                }
4045                        }
4046                        locals->TotalNumberOfActiveDPP[i][j] = 0.0;
4047                        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++)
4048                                locals->TotalNumberOfActiveDPP[i][j] = locals->TotalNumberOfActiveDPP[i][j] + locals->NoOfDPP[i][j][k];
4049                        if (j == 1) {
4050                                while (locals->TotalNumberOfActiveDPP[i][j] < mode_lib->vba.MaxNumDPP
4051                                                && locals->TotalNumberOfActiveDPP[i][j] < 2 * mode_lib->vba.NumberOfActivePlanes) {
4052                                        double BWOfNonSplitPlaneOfMaximumBandwidth;
4053                                        unsigned int NumberOfNonSplitPlaneOfMaximumBandwidth;
4054
4055                                        BWOfNonSplitPlaneOfMaximumBandwidth = 0;
4056                                        NumberOfNonSplitPlaneOfMaximumBandwidth = 0;
4057                                        for (k = 0; k < mode_lib->vba.NumberOfActivePlanes; ++k) {
4058                                                if (locals->ReadBandwidth[k] > BWOfNonSplitPlaneOfMaximumBandwidth && locals->NoOfDPP[i][j][k] == 1) {
4059                                                        BWOfNonSplitPlaneOfMaximumBandwidth = locals->ReadBandwidth[k];
4060                                                        NumberOfNonSplitPlaneOfMaximumBandwidth = k;
4061                                                }
4062                                        }
4063                                        locals->NoOfDPP[i][j][NumberOfNonSplitPlaneOfMaximumBandwidth] = 2;
4064                                        locals->RequiredDPPCLK[i][j][NumberOfNonSplitPlaneOfMaximumBandwidth] =
4065                                                locals->MinDPPCLKUsingSingleDPP[NumberOfNonSplitPlaneOfMaximumBandwidth]
4066                                                        * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100) / 2;
4067                                        locals->TotalNumberOfActiveDPP[i][j] = locals->TotalNumberOfActiveDPP[i][j] + 1;
4068                                }
4069                        }
4070                        if (locals->TotalNumberOfActiveDPP[i][j] > mode_lib->vba.MaxNumDPP) {
4071                                locals->RequiredDISPCLK[i][j] = 0.0;
4072                                locals->DISPCLK_DPPCLK_Support[i][j] = true;
4073                                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4074                                        locals->ODMCombineEnablePerState[i][k] = false;
4075                                        if (locals->SwathWidthYSingleDPP[k] <= locals->MaximumSwathWidth[k]) {
4076                                                locals->NoOfDPP[i][j][k] = 1;
4077                                                locals->RequiredDPPCLK[i][j][k] = locals->MinDPPCLKUsingSingleDPP[k]
4078                                                        * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
4079                                        } else {
4080                                                locals->NoOfDPP[i][j][k] = 2;
4081                                                locals->RequiredDPPCLK[i][j][k] = locals->MinDPPCLKUsingSingleDPP[k]
4082                                                                                * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) / 2.0;
4083                                        }
4084                                        if (i != mode_lib->vba.soc.num_states) {
4085                                                mode_lib->vba.PlaneRequiredDISPCLK =
4086                                                                mode_lib->vba.PixelClock[k]
4087                                                                                * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
4088                                                                                * (1.0 + mode_lib->vba.DISPCLKRampingMargin / 100.0);
4089                                        } else {
4090                                                mode_lib->vba.PlaneRequiredDISPCLK = mode_lib->vba.PixelClock[k]
4091                                                        * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0);
4092                                        }
4093                                        locals->RequiredDISPCLK[i][j] = dml_max(
4094                                                        locals->RequiredDISPCLK[i][j],
4095                                                        mode_lib->vba.PlaneRequiredDISPCLK);
4096                                        if (locals->MinDPPCLKUsingSingleDPP[k] / locals->NoOfDPP[i][j][k] * (1.0 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0)
4097                                                        > mode_lib->vba.MaxDppclkRoundedDownToDFSGranularity
4098                                                        || mode_lib->vba.PlaneRequiredDISPCLK > mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity)
4099                                                locals->DISPCLK_DPPCLK_Support[i][j] = false;
4100                                }
4101                                locals->TotalNumberOfActiveDPP[i][j] = 0.0;
4102                                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++)
4103                                        locals->TotalNumberOfActiveDPP[i][j] = locals->TotalNumberOfActiveDPP[i][j] + locals->NoOfDPP[i][j][k];
4104                        }
4105                        locals->RequiredDISPCLK[i][j] = dml_max(
4106                                        locals->RequiredDISPCLK[i][j],
4107                                        mode_lib->vba.WritebackRequiredDISPCLK);
4108                        if (mode_lib->vba.MaxDispclkRoundedDownToDFSGranularity
4109                                        < mode_lib->vba.WritebackRequiredDISPCLK) {
4110                                locals->DISPCLK_DPPCLK_Support[i][j] = false;
4111                        }
4112                }
4113        }
4114        /*Viewport Size Check*/
4115
4116        for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4117                locals->ViewportSizeSupport[i][0] = true;
4118                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4119                        if (locals->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
4120                                if (dml_min(locals->SwathWidthYSingleDPP[k], dml_round(mode_lib->vba.HActive[k] / 2.0 * mode_lib->vba.HRatio[k]))
4121                                                > locals->MaximumSwathWidth[k]) {
4122                                        locals->ViewportSizeSupport[i][0] = false;
4123                                }
4124                        } else {
4125                                if (locals->SwathWidthYSingleDPP[k] / 2.0 > locals->MaximumSwathWidth[k]) {
4126                                        locals->ViewportSizeSupport[i][0] = false;
4127                                }
4128                        }
4129                }
4130        }
4131        /*Total Available Pipes Support Check*/
4132
4133        for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4134                for (j = 0; j < 2; j++) {
4135                        if (locals->TotalNumberOfActiveDPP[i][j] <= mode_lib->vba.MaxNumDPP)
4136                                locals->TotalAvailablePipesSupport[i][j] = true;
4137                        else
4138                                locals->TotalAvailablePipesSupport[i][j] = false;
4139                }
4140        }
4141        /*Total Available OTG Support Check*/
4142
4143        mode_lib->vba.TotalNumberOfActiveOTG = 0.0;
4144        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4145                if (mode_lib->vba.BlendingAndTiming[k] == k) {
4146                        mode_lib->vba.TotalNumberOfActiveOTG = mode_lib->vba.TotalNumberOfActiveOTG
4147                                        + 1.0;
4148                }
4149        }
4150        if (mode_lib->vba.TotalNumberOfActiveOTG <= mode_lib->vba.MaxNumOTG) {
4151                mode_lib->vba.NumberOfOTGSupport = true;
4152        } else {
4153                mode_lib->vba.NumberOfOTGSupport = false;
4154        }
4155        /*Display IO and DSC Support Check*/
4156
4157        mode_lib->vba.NonsupportedDSCInputBPC = false;
4158        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4159                if (!(mode_lib->vba.DSCInputBitPerComponent[k] == 12.0
4160                                || mode_lib->vba.DSCInputBitPerComponent[k] == 10.0
4161                                || mode_lib->vba.DSCInputBitPerComponent[k] == 8.0)) {
4162                        mode_lib->vba.NonsupportedDSCInputBPC = true;
4163                }
4164        }
4165        for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4166                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4167                        locals->RequiresDSC[i][k] = 0;
4168                        locals->RequiresFEC[i][k] = 0;
4169                        if (mode_lib->vba.BlendingAndTiming[k] == k) {
4170                                if (mode_lib->vba.Output[k] == dm_hdmi) {
4171                                        locals->RequiresDSC[i][k] = 0;
4172                                        locals->RequiresFEC[i][k] = 0;
4173                                        locals->OutputBppPerState[i][k] = TruncToValidBPP(
4174                                                        dml_min(600.0, mode_lib->vba.PHYCLKPerState[i]) / mode_lib->vba.PixelClockBackEnd[k] * 24,
4175                                                        mode_lib->vba.ForcedOutputLinkBPP[k],
4176                                                        false,
4177                                                        mode_lib->vba.Output[k],
4178                                                        mode_lib->vba.OutputFormat[k],
4179                                                        mode_lib->vba.DSCInputBitPerComponent[k]);
4180                                } else if (mode_lib->vba.Output[k] == dm_dp
4181                                                || mode_lib->vba.Output[k] == dm_edp) {
4182                                        if (mode_lib->vba.Output[k] == dm_edp) {
4183                                                mode_lib->vba.EffectiveFECOverhead = 0.0;
4184                                        } else {
4185                                                mode_lib->vba.EffectiveFECOverhead =
4186                                                                mode_lib->vba.FECOverhead;
4187                                        }
4188                                        if (mode_lib->vba.PHYCLKPerState[i] >= 270.0) {
4189                                                mode_lib->vba.Outbpp = TruncToValidBPP(
4190                                                                (1.0 - mode_lib->vba.Downspreading / 100.0) * 270.0
4191                                                                * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4192                                                                mode_lib->vba.ForcedOutputLinkBPP[k],
4193                                                                false,
4194                                                                mode_lib->vba.Output[k],
4195                                                                mode_lib->vba.OutputFormat[k],
4196                                                                mode_lib->vba.DSCInputBitPerComponent[k]);
4197                                                mode_lib->vba.OutbppDSC = TruncToValidBPP(
4198                                                                (1.0 - mode_lib->vba.Downspreading / 100.0) * (1.0 - mode_lib->vba.EffectiveFECOverhead / 100.0) * 270.0
4199                                                                * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4200                                                                mode_lib->vba.ForcedOutputLinkBPP[k],
4201                                                                true,
4202                                                                mode_lib->vba.Output[k],
4203                                                                mode_lib->vba.OutputFormat[k],
4204                                                                mode_lib->vba.DSCInputBitPerComponent[k]);
4205                                                if (mode_lib->vba.DSCEnabled[k] == true) {
4206                                                        locals->RequiresDSC[i][k] = true;
4207                                                        if (mode_lib->vba.Output[k] == dm_dp) {
4208                                                                locals->RequiresFEC[i][k] = true;
4209                                                        } else {
4210                                                                locals->RequiresFEC[i][k] = false;
4211                                                        }
4212                                                        mode_lib->vba.Outbpp = mode_lib->vba.OutbppDSC;
4213                                                } else {
4214                                                        locals->RequiresDSC[i][k] = false;
4215                                                        locals->RequiresFEC[i][k] = false;
4216                                                }
4217                                                locals->OutputBppPerState[i][k] = mode_lib->vba.Outbpp;
4218                                        }
4219                                        if (mode_lib->vba.Outbpp == BPP_INVALID && mode_lib->vba.PHYCLKPerState[i] >= 540.0) {
4220                                                mode_lib->vba.Outbpp = TruncToValidBPP(
4221                                                                (1.0 - mode_lib->vba.Downspreading / 100.0) * 540.0
4222                                                                * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4223                                                                mode_lib->vba.ForcedOutputLinkBPP[k],
4224                                                                        false,
4225                                                                        mode_lib->vba.Output[k],
4226                                                                        mode_lib->vba.OutputFormat[k],
4227                                                                        mode_lib->vba.DSCInputBitPerComponent[k]);
4228                                                mode_lib->vba.OutbppDSC = TruncToValidBPP(
4229                                                                (1.0 - mode_lib->vba.Downspreading / 100.0) * (1.0 - mode_lib->vba.EffectiveFECOverhead / 100.0) * 540.0
4230                                                                * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4231                                                                mode_lib->vba.ForcedOutputLinkBPP[k],
4232                                                                true,
4233                                                                mode_lib->vba.Output[k],
4234                                                                mode_lib->vba.OutputFormat[k],
4235                                                                mode_lib->vba.DSCInputBitPerComponent[k]);
4236                                                if (mode_lib->vba.DSCEnabled[k] == true) {
4237                                                        locals->RequiresDSC[i][k] = true;
4238                                                        if (mode_lib->vba.Output[k] == dm_dp) {
4239                                                                locals->RequiresFEC[i][k] = true;
4240                                                        } else {
4241                                                                locals->RequiresFEC[i][k] = false;
4242                                                        }
4243                                                        mode_lib->vba.Outbpp = mode_lib->vba.OutbppDSC;
4244                                                } else {
4245                                                        locals->RequiresDSC[i][k] = false;
4246                                                        locals->RequiresFEC[i][k] = false;
4247                                                }
4248                                                locals->OutputBppPerState[i][k] = mode_lib->vba.Outbpp;
4249                                        }
4250                                        if (mode_lib->vba.Outbpp == BPP_INVALID
4251                                                        && mode_lib->vba.PHYCLKPerState[i]
4252                                                                        >= 810.0) {
4253                                                mode_lib->vba.Outbpp = TruncToValidBPP(
4254                                                                (1.0 - mode_lib->vba.Downspreading / 100.0) * 810.0
4255                                                                * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4256                                                                mode_lib->vba.ForcedOutputLinkBPP[k],
4257                                                                false,
4258                                                                mode_lib->vba.Output[k],
4259                                                                mode_lib->vba.OutputFormat[k],
4260                                                                mode_lib->vba.DSCInputBitPerComponent[k]);
4261                                                mode_lib->vba.OutbppDSC = TruncToValidBPP(
4262                                                                (1.0 - mode_lib->vba.Downspreading / 100.0) * (1.0 - mode_lib->vba.EffectiveFECOverhead / 100.0) * 810.0
4263                                                                * mode_lib->vba.OutputLinkDPLanes[k] / mode_lib->vba.PixelClockBackEnd[k] * 8.0,
4264                                                                mode_lib->vba.ForcedOutputLinkBPP[k],
4265                                                                true,
4266                                                                mode_lib->vba.Output[k],
4267                                                                mode_lib->vba.OutputFormat[k],
4268                                                                mode_lib->vba.DSCInputBitPerComponent[k]);
4269                                                if (mode_lib->vba.DSCEnabled[k] == true || mode_lib->vba.Outbpp == BPP_INVALID) {
4270                                                        locals->RequiresDSC[i][k] = true;
4271                                                        if (mode_lib->vba.Output[k] == dm_dp) {
4272                                                                locals->RequiresFEC[i][k] = true;
4273                                                        } else {
4274                                                                locals->RequiresFEC[i][k] = false;
4275                                                        }
4276                                                        mode_lib->vba.Outbpp = mode_lib->vba.OutbppDSC;
4277                                                } else {
4278                                                        locals->RequiresDSC[i][k] = false;
4279                                                        locals->RequiresFEC[i][k] = false;
4280                                                }
4281                                                locals->OutputBppPerState[i][k] =
4282                                                                mode_lib->vba.Outbpp;
4283                                        }
4284                                }
4285                        } else {
4286                                locals->OutputBppPerState[i][k] = BPP_BLENDED_PIPE;
4287                        }
4288                }
4289        }
4290        for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4291                locals->DIOSupport[i] = true;
4292                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4293                        if (!mode_lib->vba.skip_dio_check[k]
4294                                        && (locals->OutputBppPerState[i][k] == BPP_INVALID
4295                                                || (mode_lib->vba.OutputFormat[k] == dm_420
4296                                                        && mode_lib->vba.Interlace[k] == true
4297                                                        && mode_lib->vba.ProgressiveToInterlaceUnitInOPP == true))) {
4298                                locals->DIOSupport[i] = false;
4299                        }
4300                }
4301        }
4302        for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4303                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4304                        locals->DSCCLKRequiredMoreThanSupported[i] = false;
4305                        if (mode_lib->vba.BlendingAndTiming[k] == k) {
4306                                if ((mode_lib->vba.Output[k] == dm_dp
4307                                                || mode_lib->vba.Output[k] == dm_edp)) {
4308                                        if (mode_lib->vba.OutputFormat[k] == dm_420
4309                                                        || mode_lib->vba.OutputFormat[k]
4310                                                                        == dm_n422) {
4311                                                mode_lib->vba.DSCFormatFactor = 2;
4312                                        } else {
4313                                                mode_lib->vba.DSCFormatFactor = 1;
4314                                        }
4315                                        if (locals->RequiresDSC[i][k] == true) {
4316                                                if (locals->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
4317                                                        if (mode_lib->vba.PixelClockBackEnd[k] / 6.0 / mode_lib->vba.DSCFormatFactor
4318                                                                        > (1.0 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * mode_lib->vba.MaxDSCCLK[i]) {
4319                                                                locals->DSCCLKRequiredMoreThanSupported[i] =
4320                                                                                true;
4321                                                        }
4322                                                } else {
4323                                                        if (mode_lib->vba.PixelClockBackEnd[k] / 3.0 / mode_lib->vba.DSCFormatFactor
4324                                                                        > (1.0 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * mode_lib->vba.MaxDSCCLK[i]) {
4325                                                                locals->DSCCLKRequiredMoreThanSupported[i] =
4326                                                                                true;
4327                                                        }
4328                                                }
4329                                        }
4330                                }
4331                        }
4332                }
4333        }
4334        for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4335                locals->NotEnoughDSCUnits[i] = false;
4336                mode_lib->vba.TotalDSCUnitsRequired = 0.0;
4337                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4338                        if (locals->RequiresDSC[i][k] == true) {
4339                                if (locals->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
4340                                        mode_lib->vba.TotalDSCUnitsRequired =
4341                                                        mode_lib->vba.TotalDSCUnitsRequired + 2.0;
4342                                } else {
4343                                        mode_lib->vba.TotalDSCUnitsRequired =
4344                                                        mode_lib->vba.TotalDSCUnitsRequired + 1.0;
4345                                }
4346                        }
4347                }
4348                if (mode_lib->vba.TotalDSCUnitsRequired > mode_lib->vba.NumberOfDSC) {
4349                        locals->NotEnoughDSCUnits[i] = true;
4350                }
4351        }
4352        /*DSC Delay per state*/
4353
4354        for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4355                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4356                        if (mode_lib->vba.BlendingAndTiming[k] != k) {
4357                                mode_lib->vba.slices = 0;
4358                        } else if (locals->RequiresDSC[i][k] == 0
4359                                        || locals->RequiresDSC[i][k] == false) {
4360                                mode_lib->vba.slices = 0;
4361                        } else if (mode_lib->vba.PixelClockBackEnd[k] > 3200.0) {
4362                                mode_lib->vba.slices = dml_ceil(
4363                                                mode_lib->vba.PixelClockBackEnd[k] / 400.0,
4364                                                4.0);
4365                        } else if (mode_lib->vba.PixelClockBackEnd[k] > 1360.0) {
4366                                mode_lib->vba.slices = 8.0;
4367                        } else if (mode_lib->vba.PixelClockBackEnd[k] > 680.0) {
4368                                mode_lib->vba.slices = 4.0;
4369                        } else if (mode_lib->vba.PixelClockBackEnd[k] > 340.0) {
4370                                mode_lib->vba.slices = 2.0;
4371                        } else {
4372                                mode_lib->vba.slices = 1.0;
4373                        }
4374                        if (locals->OutputBppPerState[i][k] == BPP_BLENDED_PIPE
4375                                        || locals->OutputBppPerState[i][k] == BPP_INVALID) {
4376                                mode_lib->vba.bpp = 0.0;
4377                        } else {
4378                                mode_lib->vba.bpp = locals->OutputBppPerState[i][k];
4379                        }
4380                        if (locals->RequiresDSC[i][k] == true && mode_lib->vba.bpp != 0.0) {
4381                                if (locals->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_disabled) {
4382                                        locals->DSCDelayPerState[i][k] =
4383                                                        dscceComputeDelay(
4384                                                                        mode_lib->vba.DSCInputBitPerComponent[k],
4385                                                                        mode_lib->vba.bpp,
4386                                                                        dml_ceil(
4387                                                                                        mode_lib->vba.HActive[k]
4388                                                                                                        / mode_lib->vba.slices,
4389                                                                                        1.0),
4390                                                                        mode_lib->vba.slices,
4391                                                                        mode_lib->vba.OutputFormat[k])
4392                                                                        + dscComputeDelay(
4393                                                                                        mode_lib->vba.OutputFormat[k]);
4394                                } else {
4395                                        locals->DSCDelayPerState[i][k] =
4396                                                        2.0 * (dscceComputeDelay(
4397                                                                                        mode_lib->vba.DSCInputBitPerComponent[k],
4398                                                                                        mode_lib->vba.bpp,
4399                                                                                        dml_ceil(mode_lib->vba.HActive[k] / mode_lib->vba.slices, 1.0),
4400                                                                                        mode_lib->vba.slices / 2,
4401                                                                                        mode_lib->vba.OutputFormat[k])
4402                                                                        + dscComputeDelay(mode_lib->vba.OutputFormat[k]));
4403                                }
4404                                locals->DSCDelayPerState[i][k] =
4405                                                locals->DSCDelayPerState[i][k] * mode_lib->vba.PixelClock[k] / mode_lib->vba.PixelClockBackEnd[k];
4406                        } else {
4407                                locals->DSCDelayPerState[i][k] = 0.0;
4408                        }
4409                }
4410                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4411                        for (m = 0; m <= mode_lib->vba.NumberOfActivePlanes - 1; m++) {
4412                                for (j = 0; j <= mode_lib->vba.NumberOfActivePlanes - 1; j++) {
4413                                        if (mode_lib->vba.BlendingAndTiming[k] == m && locals->RequiresDSC[i][m] == true)
4414                                                locals->DSCDelayPerState[i][k] = locals->DSCDelayPerState[i][m];
4415                                }
4416                        }
4417                }
4418        }
4419
4420        //Prefetch Check
4421        for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
4422                for (j = 0; j < 2; j++) {
4423                        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4424                                if (locals->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1)
4425                                        locals->SwathWidthYPerState[i][j][k] = dml_min(locals->SwathWidthYSingleDPP[k], dml_round(locals->HActive[k] / 2 * locals->HRatio[k]));
4426                                else
4427                                        locals->SwathWidthYPerState[i][j][k] = locals->SwathWidthYSingleDPP[k] / locals->NoOfDPP[i][j][k];
4428                                locals->SwathWidthGranularityY = 256  / dml_ceil(locals->BytePerPixelInDETY[k], 1) / locals->MaxSwathHeightY[k];
4429                                locals->RoundedUpMaxSwathSizeBytesY = (dml_ceil(locals->SwathWidthYPerState[i][j][k] - 1, locals->SwathWidthGranularityY)
4430                                                + locals->SwathWidthGranularityY) * locals->BytePerPixelInDETY[k] * locals->MaxSwathHeightY[k];
4431                                if (locals->SourcePixelFormat[k] == dm_420_10) {
4432                                        locals->RoundedUpMaxSwathSizeBytesY = dml_ceil(locals->RoundedUpMaxSwathSizeBytesY, 256) + 256;
4433                                }
4434                                if (locals->MaxSwathHeightC[k] > 0) {
4435                                        locals->SwathWidthGranularityC = 256 / dml_ceil(locals->BytePerPixelInDETC[k], 2) / locals->MaxSwathHeightC[k];
4436
4437                                        locals->RoundedUpMaxSwathSizeBytesC = (dml_ceil(locals->SwathWidthYPerState[i][j][k] / 2 - 1, locals->SwathWidthGranularityC)
4438                                        + locals->SwathWidthGranularityC) * locals->BytePerPixelInDETC[k] * locals->MaxSwathHeightC[k];
4439                                }
4440                                if (locals->SourcePixelFormat[k] == dm_420_10) {
4441                                        locals->RoundedUpMaxSwathSizeBytesC = dml_ceil(locals->RoundedUpMaxSwathSizeBytesC, 256)  + 256;
4442                                } else {
4443                                        locals->RoundedUpMaxSwathSizeBytesC = 0;
4444                                }
4445
4446                                if (locals->RoundedUpMaxSwathSizeBytesY + locals->RoundedUpMaxSwathSizeBytesC <= locals->DETBufferSizeInKByte[0] * 1024 / 2) {
4447                                        locals->SwathHeightYPerState[i][j][k] = locals->MaxSwathHeightY[k];
4448                                        locals->SwathHeightCPerState[i][j][k] = locals->MaxSwathHeightC[k];
4449                                } else {
4450                                        locals->SwathHeightYPerState[i][j][k] = locals->MinSwathHeightY[k];
4451                                        locals->SwathHeightCPerState[i][j][k] = locals->MinSwathHeightC[k];
4452                                }
4453
4454                                if (locals->BytePerPixelInDETC[k] == 0) {
4455                                        locals->LinesInDETLuma = locals->DETBufferSizeInKByte[0] * 1024 / locals->BytePerPixelInDETY[k] / locals->SwathWidthYPerState[i][j][k];
4456                                        locals->LinesInDETChroma = 0;
4457                                } else if (locals->SwathHeightYPerState[i][j][k] <= locals->SwathHeightCPerState[i][j][k]) {
4458                                        locals->LinesInDETLuma = locals->DETBufferSizeInKByte[0] * 1024 / 2 / locals->BytePerPixelInDETY[k] /
4459                                                        locals->SwathWidthYPerState[i][j][k];
4460                                        locals->LinesInDETChroma = locals->DETBufferSizeInKByte[0] * 1024 / 2 / locals->BytePerPixelInDETC[k] / (locals->SwathWidthYPerState[i][j][k] / 2);
4461                                } else {
4462                                        locals->LinesInDETLuma = locals->DETBufferSizeInKByte[0] * 1024 * 2 / 3 / locals->BytePerPixelInDETY[k] / locals->SwathWidthYPerState[i][j][k];
4463                                        locals->LinesInDETChroma = locals->DETBufferSizeInKByte[0] * 1024 / 3 / locals->BytePerPixelInDETY[k] / (locals->SwathWidthYPerState[i][j][k] / 2);
4464                                }
4465
4466                                locals->EffectiveLBLatencyHidingSourceLinesLuma = dml_min(locals->MaxLineBufferLines,
4467                                        dml_floor(locals->LineBufferSize / locals->LBBitPerPixel[k] / (locals->SwathWidthYPerState[i][j][k]
4468                                        / dml_max(locals->HRatio[k], 1)), 1)) - (locals->vtaps[k] - 1);
4469
4470                                locals->EffectiveLBLatencyHidingSourceLinesChroma =  dml_min(locals->MaxLineBufferLines,
4471                                                dml_floor(locals->LineBufferSize / locals->LBBitPerPixel[k]
4472                                                / (locals->SwathWidthYPerState[i][j][k] / 2
4473                                                / dml_max(locals->HRatio[k] / 2, 1)), 1)) - (locals->VTAPsChroma[k] - 1);
4474
4475                                locals->EffectiveDETLBLinesLuma = dml_floor(locals->LinesInDETLuma +  dml_min(
4476                                                locals->LinesInDETLuma * locals->RequiredDISPCLK[i][j] * locals->BytePerPixelInDETY[k] *
4477                                                locals->PSCL_FACTOR[k] / locals->ReturnBWPerState[i][0],
4478                                                locals->EffectiveLBLatencyHidingSourceLinesLuma),
4479                                                locals->SwathHeightYPerState[i][j][k]);
4480
4481                                locals->EffectiveDETLBLinesChroma = dml_floor(locals->LinesInDETChroma + dml_min(
4482                                                locals->LinesInDETChroma * locals->RequiredDISPCLK[i][j] * locals->BytePerPixelInDETC[k] *
4483                                                locals->PSCL_FACTOR_CHROMA[k] / locals->ReturnBWPerState[i][0],
4484                                                locals->EffectiveLBLatencyHidingSourceLinesChroma),
4485                                                locals->SwathHeightCPerState[i][j][k]);
4486
4487                                if (locals->BytePerPixelInDETC[k] == 0) {
4488                                        locals->UrgentLatencySupportUsPerState[i][j][k] = locals->EffectiveDETLBLinesLuma * (locals->HTotal[k] / locals->PixelClock[k])
4489                                                        / locals->VRatio[k] - locals->EffectiveDETLBLinesLuma * locals->SwathWidthYPerState[i][j][k] *
4490                                                                dml_ceil(locals->BytePerPixelInDETY[k], 1) / (locals->ReturnBWPerState[i][0] / locals->NoOfDPP[i][j][k]);
4491                                } else {
4492                                        locals->UrgentLatencySupportUsPerState[i][j][k] = dml_min(
4493                                                locals->EffectiveDETLBLinesLuma * (locals->HTotal[k] / locals->PixelClock[k])
4494                                                / locals->VRatio[k] - locals->EffectiveDETLBLinesLuma * locals->SwathWidthYPerState[i][j][k] *
4495                                                dml_ceil(locals->BytePerPixelInDETY[k], 1) / (locals->ReturnBWPerState[i][0] / locals->NoOfDPP[i][j][k]),
4496                                                        locals->EffectiveDETLBLinesChroma * (locals->HTotal[k] / locals->PixelClock[k]) / (locals->VRatio[k] / 2) -
4497                                                        locals->EffectiveDETLBLinesChroma * locals->SwathWidthYPerState[i][j][k] / 2 *
4498                                                        dml_ceil(locals->BytePerPixelInDETC[k], 2) / (locals->ReturnBWPerState[i][0] / locals->NoOfDPP[i][j][k]));
4499                                }
4500                        }
4501                }
4502        }
4503
4504        for (i = 0; i <= locals->soc.num_states; i++) {
4505                for (j = 0; j < 2; j++) {
4506                        locals->UrgentLatencySupport[i][j] = true;
4507                        for (k = 0; k < locals->NumberOfActivePlanes; k++) {
4508                                if (locals->UrgentLatencySupportUsPerState[i][j][k] < locals->UrgentLatency)
4509                                        locals->UrgentLatencySupport[i][j] = false;
4510                        }
4511                }
4512        }
4513
4514
4515        /*Prefetch Check*/
4516        for (i = 0; i <= locals->soc.num_states; i++) {
4517                for (j = 0; j < 2; j++) {
4518                        locals->TotalNumberOfDCCActiveDPP[i][j] = 0;
4519                        for (k = 0; k < locals->NumberOfActivePlanes; k++) {
4520                                if (locals->DCCEnable[k] == true) {
4521                                        locals->TotalNumberOfDCCActiveDPP[i][j] =
4522                                                locals->TotalNumberOfDCCActiveDPP[i][j] + locals->NoOfDPP[i][j][k];
4523                                }
4524                        }
4525                }
4526        }
4527
4528        CalculateMinAndMaxPrefetchMode(locals->AllowDRAMSelfRefreshOrDRAMClockChangeInVblank, &locals->MinPrefetchMode, &locals->MaxPrefetchMode);
4529
4530        locals->MaxTotalVActiveRDBandwidth = 0;
4531        for (k = 0; k < locals->NumberOfActivePlanes; k++) {
4532                locals->MaxTotalVActiveRDBandwidth = locals->MaxTotalVActiveRDBandwidth + locals->ReadBandwidth[k];
4533        }
4534
4535        for (i = 0; i <= locals->soc.num_states; i++) {
4536                for (j = 0; j < 2; j++) {
4537                        for (k = 0; k < locals->NumberOfActivePlanes; k++) {
4538                                locals->NoOfDPPThisState[k] = locals->NoOfDPP[i][j][k];
4539                                locals->RequiredDPPCLKThisState[k] = locals->RequiredDPPCLK[i][j][k];
4540                                locals->SwathHeightYThisState[k] = locals->SwathHeightYPerState[i][j][k];
4541                                locals->SwathHeightCThisState[k] = locals->SwathHeightCPerState[i][j][k];
4542                                locals->SwathWidthYThisState[k] = locals->SwathWidthYPerState[i][j][k];
4543                                mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0] = dml_max(
4544                                                mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0],
4545                                                mode_lib->vba.PixelClock[k] / 16.0);
4546                                if (mode_lib->vba.BytePerPixelInDETC[k] == 0.0) {
4547                                        if (mode_lib->vba.VRatio[k] <= 1.0) {
4548                                                mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0] =
4549                                                                dml_max(
4550                                                                                mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0],
4551                                                                                1.1
4552                                                                                                * dml_ceil(
4553                                                                                                                mode_lib->vba.BytePerPixelInDETY[k],
4554                                                                                                                1.0)
4555                                                                                                / 64.0
4556                                                                                                * mode_lib->vba.HRatio[k]
4557                                                                                                * mode_lib->vba.PixelClock[k]
4558                                                                                                / mode_lib->vba.NoOfDPP[i][j][k]);
4559                                        } else {
4560                                                mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0] =
4561                                                                dml_max(
4562                                                                                mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0],
4563                                                                                1.1
4564                                                                                                * dml_ceil(
4565                                                                                                                mode_lib->vba.BytePerPixelInDETY[k],
4566                                                                                                                1.0)
4567                                                                                                / 64.0
4568                                                                                                * mode_lib->vba.PSCL_FACTOR[k]
4569                                                                                                * mode_lib->vba.RequiredDPPCLK[i][j][k]);
4570                                        }
4571                                } else {
4572                                        if (mode_lib->vba.VRatio[k] <= 1.0) {
4573                                                mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0] =
4574                                                                dml_max(
4575                                                                                mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0],
4576                                                                                1.1
4577                                                                                                * dml_ceil(
4578                                                                                                                mode_lib->vba.BytePerPixelInDETY[k],
4579                                                                                                                1.0)
4580                                                                                                / 32.0
4581                                                                                                * mode_lib->vba.HRatio[k]
4582                                                                                                * mode_lib->vba.PixelClock[k]
4583                                                                                                / mode_lib->vba.NoOfDPP[i][j][k]);
4584                                        } else {
4585                                                mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0] =
4586                                                                dml_max(
4587                                                                                mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0],
4588                                                                                1.1
4589                                                                                                * dml_ceil(
4590                                                                                                                mode_lib->vba.BytePerPixelInDETY[k],
4591                                                                                                                1.0)
4592                                                                                                / 32.0
4593                                                                                                * mode_lib->vba.PSCL_FACTOR[k]
4594                                                                                                * mode_lib->vba.RequiredDPPCLK[i][j][k]);
4595                                        }
4596                                        if (mode_lib->vba.VRatio[k] / 2.0 <= 1.0) {
4597                                                mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0] =
4598                                                                dml_max(
4599                                                                                mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0],
4600                                                                                1.1
4601                                                                                                * dml_ceil(
4602                                                                                                                mode_lib->vba.BytePerPixelInDETC[k],
4603                                                                                                                2.0)
4604                                                                                                / 32.0
4605                                                                                                * mode_lib->vba.HRatio[k]
4606                                                                                                / 2.0
4607                                                                                                * mode_lib->vba.PixelClock[k]
4608                                                                                                / mode_lib->vba.NoOfDPP[i][j][k]);
4609                                        } else {
4610                                                mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0] =
4611                                                                dml_max(
4612                                                                                mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0],
4613                                                                                1.1
4614                                                                                                * dml_ceil(
4615                                                                                                                mode_lib->vba.BytePerPixelInDETC[k],
4616                                                                                                                2.0)
4617                                                                                                / 32.0
4618                                                                                                * mode_lib->vba.PSCL_FACTOR_CHROMA[k]
4619                                                                                                * mode_lib->vba.RequiredDPPCLK[i][j][k]);
4620                                        }
4621                                }
4622                        }
4623                        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4624                                mode_lib->vba.PDEAndMetaPTEBytesPerFrameY = CalculateVMAndRowBytes(
4625                                                mode_lib,
4626                                                mode_lib->vba.DCCEnable[k],
4627                                                mode_lib->vba.Read256BlockHeightY[k],
4628                                                mode_lib->vba.Read256BlockWidthY[k],
4629                                                mode_lib->vba.SourcePixelFormat[k],
4630                                                mode_lib->vba.SurfaceTiling[k],
4631                                                dml_ceil(mode_lib->vba.BytePerPixelInDETY[k], 1.0),
4632                                                mode_lib->vba.SourceScan[k],
4633                                                mode_lib->vba.ViewportWidth[k],
4634                                                mode_lib->vba.ViewportHeight[k],
4635                                                mode_lib->vba.SwathWidthYPerState[i][j][k],
4636                                                mode_lib->vba.GPUVMEnable,
4637                                                mode_lib->vba.VMMPageSize,
4638                                                mode_lib->vba.PTEBufferSizeInRequestsLuma,
4639                                                mode_lib->vba.PDEProcessingBufIn64KBReqs,
4640                                                mode_lib->vba.PitchY[k],
4641                                                mode_lib->vba.DCCMetaPitchY[k],
4642                                                &mode_lib->vba.MacroTileWidthY[k],
4643                                                &mode_lib->vba.MetaRowBytesY,
4644                                                &mode_lib->vba.DPTEBytesPerRowY,
4645                                                &mode_lib->vba.PTEBufferSizeNotExceededY[i][j][k],
4646                                                &mode_lib->vba.dpte_row_height[k],
4647                                                &mode_lib->vba.meta_row_height[k]);
4648                                mode_lib->vba.PrefetchLinesY[0][0][k] = CalculatePrefetchSourceLines(
4649                                                mode_lib,
4650                                                mode_lib->vba.VRatio[k],
4651                                                mode_lib->vba.vtaps[k],
4652                                                mode_lib->vba.Interlace[k],
4653                                                mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
4654                                                mode_lib->vba.SwathHeightYPerState[i][j][k],
4655                                                mode_lib->vba.ViewportYStartY[k],
4656                                                &mode_lib->vba.PrefillY[k],
4657                                                &mode_lib->vba.MaxNumSwY[k]);
4658                                if ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64
4659                                                && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
4660                                                && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
4661                                                && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
4662                                                && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8)) {
4663                                        mode_lib->vba.PDEAndMetaPTEBytesPerFrameC = CalculateVMAndRowBytes(
4664                                                        mode_lib,
4665                                                        mode_lib->vba.DCCEnable[k],
4666                                                        mode_lib->vba.Read256BlockHeightY[k],
4667                                                        mode_lib->vba.Read256BlockWidthY[k],
4668                                                        mode_lib->vba.SourcePixelFormat[k],
4669                                                        mode_lib->vba.SurfaceTiling[k],
4670                                                        dml_ceil(mode_lib->vba.BytePerPixelInDETC[k], 2.0),
4671                                                        mode_lib->vba.SourceScan[k],
4672                                                        mode_lib->vba.ViewportWidth[k] / 2.0,
4673                                                        mode_lib->vba.ViewportHeight[k] / 2.0,
4674                                                        mode_lib->vba.SwathWidthYPerState[i][j][k] / 2.0,
4675                                                        mode_lib->vba.GPUVMEnable,
4676                                                        mode_lib->vba.VMMPageSize,
4677                                                        mode_lib->vba.PTEBufferSizeInRequestsLuma,
4678                                                        mode_lib->vba.PDEProcessingBufIn64KBReqs,
4679                                                        mode_lib->vba.PitchC[k],
4680                                                        0.0,
4681                                                        &mode_lib->vba.MacroTileWidthC[k],
4682                                                        &mode_lib->vba.MetaRowBytesC,
4683                                                        &mode_lib->vba.DPTEBytesPerRowC,
4684                                                        &mode_lib->vba.PTEBufferSizeNotExceededC[i][j][k],
4685                                                        &mode_lib->vba.dpte_row_height_chroma[k],
4686                                                        &mode_lib->vba.meta_row_height_chroma[k]);
4687                                        mode_lib->vba.PrefetchLinesC[0][0][k] = CalculatePrefetchSourceLines(
4688                                                        mode_lib,
4689                                                        mode_lib->vba.VRatio[k] / 2.0,
4690                                                        mode_lib->vba.VTAPsChroma[k],
4691                                                        mode_lib->vba.Interlace[k],
4692                                                        mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
4693                                                        mode_lib->vba.SwathHeightCPerState[i][j][k],
4694                                                        mode_lib->vba.ViewportYStartC[k],
4695                                                        &mode_lib->vba.PrefillC[k],
4696                                                        &mode_lib->vba.MaxNumSwC[k]);
4697                                } else {
4698                                        mode_lib->vba.PDEAndMetaPTEBytesPerFrameC = 0.0;
4699                                        mode_lib->vba.MetaRowBytesC = 0.0;
4700                                        mode_lib->vba.DPTEBytesPerRowC = 0.0;
4701                                        locals->PrefetchLinesC[0][0][k] = 0.0;
4702                                        locals->PTEBufferSizeNotExceededC[i][j][k] = true;
4703                                        locals->PTEBufferSizeInRequestsForLuma = mode_lib->vba.PTEBufferSizeInRequestsLuma + mode_lib->vba.PTEBufferSizeInRequestsChroma;
4704                                }
4705                                locals->PDEAndMetaPTEBytesPerFrame[0][0][k] =
4706                                                mode_lib->vba.PDEAndMetaPTEBytesPerFrameY + mode_lib->vba.PDEAndMetaPTEBytesPerFrameC;
4707                                locals->MetaRowBytes[0][0][k] = mode_lib->vba.MetaRowBytesY + mode_lib->vba.MetaRowBytesC;
4708                                locals->DPTEBytesPerRow[0][0][k] = mode_lib->vba.DPTEBytesPerRowY + mode_lib->vba.DPTEBytesPerRowC;
4709
4710                                CalculateActiveRowBandwidth(
4711                                                mode_lib->vba.GPUVMEnable,
4712                                                mode_lib->vba.SourcePixelFormat[k],
4713                                                mode_lib->vba.VRatio[k],
4714                                                mode_lib->vba.DCCEnable[k],
4715                                                mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
4716                                                mode_lib->vba.MetaRowBytesY,
4717                                                mode_lib->vba.MetaRowBytesC,
4718                                                mode_lib->vba.meta_row_height[k],
4719                                                mode_lib->vba.meta_row_height_chroma[k],
4720                                                mode_lib->vba.DPTEBytesPerRowY,
4721                                                mode_lib->vba.DPTEBytesPerRowC,
4722                                                mode_lib->vba.dpte_row_height[k],
4723                                                mode_lib->vba.dpte_row_height_chroma[k],
4724                                                &mode_lib->vba.meta_row_bw[k],
4725                                                &mode_lib->vba.dpte_row_bw[k],
4726                                                &mode_lib->vba.qual_row_bw[k]);
4727                        }
4728                        mode_lib->vba.ExtraLatency =
4729                                        mode_lib->vba.UrgentRoundTripAndOutOfOrderLatencyPerState[i]
4730                                                        + (mode_lib->vba.TotalNumberOfActiveDPP[i][j]
4731                                                                        * mode_lib->vba.PixelChunkSizeInKByte
4732                                                                        + mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j]
4733                                                                                        * mode_lib->vba.MetaChunkSize)
4734                                                                        * 1024.0
4735                                                                        / mode_lib->vba.ReturnBWPerState[i][0];
4736                        if (mode_lib->vba.GPUVMEnable == true) {
4737                                mode_lib->vba.ExtraLatency = mode_lib->vba.ExtraLatency
4738                                                + mode_lib->vba.TotalNumberOfActiveDPP[i][j]
4739                                                                * mode_lib->vba.PTEGroupSize
4740                                                                / mode_lib->vba.ReturnBWPerState[i][0];
4741                        }
4742                        mode_lib->vba.TimeCalc = 24.0 / mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0];
4743
4744                        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4745                                if (mode_lib->vba.BlendingAndTiming[k] == k) {
4746                                        if (mode_lib->vba.WritebackEnable[k] == true) {
4747                                                locals->WritebackDelay[i][k] = mode_lib->vba.WritebackLatency
4748                                                                + CalculateWriteBackDelay(
4749                                                                                mode_lib->vba.WritebackPixelFormat[k],
4750                                                                                mode_lib->vba.WritebackHRatio[k],
4751                                                                                mode_lib->vba.WritebackVRatio[k],
4752                                                                                mode_lib->vba.WritebackLumaHTaps[k],
4753                                                                                mode_lib->vba.WritebackLumaVTaps[k],
4754                                                                                mode_lib->vba.WritebackChromaHTaps[k],
4755                                                                                mode_lib->vba.WritebackChromaVTaps[k],
4756                                                                                mode_lib->vba.WritebackDestinationWidth[k]) / locals->RequiredDISPCLK[i][j];
4757                                        } else {
4758                                                locals->WritebackDelay[i][k] = 0.0;
4759                                        }
4760                                        for (m = 0; m <= mode_lib->vba.NumberOfActivePlanes - 1; m++) {
4761                                                if (mode_lib->vba.BlendingAndTiming[m] == k
4762                                                                && mode_lib->vba.WritebackEnable[m]
4763                                                                                == true) {
4764                                                        locals->WritebackDelay[i][k] = dml_max(locals->WritebackDelay[i][k],
4765                                                                                        mode_lib->vba.WritebackLatency + CalculateWriteBackDelay(
4766                                                                                                        mode_lib->vba.WritebackPixelFormat[m],
4767                                                                                                        mode_lib->vba.WritebackHRatio[m],
4768                                                                                                        mode_lib->vba.WritebackVRatio[m],
4769                                                                                                        mode_lib->vba.WritebackLumaHTaps[m],
4770                                                                                                        mode_lib->vba.WritebackLumaVTaps[m],
4771                                                                                                        mode_lib->vba.WritebackChromaHTaps[m],
4772                                                                                                        mode_lib->vba.WritebackChromaVTaps[m],
4773                                                                                                        mode_lib->vba.WritebackDestinationWidth[m]) / locals->RequiredDISPCLK[i][j]);
4774                                                }
4775                                        }
4776                                }
4777                        }
4778                        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4779                                for (m = 0; m <= mode_lib->vba.NumberOfActivePlanes - 1; m++) {
4780                                        if (mode_lib->vba.BlendingAndTiming[k] == m) {
4781                                                locals->WritebackDelay[i][k] = locals->WritebackDelay[i][m];
4782                                        }
4783                                }
4784                        }
4785                        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4786                                for (m = 0; m < locals->NumberOfCursors[k]; m++)
4787                                        locals->cursor_bw[k] = locals->NumberOfCursors[k] * locals->CursorWidth[k][m] * locals->CursorBPP[k][m]
4788                                                / 8 / (locals->HTotal[k] / locals->PixelClock[k]) * locals->VRatio[k];
4789                        }
4790
4791                        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4792                                locals->MaximumVStartup[0][0][k] = mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]
4793                                        - dml_max(1.0, dml_ceil(locals->WritebackDelay[i][k] / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]), 1.0));
4794                        }
4795
4796                        mode_lib->vba.NextPrefetchMode = mode_lib->vba.MinPrefetchMode;
4797                        do {
4798                                mode_lib->vba.PrefetchMode[i][j] = mode_lib->vba.NextPrefetchMode;
4799                                mode_lib->vba.NextPrefetchMode = mode_lib->vba.NextPrefetchMode + 1;
4800
4801                                mode_lib->vba.TWait = CalculateTWait(
4802                                                mode_lib->vba.PrefetchMode[i][j],
4803                                                mode_lib->vba.DRAMClockChangeLatency,
4804                                                mode_lib->vba.UrgentLatency,
4805                                                mode_lib->vba.SREnterPlusExitTime);
4806                                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4807
4808                                        if (mode_lib->vba.XFCEnabled[k] == true) {
4809                                                mode_lib->vba.XFCRemoteSurfaceFlipDelay =
4810                                                                CalculateRemoteSurfaceFlipDelay(
4811                                                                                mode_lib,
4812                                                                                mode_lib->vba.VRatio[k],
4813                                                                                locals->SwathWidthYPerState[i][j][k],
4814                                                                                dml_ceil(locals->BytePerPixelInDETY[k], 1.0),
4815                                                                                mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
4816                                                                                mode_lib->vba.XFCTSlvVupdateOffset,
4817                                                                                mode_lib->vba.XFCTSlvVupdateWidth,
4818                                                                                mode_lib->vba.XFCTSlvVreadyOffset,
4819                                                                                mode_lib->vba.XFCXBUFLatencyTolerance,
4820                                                                                mode_lib->vba.XFCFillBWOverhead,
4821                                                                                mode_lib->vba.XFCSlvChunkSize,
4822                                                                                mode_lib->vba.XFCBusTransportTime,
4823                                                                                mode_lib->vba.TimeCalc,
4824                                                                                mode_lib->vba.TWait,
4825                                                                                &mode_lib->vba.SrcActiveDrainRate,
4826                                                                                &mode_lib->vba.TInitXFill,
4827                                                                                &mode_lib->vba.TslvChk);
4828                                        } else {
4829                                                mode_lib->vba.XFCRemoteSurfaceFlipDelay = 0.0;
4830                                        }
4831
4832                                        CalculateDelayAfterScaler(mode_lib, mode_lib->vba.ReturnBWPerState[i][0], mode_lib->vba.ReadBandwidthLuma[k], mode_lib->vba.ReadBandwidthChroma[k], mode_lib->vba.MaxTotalVActiveRDBandwidth,
4833                                                mode_lib->vba.DisplayPipeLineDeliveryTimeLuma[k], mode_lib->vba.DisplayPipeLineDeliveryTimeChroma[k],
4834                                                mode_lib->vba.RequiredDPPCLK[i][j][k], mode_lib->vba.RequiredDISPCLK[i][j], mode_lib->vba.PixelClock[k], mode_lib->vba.DSCDelayPerState[i][k], mode_lib->vba.NoOfDPP[i][j][k], mode_lib->vba.ScalerEnabled[k], mode_lib->vba.NumberOfCursors[k],
4835                                                mode_lib->vba.DPPCLKDelaySubtotal, mode_lib->vba.DPPCLKDelaySCL, mode_lib->vba.DPPCLKDelaySCLLBOnly, mode_lib->vba.DPPCLKDelayCNVCFormater, mode_lib->vba.DPPCLKDelayCNVCCursor, mode_lib->vba.DISPCLKDelaySubtotal,
4836                                                mode_lib->vba.SwathWidthYPerState[i][j][k] / mode_lib->vba.HRatio[k], mode_lib->vba.OutputFormat[k], mode_lib->vba.HTotal[k],
4837                                                mode_lib->vba.SwathWidthYSingleDPP[k], mode_lib->vba.BytePerPixelInDETY[k], mode_lib->vba.BytePerPixelInDETC[k], mode_lib->vba.SwathHeightYThisState[k], mode_lib->vba.SwathHeightCThisState[k], mode_lib->vba.Interlace[k], mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
4838                                                &mode_lib->vba.DSTXAfterScaler[k], &mode_lib->vba.DSTYAfterScaler[k]);
4839
4840                                        mode_lib->vba.IsErrorResult[i][j][k] =
4841                                                        CalculatePrefetchSchedule(
4842                                                                        mode_lib,
4843                                                                        mode_lib->vba.RequiredDPPCLK[i][j][k],
4844                                                                        mode_lib->vba.RequiredDISPCLK[i][j],
4845                                                                        mode_lib->vba.PixelClock[k],
4846                                                                        mode_lib->vba.ProjectedDCFCLKDeepSleep[0][0],
4847                                                                        mode_lib->vba.NoOfDPP[i][j][k],
4848                                                                        mode_lib->vba.NumberOfCursors[k],
4849                                                                        mode_lib->vba.VTotal[k]
4850                                                                                        - mode_lib->vba.VActive[k],
4851                                                                        mode_lib->vba.HTotal[k],
4852                                                                        mode_lib->vba.MaxInterDCNTileRepeaters,
4853                                                                        mode_lib->vba.MaximumVStartup[0][0][k],
4854                                                                        mode_lib->vba.GPUVMMaxPageTableLevels,
4855                                                                        mode_lib->vba.GPUVMEnable,
4856                                                                        mode_lib->vba.DynamicMetadataEnable[k],
4857                                                                        mode_lib->vba.DynamicMetadataLinesBeforeActiveRequired[k],
4858                                                                        mode_lib->vba.DynamicMetadataTransmittedBytes[k],
4859                                                                        mode_lib->vba.DCCEnable[k],
4860                                                                        mode_lib->vba.UrgentLatencyPixelDataOnly,
4861                                                                        mode_lib->vba.ExtraLatency,
4862                                                                        mode_lib->vba.TimeCalc,
4863                                                                        mode_lib->vba.PDEAndMetaPTEBytesPerFrame[0][0][k],
4864                                                                        mode_lib->vba.MetaRowBytes[0][0][k],
4865                                                                        mode_lib->vba.DPTEBytesPerRow[0][0][k],
4866                                                                        mode_lib->vba.PrefetchLinesY[0][0][k],
4867                                                                        mode_lib->vba.SwathWidthYPerState[i][j][k],
4868                                                                        mode_lib->vba.BytePerPixelInDETY[k],
4869                                                                        mode_lib->vba.PrefillY[k],
4870                                                                        mode_lib->vba.MaxNumSwY[k],
4871                                                                        mode_lib->vba.PrefetchLinesC[0][0][k],
4872                                                                        mode_lib->vba.BytePerPixelInDETC[k],
4873                                                                        mode_lib->vba.PrefillC[k],
4874                                                                        mode_lib->vba.MaxNumSwC[k],
4875                                                                        mode_lib->vba.SwathHeightYPerState[i][j][k],
4876                                                                        mode_lib->vba.SwathHeightCPerState[i][j][k],
4877                                                                        mode_lib->vba.TWait,
4878                                                                        mode_lib->vba.XFCEnabled[k],
4879                                                                        mode_lib->vba.XFCRemoteSurfaceFlipDelay,
4880                                                                        mode_lib->vba.Interlace[k],
4881                                                                        mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
4882                                                                        mode_lib->vba.DSTXAfterScaler[k],
4883                                                                        mode_lib->vba.DSTYAfterScaler[k],
4884                                                                        &mode_lib->vba.LineTimesForPrefetch[k],
4885                                                                        &mode_lib->vba.PrefetchBW[k],
4886                                                                        &mode_lib->vba.LinesForMetaPTE[k],
4887                                                                        &mode_lib->vba.LinesForMetaAndDPTERow[k],
4888                                                                        &mode_lib->vba.VRatioPreY[i][j][k],
4889                                                                        &mode_lib->vba.VRatioPreC[i][j][k],
4890                                                                        &mode_lib->vba.RequiredPrefetchPixelDataBWLuma[i][j][k],
4891                                                                        &mode_lib->vba.Tno_bw[k],
4892                                                                        &mode_lib->vba.VUpdateOffsetPix[k],
4893                                                                        &mode_lib->vba.VUpdateWidthPix[k],
4894                                                                        &mode_lib->vba.VReadyOffsetPix[k]);
4895                                }
4896                                mode_lib->vba.MaximumReadBandwidthWithoutPrefetch = 0.0;
4897                                mode_lib->vba.MaximumReadBandwidthWithPrefetch = 0.0;
4898                                locals->prefetch_vm_bw_valid = true;
4899                                locals->prefetch_row_bw_valid = true;
4900                                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4901                                        if (locals->PDEAndMetaPTEBytesPerFrame[0][0][k] == 0)
4902                                                locals->prefetch_vm_bw[k] = 0;
4903                                        else if (locals->LinesForMetaPTE[k] > 0)
4904                                                locals->prefetch_vm_bw[k] = locals->PDEAndMetaPTEBytesPerFrame[0][0][k]
4905                                                        / (locals->LinesForMetaPTE[k] * locals->HTotal[k] / locals->PixelClock[k]);
4906                                        else {
4907                                                locals->prefetch_vm_bw[k] = 0;
4908                                                locals->prefetch_vm_bw_valid = false;
4909                                        }
4910                                        if (locals->MetaRowBytes[0][0][k] + locals->DPTEBytesPerRow[0][0][k] == 0)
4911                                                locals->prefetch_row_bw[k] = 0;
4912                                        else if (locals->LinesForMetaAndDPTERow[k] > 0)
4913                                                locals->prefetch_row_bw[k] = (locals->MetaRowBytes[0][0][k] + locals->DPTEBytesPerRow[0][0][k])
4914                                                        / (locals->LinesForMetaAndDPTERow[k] * locals->HTotal[k] / locals->PixelClock[k]);
4915                                        else {
4916                                                locals->prefetch_row_bw[k] = 0;
4917                                                locals->prefetch_row_bw_valid = false;
4918                                        }
4919
4920                                        mode_lib->vba.MaximumReadBandwidthWithoutPrefetch = mode_lib->vba.MaximumReadBandwidthWithPrefetch
4921                                                        + 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];
4922                                        mode_lib->vba.MaximumReadBandwidthWithPrefetch =
4923                                                        mode_lib->vba.MaximumReadBandwidthWithPrefetch
4924                                                                        + mode_lib->vba.cursor_bw[k]
4925                                                                        + dml_max3(
4926                                                                                        mode_lib->vba.prefetch_vm_bw[k],
4927                                                                                        mode_lib->vba.prefetch_row_bw[k],
4928                                                                                        dml_max(mode_lib->vba.ReadBandwidth[k],
4929                                                                                        mode_lib->vba.RequiredPrefetchPixelDataBWLuma[i][j][k])
4930                                                                                        + mode_lib->vba.meta_row_bw[k] + mode_lib->vba.dpte_row_bw[k]);
4931                                }
4932                                locals->BandwidthWithoutPrefetchSupported[i][0] = true;
4933                                if (mode_lib->vba.MaximumReadBandwidthWithoutPrefetch > locals->ReturnBWPerState[i][0]) {
4934                                        locals->BandwidthWithoutPrefetchSupported[i][0] = false;
4935                                }
4936
4937                                locals->PrefetchSupported[i][j] = true;
4938                                if (mode_lib->vba.MaximumReadBandwidthWithPrefetch > locals->ReturnBWPerState[i][0]) {
4939                                        locals->PrefetchSupported[i][j] = false;
4940                                }
4941                                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4942                                        if (locals->LineTimesForPrefetch[k] < 2.0
4943                                                        || locals->LinesForMetaPTE[k] >= 8.0
4944                                                        || locals->LinesForMetaAndDPTERow[k] >= 16.0
4945                                                        || mode_lib->vba.IsErrorResult[i][j][k] == true) {
4946                                                locals->PrefetchSupported[i][j] = false;
4947                                        }
4948                                }
4949                                locals->VRatioInPrefetchSupported[i][j] = true;
4950                                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4951                                        if (locals->VRatioPreY[i][j][k] > 4.0
4952                                                        || locals->VRatioPreC[i][j][k] > 4.0
4953                                                        || mode_lib->vba.IsErrorResult[i][j][k] == true) {
4954                                                locals->VRatioInPrefetchSupported[i][j] = false;
4955                                        }
4956                                }
4957                        } while ((locals->PrefetchSupported[i][j] != true || locals->VRatioInPrefetchSupported[i][j] != true)
4958                                        && mode_lib->vba.NextPrefetchMode < mode_lib->vba.MaxPrefetchMode);
4959
4960                        if (mode_lib->vba.PrefetchSupported[i][j] == true
4961                                        && mode_lib->vba.VRatioInPrefetchSupported[i][j] == true) {
4962                                mode_lib->vba.BandwidthAvailableForImmediateFlip =
4963                                                mode_lib->vba.ReturnBWPerState[i][0];
4964                                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4965                                        mode_lib->vba.BandwidthAvailableForImmediateFlip =
4966                                                        mode_lib->vba.BandwidthAvailableForImmediateFlip
4967                                                                        - mode_lib->vba.cursor_bw[k]
4968                                                                        - dml_max(
4969                                                                                        mode_lib->vba.ReadBandwidth[k] + mode_lib->vba.qual_row_bw[k],
4970                                                                                        mode_lib->vba.PrefetchBW[k]);
4971                                }
4972                                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4973                                        mode_lib->vba.ImmediateFlipBytes[k] = 0.0;
4974                                        if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8
4975                                                        && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) {
4976                                                mode_lib->vba.ImmediateFlipBytes[k] =
4977                                                                mode_lib->vba.PDEAndMetaPTEBytesPerFrame[0][0][k]
4978                                                                                + mode_lib->vba.MetaRowBytes[0][0][k]
4979                                                                                + mode_lib->vba.DPTEBytesPerRow[0][0][k];
4980                                        }
4981                                }
4982                                mode_lib->vba.TotImmediateFlipBytes = 0.0;
4983                                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4984                                        if ((mode_lib->vba.SourcePixelFormat[k] != dm_420_8
4985                                                        && mode_lib->vba.SourcePixelFormat[k] != dm_420_10)) {
4986                                                mode_lib->vba.TotImmediateFlipBytes =
4987                                                                mode_lib->vba.TotImmediateFlipBytes
4988                                                                                + mode_lib->vba.ImmediateFlipBytes[k];
4989                                        }
4990                                }
4991
4992                                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
4993                                        CalculateFlipSchedule(
4994                                                        mode_lib,
4995                                                        mode_lib->vba.ExtraLatency,
4996                                                        mode_lib->vba.UrgentLatencyPixelDataOnly,
4997                                                        mode_lib->vba.GPUVMMaxPageTableLevels,
4998                                                        mode_lib->vba.GPUVMEnable,
4999                                                        mode_lib->vba.BandwidthAvailableForImmediateFlip,
5000                                                        mode_lib->vba.TotImmediateFlipBytes,

5001                                                        mode_lib->vba.SourcePixelFormat[k],
5002                                                        mode_lib->vba.ImmediateFlipBytes[k],
5003                                                        mode_lib->vba.HTotal[k]
5004                                                                        / mode_lib->vba.PixelClock[k],
5005                                                        mode_lib->vba.VRatio[k],
5006                                                        mode_lib->vba.Tno_bw[k],
5007                                                        mode_lib->vba.PDEAndMetaPTEBytesPerFrame[0][0][k],
5008                                                        mode_lib->vba.MetaRowBytes[0][0][k],
5009                                                        mode_lib->vba.DPTEBytesPerRow[0][0][k],
5010                                                        mode_lib->vba.DCCEnable[k],
5011                                                        mode_lib->vba.dpte_row_height[k],
5012                                                        mode_lib->vba.meta_row_height[k],
5013                                                        mode_lib->vba.qual_row_bw[k],
5014                                                        &mode_lib->vba.DestinationLinesToRequestVMInImmediateFlip[k],
5015                                                        &mode_lib->vba.DestinationLinesToRequestRowInImmediateFlip[k],
5016                                                        &mode_lib->vba.final_flip_bw[k],
5017                                                        &mode_lib->vba.ImmediateFlipSupportedForPipe[k]);
5018                                }
5019                                mode_lib->vba.total_dcn_read_bw_with_flip = 0.0;
5020                                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
5021                                        mode_lib->vba.total_dcn_read_bw_with_flip =
5022                                                        mode_lib->vba.total_dcn_read_bw_with_flip
5023                                                                        + mode_lib->vba.cursor_bw[k]
5024                                                                        + dml_max3(
5025                                                                                        mode_lib->vba.prefetch_vm_bw[k],
5026                                                                                        mode_lib->vba.prefetch_row_bw[k],
5027                                                                                        mode_lib->vba.final_flip_bw[k]
5028                                                                                                        + dml_max(
5029                                                                                                                        mode_lib->vba.ReadBandwidth[k],
5030                                                                                                                        mode_lib->vba.RequiredPrefetchPixelDataBWLuma[i][j][k]));
5031                                }
5032                                mode_lib->vba.ImmediateFlipSupportedForState[i][j] = true;
5033                                if (mode_lib->vba.total_dcn_read_bw_with_flip
5034                                                > mode_lib->vba.ReturnBWPerState[i][0]) {
5035                                        mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false;
5036                                }
5037                                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
5038                                        if (mode_lib->vba.ImmediateFlipSupportedForPipe[k] == false) {
5039                                                mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false;
5040                                        }
5041                                }
5042                        } else {
5043                                mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false;
5044                        }
5045                }
5046        }
5047
5048        /*Vertical Active BW support*/
5049        for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
5050                mode_lib->vba.MaxTotalVerticalActiveAvailableBandwidth[i][0] = dml_min(mode_lib->vba.ReturnBusWidth *
5051                                mode_lib->vba.DCFCLKPerState[i], mode_lib->vba.FabricAndDRAMBandwidthPerState[i] * 1000) *
5052                                mode_lib->vba.MaxAveragePercentOfIdealDRAMBWDisplayCanUseInNormalSystemOperation / 100;
5053                if (mode_lib->vba.MaxTotalVActiveRDBandwidth <= mode_lib->vba.MaxTotalVerticalActiveAvailableBandwidth[i][0])
5054                        mode_lib->vba.TotalVerticalActiveBandwidthSupport[i][0] = true;
5055                else
5056                        mode_lib->vba.TotalVerticalActiveBandwidthSupport[i][0] = false;
5057        }
5058
5059        /*PTE Buffer Size Check*/
5060
5061        for (i = 0; i <= mode_lib->vba.soc.num_states; i++) {
5062                for (j = 0; j < 2; j++) {
5063                        locals->PTEBufferSizeNotExceeded[i][j] = true;
5064                        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
5065                                if (locals->PTEBufferSizeNotExceededY[i][j][k] == false
5066                                                || locals->PTEBufferSizeNotExceededC[i][j][k] == false) {
5067                                        locals->PTEBufferSizeNotExceeded[i][j] = false;
5068                                }
5069                        }
5070                }
5071        }
5072        /*Cursor Support Check*/
5073        mode_lib->vba.CursorSupport = true;
5074        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
5075                for (j = 0; j < 2; j++) {
5076                        if (mode_lib->vba.CursorWidth[k][j] > 0.0) {
5077                                if (dml_floor(
5078                                                dml_floor(
5079                                                                mode_lib->vba.CursorBufferSize
5080                                                                                - mode_lib->vba.CursorChunkSize,
5081                                                                mode_lib->vba.CursorChunkSize) * 1024.0
5082                                                                / (mode_lib->vba.CursorWidth[k][j]
5083                                                                                * mode_lib->vba.CursorBPP[k][j]
5084                                                                                / 8.0),
5085                                                1.0)
5086                                                * (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k])
5087                                                / mode_lib->vba.VRatio[k] < mode_lib->vba.UrgentLatencyPixelDataOnly
5088                                                || (mode_lib->vba.CursorBPP[k][j] == 64.0
5089                                                                && mode_lib->vba.Cursor64BppSupport == false)) {
5090                                        mode_lib->vba.CursorSupport = false;
5091                                }
5092                        }
5093                }
5094        }
5095        /*Valid Pitch Check*/
5096
5097        mode_lib->vba.PitchSupport = true;
5098        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
5099                locals->AlignedYPitch[k] = dml_ceil(
5100                                dml_max(mode_lib->vba.PitchY[k], mode_lib->vba.ViewportWidth[k]),
5101                                locals->MacroTileWidthY[k]);
5102                if (locals->AlignedYPitch[k] > mode_lib->vba.PitchY[k]) {
5103                        mode_lib->vba.PitchSupport = false;
5104                }
5105                if (mode_lib->vba.DCCEnable[k] == true) {
5106                        locals->AlignedDCCMetaPitch[k] = dml_ceil(
5107                                        dml_max(
5108                                                        mode_lib->vba.DCCMetaPitchY[k],
5109                                                        mode_lib->vba.ViewportWidth[k]),
5110                                        64.0 * locals->Read256BlockWidthY[k]);
5111                } else {
5112                        locals->AlignedDCCMetaPitch[k] = mode_lib->vba.DCCMetaPitchY[k];
5113                }
5114                if (locals->AlignedDCCMetaPitch[k] > mode_lib->vba.DCCMetaPitchY[k]) {
5115                        mode_lib->vba.PitchSupport = false;
5116                }
5117                if (mode_lib->vba.SourcePixelFormat[k] != dm_444_64
5118                                && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
5119                                && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
5120                                && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
5121                                && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8) {
5122                        locals->AlignedCPitch[k] = dml_ceil(
5123                                        dml_max(
5124                                                        mode_lib->vba.PitchC[k],
5125                                                        mode_lib->vba.ViewportWidth[k] / 2.0),
5126                                        locals->MacroTileWidthC[k]);
5127                } else {
5128                        locals->AlignedCPitch[k] = mode_lib->vba.PitchC[k];
5129                }
5130                if (locals->AlignedCPitch[k] > mode_lib->vba.PitchC[k]) {
5131                        mode_lib->vba.PitchSupport = false;
5132                }
5133        }
5134        /*Mode Support, Voltage State and SOC Configuration*/
5135
5136        for (i = mode_lib->vba.soc.num_states; i >= 0; i--) {
5137                for (j = 0; j < 2; j++) {
5138                        enum dm_validation_status status = DML_VALIDATION_OK;
5139
5140                        if (mode_lib->vba.ScaleRatioAndTapsSupport != true) {
5141                                status = DML_FAIL_SCALE_RATIO_TAP;
5142                        } else if (mode_lib->vba.SourceFormatPixelAndScanSupport != true) {
5143                                status = DML_FAIL_SOURCE_PIXEL_FORMAT;
5144                        } else if (locals->ViewportSizeSupport[i][0] != true) {
5145                                status = DML_FAIL_VIEWPORT_SIZE;
5146                        } else if (locals->DIOSupport[i] != true) {
5147                                status = DML_FAIL_DIO_SUPPORT;
5148                        } else if (locals->NotEnoughDSCUnits[i] != false) {
5149                                status = DML_FAIL_NOT_ENOUGH_DSC;
5150                        } else if (locals->DSCCLKRequiredMoreThanSupported[i] != false) {
5151                                status = DML_FAIL_DSC_CLK_REQUIRED;
5152                        } else if (locals->UrgentLatencySupport[i][j] != true) {
5153                                status = DML_FAIL_URGENT_LATENCY;
5154                        } else if (locals->ROBSupport[i][0] != true) {
5155                                status = DML_FAIL_REORDERING_BUFFER;
5156                        } else if (locals->DISPCLK_DPPCLK_Support[i][j] != true) {
5157                                status = DML_FAIL_DISPCLK_DPPCLK;
5158                        } else if (locals->TotalAvailablePipesSupport[i][j] != true) {
5159                                status = DML_FAIL_TOTAL_AVAILABLE_PIPES;
5160                        } else if (mode_lib->vba.NumberOfOTGSupport != true) {
5161                                status = DML_FAIL_NUM_OTG;
5162                        } else if (mode_lib->vba.WritebackModeSupport != true) {
5163                                status = DML_FAIL_WRITEBACK_MODE;
5164                        } else if (mode_lib->vba.WritebackLatencySupport != true) {
5165                                status = DML_FAIL_WRITEBACK_LATENCY;
5166                        } else if (mode_lib->vba.WritebackScaleRatioAndTapsSupport != true) {
5167                                status = DML_FAIL_WRITEBACK_SCALE_RATIO_TAP;
5168                        } else if (mode_lib->vba.CursorSupport != true) {
5169                                status = DML_FAIL_CURSOR_SUPPORT;
5170                        } else if (mode_lib->vba.PitchSupport != true) {
5171                                status = DML_FAIL_PITCH_SUPPORT;
5172                        } else if (locals->PrefetchSupported[i][j] != true) {
5173                                status = DML_FAIL_PREFETCH_SUPPORT;
5174                        } else if (locals->TotalVerticalActiveBandwidthSupport[i][0] != true) {
5175                                status = DML_FAIL_TOTAL_V_ACTIVE_BW;
5176                        } else if (locals->VRatioInPrefetchSupported[i][j] != true) {
5177                                status = DML_FAIL_V_RATIO_PREFETCH;
5178                        } else if (locals->PTEBufferSizeNotExceeded[i][j] != true) {
5179                                status = DML_FAIL_PTE_BUFFER_SIZE;
5180                        } else if (mode_lib->vba.NonsupportedDSCInputBPC != false) {
5181                                status = DML_FAIL_DSC_INPUT_BPC;
5182                        }
5183
5184                        if (status == DML_VALIDATION_OK) {
5185                                locals->ModeSupport[i][j] = true;
5186                        } else {
5187                                locals->ModeSupport[i][j] = false;
5188                        }
5189                        locals->ValidationStatus[i] = status;
5190                }
5191        }
5192        {
5193                unsigned int MaximumMPCCombine = 0;
5194                mode_lib->vba.VoltageLevel = mode_lib->vba.soc.num_states + 1;
5195                for (i = mode_lib->vba.VoltageOverrideLevel; i <= mode_lib->vba.soc.num_states; i++) {
5196                        if (locals->ModeSupport[i][0] == true || locals->ModeSupport[i][1] == true) {
5197                                mode_lib->vba.VoltageLevel = i;
5198                                if (locals->ModeSupport[i][1] == true && (locals->ModeSupport[i][0] == false
5199                                                || mode_lib->vba.WhenToDoMPCCombine == dm_mpc_always_when_possible)) {
5200                                        MaximumMPCCombine = 1;
5201                                } else {
5202                                        MaximumMPCCombine = 0;
5203                                }
5204                                break;
5205                        }
5206                }
5207                mode_lib->vba.ImmediateFlipSupport =
5208                        locals->ImmediateFlipSupportedForState[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
5209                for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
5210                        mode_lib->vba.DPPPerPlane[k] = locals->NoOfDPP[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
5211                        locals->DPPCLK[k] = locals->RequiredDPPCLK[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
5212                }
5213                mode_lib->vba.DISPCLK = locals->RequiredDISPCLK[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
5214                mode_lib->vba.maxMpcComb = MaximumMPCCombine;
5215        }
5216        mode_lib->vba.DCFCLK = mode_lib->vba.DCFCLKPerState[mode_lib->vba.VoltageLevel];
5217        mode_lib->vba.DRAMSpeed = mode_lib->vba.DRAMSpeedPerState[mode_lib->vba.VoltageLevel];
5218        mode_lib->vba.FabricClock = mode_lib->vba.FabricClockPerState[mode_lib->vba.VoltageLevel];
5219        mode_lib->vba.SOCCLK = mode_lib->vba.SOCCLKPerState[mode_lib->vba.VoltageLevel];
5220        mode_lib->vba.ReturnBW = locals->ReturnBWPerState[mode_lib->vba.VoltageLevel][0];
5221        mode_lib->vba.FabricAndDRAMBandwidth = locals->FabricAndDRAMBandwidthPerState[mode_lib->vba.VoltageLevel];
5222        for (k = 0; k <= mode_lib->vba.NumberOfActivePlanes - 1; k++) {
5223                if (mode_lib->vba.BlendingAndTiming[k] == k) {
5224                        mode_lib->vba.ODMCombineEnabled[k] =
5225                                        locals->ODMCombineEnablePerState[mode_lib->vba.VoltageLevel][k];
5226                } else {
5227                        mode_lib->vba.ODMCombineEnabled[k] = 0;
5228                }
5229                mode_lib->vba.DSCEnabled[k] =
5230                                locals->RequiresDSC[mode_lib->vba.VoltageLevel][k];
5231                mode_lib->vba.OutputBpp[k] =
5232                                locals->OutputBppPerState[mode_lib->vba.VoltageLevel][k];
5233        }
5234}
5235