drivers/gpu/drm/amd/display/dc/dml/dcn32/display_mode_vba_32.c

   1 /*
   2  * Copyright 2022 Advanced Micro Devices, Inc. All rights reserved.
   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 "dc.h"
  27 #include "dc_link.h"
  28 #include "../display_mode_lib.h"
  29 #include "display_mode_vba_32.h"
  30 #include "../dml_inline_defs.h"
  31 #include "display_mode_vba_util_32.h"
  32
  33 void dml32_recalculate(struct display_mode_lib *mode_lib);
  34 static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(
  35                 struct display_mode_lib *mode_lib);
  36 void dml32_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_lib);
  37
  38 void dml32_recalculate(struct display_mode_lib *mode_lib)
  39 {
  40         ModeSupportAndSystemConfiguration(mode_lib);
  41
  42         dml32_CalculateMaxDETAndMinCompressedBufferSize(mode_lib->vba.ConfigReturnBufferSizeInKByte,
  43                         mode_lib->vba.ROBBufferSizeInKByte,
  44                         DC__NUM_DPP,
  45                         false, //mode_lib->vba.override_setting.nomDETInKByteOverrideEnable,
  46                         0, //mode_lib->vba.override_setting.nomDETInKByteOverrideValue,
  47
  48                         /* Output */
  49                         &mode_lib->vba.MaxTotalDETInKByte, &mode_lib->vba.nomDETInKByte,
  50                         &mode_lib->vba.MinCompressedBufferSizeInKByte);
  51
  52         PixelClockAdjustmentForProgressiveToInterlaceUnit(mode_lib);
  53 #ifdef __DML_VBA_DEBUG__
  54         dml_print("DML::%s: Calling DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation\n", __func__);
  55 #endif
  56         DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(mode_lib);
  57 }
  58
  59 static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation(
  60                 struct display_mode_lib *mode_lib)
  61 {
  62         struct vba_vars_st *v = &mode_lib->vba;
  63         unsigned int j, k;
  64         bool ImmediateFlipRequirementFinal;
  65         int iteration;
  66         double MaxTotalRDBandwidth;
  67         unsigned int NextPrefetchMode;
  68         double MaxTotalRDBandwidthNoUrgentBurst = 0.0;
  69         bool DestinationLineTimesForPrefetchLessThan2 = false;
  70         bool VRatioPrefetchMoreThanMax = false;
  71         double TWait;
  72         double TotalWRBandwidth = 0;
  73         double WRBandwidth = 0;
  74
  75 #ifdef __DML_VBA_DEBUG__
  76         dml_print("DML::%s: --- START ---\n", __func__);
  77         dml_print("DML::%s: mode_lib->vba.PrefetchMode = %d\n", __func__, mode_lib->vba.PrefetchMode);
  78         dml_print("DML::%s: mode_lib->vba.ImmediateFlipSupport = %d\n", __func__, mode_lib->vba.ImmediateFlipSupport);
  79         dml_print("DML::%s: mode_lib->vba.VoltageLevel = %d\n", __func__, mode_lib->vba.VoltageLevel);
  80 #endif
  81
  82         v->WritebackDISPCLK = 0.0;
  83         v->GlobalDPPCLK = 0.0;
  84
  85         // DISPCLK and DPPCLK Calculation
  86         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
  87                 if (mode_lib->vba.WritebackEnable[k]) {
  88                         v->WritebackDISPCLK = dml_max(v->WritebackDISPCLK,
  89                                         dml32_CalculateWriteBackDISPCLK(
  90                                                         mode_lib->vba.WritebackPixelFormat[k],
  91                                                         mode_lib->vba.PixelClock[k], mode_lib->vba.WritebackHRatio[k],
  92                                                         mode_lib->vba.WritebackVRatio[k],
  93                                                         mode_lib->vba.WritebackHTaps[k],
  94                                                         mode_lib->vba.WritebackVTaps[k],
  95                                                         mode_lib->vba.WritebackSourceWidth[k],
  96                                                         mode_lib->vba.WritebackDestinationWidth[k],
  97                                                         mode_lib->vba.HTotal[k], mode_lib->vba.WritebackLineBufferSize,
  98                                                         mode_lib->vba.DISPCLKDPPCLKVCOSpeed));
  99                 }
 100         }
 101
 102         v->DISPCLK_calculated = v->WritebackDISPCLK;
 103
 104         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 105                 if (mode_lib->vba.BlendingAndTiming[k] == k) {
 106                         v->DISPCLK_calculated = dml_max(v->DISPCLK_calculated,
 107                                         dml32_CalculateRequiredDispclk(
 108                                                         mode_lib->vba.ODMCombineEnabled[k],
 109                                                         mode_lib->vba.PixelClock[k],
 110                                                         mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
 111                                                         mode_lib->vba.DISPCLKRampingMargin,
 112                                                         mode_lib->vba.DISPCLKDPPCLKVCOSpeed,
 113                                                         mode_lib->vba.MaxDppclk[v->soc.num_states - 1]));
 114                 }
 115         }
 116
 117         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 118                 dml32_CalculateSinglePipeDPPCLKAndSCLThroughput(mode_lib->vba.HRatio[k],
 119                                 mode_lib->vba.HRatioChroma[k],
 120                                 mode_lib->vba.VRatio[k],
 121                                 mode_lib->vba.VRatioChroma[k],
 122                                 mode_lib->vba.MaxDCHUBToPSCLThroughput,
 123                                 mode_lib->vba.MaxPSCLToLBThroughput,
 124                                 mode_lib->vba.PixelClock[k],
 125                                 mode_lib->vba.SourcePixelFormat[k],
 126                                 mode_lib->vba.htaps[k],
 127                                 mode_lib->vba.HTAPsChroma[k],
 128                                 mode_lib->vba.vtaps[k],
 129                                 mode_lib->vba.VTAPsChroma[k],
 130
 131                                 /* Output */
 132                                 &v->PSCL_THROUGHPUT_LUMA[k], &v->PSCL_THROUGHPUT_CHROMA[k],
 133                                 &v->DPPCLKUsingSingleDPP[k]);
 134         }
 135
 136         dml32_CalculateDPPCLK(mode_lib->vba.NumberOfActiveSurfaces, mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
 137                         mode_lib->vba.DISPCLKDPPCLKVCOSpeed, v->DPPCLKUsingSingleDPP, mode_lib->vba.DPPPerPlane,
 138                         /* Output */
 139                         &v->GlobalDPPCLK, v->DPPCLK);
 140
 141         for (k = 0; k < v->NumberOfActiveSurfaces; ++k) {
 142                 v->DPPCLK_calculated[k] = v->DPPCLK[k];
 143         }
 144
 145         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 146                 dml32_CalculateBytePerPixelAndBlockSizes(
 147                                 mode_lib->vba.SourcePixelFormat[k],
 148                                 mode_lib->vba.SurfaceTiling[k],
 149
 150                                 /* Output */
 151                                 &v->BytePerPixelY[k],
 152                                 &v->BytePerPixelC[k],
 153                                 &v->BytePerPixelDETY[k],
 154                                 &v->BytePerPixelDETC[k],
 155                                 &v->BlockHeight256BytesY[k],
 156                                 &v->BlockHeight256BytesC[k],
 157                                 &v->BlockWidth256BytesY[k],
 158                                 &v->BlockWidth256BytesC[k],
 159                                 &v->BlockHeightY[k],
 160                                 &v->BlockHeightC[k],
 161                                 &v->BlockWidthY[k],
 162                                 &v->BlockWidthC[k]);
 163         }
 164
 165 #ifdef __DML_VBA_DEBUG__
 166         dml_print("DML::%s: %d\n", __func__, __LINE__);
 167 #endif
 168         dml32_CalculateSwathWidth(
 169                         false,  // ForceSingleDPP
 170                         mode_lib->vba.NumberOfActiveSurfaces,
 171                         mode_lib->vba.SourcePixelFormat,
 172                         mode_lib->vba.SourceRotation,
 173                         mode_lib->vba.ViewportStationary,
 174                         mode_lib->vba.ViewportWidth,
 175                         mode_lib->vba.ViewportHeight,
 176                         mode_lib->vba.ViewportXStartY,
 177                         mode_lib->vba.ViewportYStartY,
 178                         mode_lib->vba.ViewportXStartC,
 179                         mode_lib->vba.ViewportYStartC,
 180                         mode_lib->vba.SurfaceWidthY,
 181                         mode_lib->vba.SurfaceWidthC,
 182                         mode_lib->vba.SurfaceHeightY,
 183                         mode_lib->vba.SurfaceHeightC,
 184                         mode_lib->vba.ODMCombineEnabled,
 185                         v->BytePerPixelY,
 186                         v->BytePerPixelC,
 187                         v->BlockHeight256BytesY,
 188                         v->BlockHeight256BytesC,
 189                         v->BlockWidth256BytesY,
 190                         v->BlockWidth256BytesC,
 191                         mode_lib->vba.BlendingAndTiming,
 192                         mode_lib->vba.HActive,
 193                         mode_lib->vba.HRatio,
 194                         mode_lib->vba.DPPPerPlane,
 195
 196                         /* Output */
 197                         v->SwathWidthSingleDPPY, v->SwathWidthSingleDPPC, v->SwathWidthY, v->SwathWidthC,
 198                         v->dummy_vars
 199                                 .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 200                                 .dummy_integer_array[0], // Integer             MaximumSwathHeightY[]
 201                         v->dummy_vars
 202                                 .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 203                                 .dummy_integer_array[1], // Integer             MaximumSwathHeightC[]
 204                         v->swath_width_luma_ub, v->swath_width_chroma_ub);
 205
 206         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 207                 v->ReadBandwidthSurfaceLuma[k] = v->SwathWidthSingleDPPY[k] * v->BytePerPixelY[k]
 208                                 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k];
 209                 v->ReadBandwidthSurfaceChroma[k] = v->SwathWidthSingleDPPC[k] * v->BytePerPixelC[k]
 210                                 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k])
 211                                 * mode_lib->vba.VRatioChroma[k];
 212 #ifdef __DML_VBA_DEBUG__
 213                 dml_print("DML::%s: ReadBandwidthSurfaceLuma[%i] = %fBps\n",
 214                                 __func__, k, v->ReadBandwidthSurfaceLuma[k]);
 215                 dml_print("DML::%s: ReadBandwidthSurfaceChroma[%i] = %fBps\n",
 216                                 __func__, k, v->ReadBandwidthSurfaceChroma[k]);
 217 #endif
 218         }
 219
 220         {
 221                 // VBA_DELTA
 222                 // Calculate DET size, swath height
 223                 dml32_CalculateSwathAndDETConfiguration(
 224                                 &v->dummy_vars.dml32_CalculateSwathAndDETConfiguration,
 225                                 mode_lib->vba.DETSizeOverride,
 226                                 mode_lib->vba.UsesMALLForPStateChange,
 227                                 mode_lib->vba.ConfigReturnBufferSizeInKByte,
 228                                 mode_lib->vba.MaxTotalDETInKByte,
 229                                 mode_lib->vba.MinCompressedBufferSizeInKByte,
 230                                 false, /* ForceSingleDPP */
 231                                 mode_lib->vba.NumberOfActiveSurfaces,
 232                                 mode_lib->vba.nomDETInKByte,
 233                                 mode_lib->vba.UseUnboundedRequesting,
 234                                 mode_lib->vba.DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment,
 235                                 mode_lib->vba.ip.pixel_chunk_size_kbytes,
 236                                 mode_lib->vba.ip.rob_buffer_size_kbytes,
 237                                 mode_lib->vba.CompressedBufferSegmentSizeInkByteFinal,
 238                                 v->dummy_vars
 239                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 240                                         .dummy_output_encoder_array, /* output_encoder_class Output[] */
 241                                 v->ReadBandwidthSurfaceLuma,
 242                                 v->ReadBandwidthSurfaceChroma,
 243                                 v->dummy_vars
 244                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 245                                         .dummy_single_array[0], /* Single MaximumSwathWidthLuma[] */
 246                                 v->dummy_vars
 247                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 248                                         .dummy_single_array[1], /* Single MaximumSwathWidthChroma[] */
 249                                 mode_lib->vba.SourceRotation,
 250                                 mode_lib->vba.ViewportStationary,
 251                                 mode_lib->vba.SourcePixelFormat,
 252                                 mode_lib->vba.SurfaceTiling,
 253                                 mode_lib->vba.ViewportWidth,
 254                                 mode_lib->vba.ViewportHeight,
 255                                 mode_lib->vba.ViewportXStartY,
 256                                 mode_lib->vba.ViewportYStartY,
 257                                 mode_lib->vba.ViewportXStartC,
 258                                 mode_lib->vba.ViewportYStartC,
 259                                 mode_lib->vba.SurfaceWidthY,
 260                                 mode_lib->vba.SurfaceWidthC,
 261                                 mode_lib->vba.SurfaceHeightY,
 262                                 mode_lib->vba.SurfaceHeightC,
 263                                 v->BlockHeight256BytesY,
 264                                 v->BlockHeight256BytesC,
 265                                 v->BlockWidth256BytesY,
 266                                 v->BlockWidth256BytesC,
 267                                 mode_lib->vba.ODMCombineEnabled,
 268                                 mode_lib->vba.BlendingAndTiming,
 269                                 v->BytePerPixelY,
 270                                 v->BytePerPixelC,
 271                                 v->BytePerPixelDETY,
 272                                 v->BytePerPixelDETC,
 273                                 mode_lib->vba.HActive,
 274                                 mode_lib->vba.HRatio,
 275                                 mode_lib->vba.HRatioChroma,
 276                                 mode_lib->vba.DPPPerPlane,
 277
 278                                 /* Output */
 279                                 v->dummy_vars
 280                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 281                                         .dummy_long_array[0], /* Long swath_width_luma_ub[] */
 282                                 v->dummy_vars
 283                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 284                                         .dummy_long_array[1], /* Long swath_width_chroma_ub[] */
 285                                 v->dummy_vars
 286                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 287                                         .dummy_double_array[0], /* Long SwathWidth[] */
 288                                 v->dummy_vars
 289                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 290                                         .dummy_double_array[1], /* Long SwathWidthChroma[] */
 291                                 mode_lib->vba.SwathHeightY,
 292                                 mode_lib->vba.SwathHeightC,
 293                                 mode_lib->vba.DETBufferSizeInKByte,
 294                                 mode_lib->vba.DETBufferSizeY,
 295                                 mode_lib->vba.DETBufferSizeC,
 296                                 &v->UnboundedRequestEnabled,
 297                                 &v->CompressedBufferSizeInkByte,
 298                                 &v->CompBufReservedSpaceKBytes,
 299                                 &v->dummy_vars
 300                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 301                                         .dummy_boolean,       /* bool *CompBufReservedSpaceNeedAjustment */
 302                                 v->dummy_vars
 303                                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 304                                         .dummy_boolean_array, /* bool ViewportSizeSupportPerSurface[] */
 305                                 &v->dummy_vars
 306                                          .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 307                                          .dummy_boolean); /* bool *ViewportSizeSupport */
 308         }
 309
 310         v->CompBufReservedSpaceZs     = v->CompBufReservedSpaceKBytes * 1024.0 / 256.0;
 311         v->CompBufReservedSpace64B    = v->CompBufReservedSpaceKBytes * 1024.0 / 64.0;
 312
 313         // DCFCLK Deep Sleep
 314         dml32_CalculateDCFCLKDeepSleep(
 315                         mode_lib->vba.NumberOfActiveSurfaces,
 316                         v->BytePerPixelY,
 317                         v->BytePerPixelC,
 318                         mode_lib->vba.VRatio,
 319                         mode_lib->vba.VRatioChroma,
 320                         v->SwathWidthY,
 321                         v->SwathWidthC,
 322                         mode_lib->vba.DPPPerPlane,
 323                         mode_lib->vba.HRatio,
 324                         mode_lib->vba.HRatioChroma,
 325                         mode_lib->vba.PixelClock,
 326                         v->PSCL_THROUGHPUT_LUMA,
 327                         v->PSCL_THROUGHPUT_CHROMA,
 328                         mode_lib->vba.DPPCLK,
 329                         v->ReadBandwidthSurfaceLuma,
 330                         v->ReadBandwidthSurfaceChroma,
 331                         mode_lib->vba.ReturnBusWidth,
 332
 333                         /* Output */
 334                         &v->DCFCLKDeepSleep);
 335
 336         // DSCCLK
 337         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 338                 if ((mode_lib->vba.BlendingAndTiming[k] != k) || !mode_lib->vba.DSCEnabled[k]) {
 339                         v->DSCCLK_calculated[k] = 0.0;
 340                 } else {
 341                         if (mode_lib->vba.OutputFormat[k] == dm_420)
 342                                 mode_lib->vba.DSCFormatFactor = 2;
 343                         else if (mode_lib->vba.OutputFormat[k] == dm_444)
 344                                 mode_lib->vba.DSCFormatFactor = 1;
 345                         else if (mode_lib->vba.OutputFormat[k] == dm_n422)
 346                                 mode_lib->vba.DSCFormatFactor = 2;
 347                         else
 348                                 mode_lib->vba.DSCFormatFactor = 1;
 349                         if (mode_lib->vba.ODMCombineEnabled[k] == dm_odm_combine_mode_4to1)
 350                                 v->DSCCLK_calculated[k] = mode_lib->vba.PixelClockBackEnd[k] / 12
 351                                                 / mode_lib->vba.DSCFormatFactor
 352                                                 / (1 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100);
 353                         else if (mode_lib->vba.ODMCombineEnabled[k] == dm_odm_combine_mode_2to1)
 354                                 v->DSCCLK_calculated[k] = mode_lib->vba.PixelClockBackEnd[k] / 6
 355                                                 / mode_lib->vba.DSCFormatFactor
 356                                                 / (1 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100);
 357                         else
 358                                 v->DSCCLK_calculated[k] = mode_lib->vba.PixelClockBackEnd[k] / 3
 359                                                 / mode_lib->vba.DSCFormatFactor
 360                                                 / (1 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100);
 361                 }
 362         }
 363
 364         // DSC Delay
 365         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 366                 v->DSCDelay[k] = dml32_DSCDelayRequirement(mode_lib->vba.DSCEnabled[k],
 367                                 mode_lib->vba.ODMCombineEnabled[k], mode_lib->vba.DSCInputBitPerComponent[k],
 368                                 mode_lib->vba.OutputBpp[k], mode_lib->vba.HActive[k], mode_lib->vba.HTotal[k],
 369                                 mode_lib->vba.NumberOfDSCSlices[k], mode_lib->vba.OutputFormat[k],
 370                                 mode_lib->vba.Output[k], mode_lib->vba.PixelClock[k],
 371                                 mode_lib->vba.PixelClockBackEnd[k]);
 372         }
 373
 374         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
 375                 for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) // NumberOfSurfaces
 376                         if (j != k && mode_lib->vba.BlendingAndTiming[k] == j && mode_lib->vba.DSCEnabled[j])
 377                                 v->DSCDelay[k] = v->DSCDelay[j];
 378
 379         //Immediate Flip
 380         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 381                 v->ImmediateFlipSupportedSurface[k] = mode_lib->vba.ImmediateFlipSupport
 382                                 && (mode_lib->vba.ImmediateFlipRequirement[k] != dm_immediate_flip_not_required);
 383         }
 384
 385         // Prefetch
 386         dml32_CalculateSurfaceSizeInMall(
 387                                 mode_lib->vba.NumberOfActiveSurfaces,
 388                                 mode_lib->vba.MALLAllocatedForDCNFinal,
 389                                 mode_lib->vba.UseMALLForStaticScreen,
 390                                 mode_lib->vba.DCCEnable,
 391                                 mode_lib->vba.ViewportStationary,
 392                                 mode_lib->vba.ViewportXStartY,
 393                                 mode_lib->vba.ViewportYStartY,
 394                                 mode_lib->vba.ViewportXStartC,
 395                                 mode_lib->vba.ViewportYStartC,
 396                                 mode_lib->vba.ViewportWidth,
 397                                 mode_lib->vba.ViewportHeight,
 398                                 v->BytePerPixelY,
 399                                 mode_lib->vba.ViewportWidthChroma,
 400                                 mode_lib->vba.ViewportHeightChroma,
 401                                 v->BytePerPixelC,
 402                                 mode_lib->vba.SurfaceWidthY,
 403                                 mode_lib->vba.SurfaceWidthC,
 404                                 mode_lib->vba.SurfaceHeightY,
 405                                 mode_lib->vba.SurfaceHeightC,
 406                                 v->BlockWidth256BytesY,
 407                                 v->BlockWidth256BytesC,
 408                                 v->BlockHeight256BytesY,
 409                                 v->BlockHeight256BytesC,
 410                                 v->BlockWidthY,
 411                                 v->BlockWidthC,
 412                                 v->BlockHeightY,
 413                                 v->BlockHeightC,
 414
 415                                 /* Output */
 416                                 v->SurfaceSizeInMALL,
 417                                 &v->dummy_vars.
 418                                 DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 419                                 .dummy_boolean2); /* Boolean *ExceededMALLSize */
 420
 421         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 422                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].PixelClock = mode_lib->vba.PixelClock[k];
 423                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].DPPPerSurface = mode_lib->vba.DPPPerPlane[k];
 424                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SourceRotation = mode_lib->vba.SourceRotation[k];
 425                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportHeight = mode_lib->vba.ViewportHeight[k];
 426                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportHeightChroma = mode_lib->vba.ViewportHeightChroma[k];
 427                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockWidth256BytesY = v->BlockWidth256BytesY[k];
 428                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockHeight256BytesY = v->BlockHeight256BytesY[k];
 429                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockWidth256BytesC = v->BlockWidth256BytesC[k];
 430                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockHeight256BytesC = v->BlockHeight256BytesC[k];
 431                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockWidthY = v->BlockWidthY[k];
 432                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockHeightY = v->BlockHeightY[k];
 433                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockWidthC = v->BlockWidthC[k];
 434                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BlockHeightC = v->BlockHeightC[k];
 435                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].InterlaceEnable = mode_lib->vba.Interlace[k];
 436                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].HTotal = mode_lib->vba.HTotal[k];
 437                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].DCCEnable = mode_lib->vba.DCCEnable[k];
 438                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SourcePixelFormat = mode_lib->vba.SourcePixelFormat[k];
 439                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SurfaceTiling = mode_lib->vba.SurfaceTiling[k];
 440                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BytePerPixelY = v->BytePerPixelY[k];
 441                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].BytePerPixelC = v->BytePerPixelC[k];
 442                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ProgressiveToInterlaceUnitInOPP = mode_lib->vba.ProgressiveToInterlaceUnitInOPP;
 443                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].VRatio = mode_lib->vba.VRatio[k];
 444                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].VRatioChroma = mode_lib->vba.VRatioChroma[k];
 445                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].VTaps = mode_lib->vba.vtaps[k];
 446                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].VTapsChroma = mode_lib->vba.VTAPsChroma[k];
 447                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].PitchY = mode_lib->vba.PitchY[k];
 448                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].DCCMetaPitchY = mode_lib->vba.DCCMetaPitchY[k];
 449                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].PitchC = mode_lib->vba.PitchC[k];
 450                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].DCCMetaPitchC = mode_lib->vba.DCCMetaPitchC[k];
 451                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportStationary = mode_lib->vba.ViewportStationary[k];
 452                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportXStart = mode_lib->vba.ViewportXStartY[k];
 453                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportYStart = mode_lib->vba.ViewportYStartY[k];
 454                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportXStartC = mode_lib->vba.ViewportXStartC[k];
 455                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].ViewportYStartC = mode_lib->vba.ViewportYStartC[k];
 456                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].FORCE_ONE_ROW_FOR_FRAME = mode_lib->vba.ForceOneRowForFrame[k];
 457                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SwathHeightY = mode_lib->vba.SwathHeightY[k];
 458                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters[k].SwathHeightC = mode_lib->vba.SwathHeightC[k];
 459         }
 460
 461         {
 462
 463                 dml32_CalculateVMRowAndSwath(
 464                                 &v->dummy_vars.dml32_CalculateVMRowAndSwath,
 465                                 mode_lib->vba.NumberOfActiveSurfaces,
 466                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.SurfaceParameters,
 467                                 v->SurfaceSizeInMALL,
 468                                 mode_lib->vba.PTEBufferSizeInRequestsLuma,
 469                                 mode_lib->vba.PTEBufferSizeInRequestsChroma,
 470                                 mode_lib->vba.DCCMetaBufferSizeBytes,
 471                                 mode_lib->vba.UseMALLForStaticScreen,
 472                                 mode_lib->vba.UsesMALLForPStateChange,
 473                                 mode_lib->vba.MALLAllocatedForDCNFinal,
 474                                 v->SwathWidthY,
 475                                 v->SwathWidthC,
 476                                 mode_lib->vba.GPUVMEnable,
 477                                 mode_lib->vba.HostVMEnable,
 478                                 mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
 479                                 mode_lib->vba.GPUVMMaxPageTableLevels,
 480                                 mode_lib->vba.GPUVMMinPageSizeKBytes,
 481                                 mode_lib->vba.HostVMMinPageSize,
 482
 483                                 /* Output */
 484                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean_array2[0],  // Boolean PTEBufferSizeNotExceeded[]
 485                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean_array2[1],  // Boolean DCCMetaBufferSizeNotExceeded[]
 486                                 v->dpte_row_width_luma_ub,
 487                                 v->dpte_row_width_chroma_ub,
 488                                 v->dpte_row_height,
 489                                 v->dpte_row_height_chroma,
 490                                 v->dpte_row_height_linear,
 491                                 v->dpte_row_height_linear_chroma,
 492                                 v->meta_req_width,
 493                                 v->meta_req_width_chroma,
 494                                 v->meta_req_height,
 495                                 v->meta_req_height_chroma,
 496                                 v->meta_row_width,
 497                                 v->meta_row_width_chroma,
 498                                 v->meta_row_height,
 499                                 v->meta_row_height_chroma,
 500                                 v->vm_group_bytes,
 501                                 v->dpte_group_bytes,
 502                                 v->PixelPTEReqWidthY,
 503                                 v->PixelPTEReqHeightY,
 504                                 v->PTERequestSizeY,
 505                                 v->PixelPTEReqWidthC,
 506                                 v->PixelPTEReqHeightC,
 507                                 v->PTERequestSizeC,
 508                                 v->dpde0_bytes_per_frame_ub_l,
 509                                 v->meta_pte_bytes_per_frame_ub_l,
 510                                 v->dpde0_bytes_per_frame_ub_c,
 511                                 v->meta_pte_bytes_per_frame_ub_c,
 512                                 v->PrefetchSourceLinesY,
 513                                 v->PrefetchSourceLinesC,
 514                                 v->VInitPreFillY, v->VInitPreFillC,
 515                                 v->MaxNumSwathY,
 516                                 v->MaxNumSwathC,
 517                                 v->meta_row_bw,
 518                                 v->dpte_row_bw,
 519                                 v->PixelPTEBytesPerRow,
 520                                 v->PDEAndMetaPTEBytesFrame,
 521                                 v->MetaRowByte,
 522                                 v->Use_One_Row_For_Frame,
 523                                 v->Use_One_Row_For_Frame_Flip,
 524                                 v->UsesMALLForStaticScreen,
 525                                 v->PTE_BUFFER_MODE,
 526                                 v->BIGK_FRAGMENT_SIZE);
 527         }
 528
 529
 530         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.ReorderBytes = mode_lib->vba.NumberOfChannels
 531                         * dml_max3(mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelDataOnly,
 532                                         mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelMixedWithVMData,
 533                                         mode_lib->vba.UrgentOutOfOrderReturnPerChannelVMDataOnly);
 534
 535         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.VMDataOnlyReturnBW = dml32_get_return_bw_mbps_vm_only(
 536                         &mode_lib->vba.soc,
 537                         mode_lib->vba.VoltageLevel,
 538                         mode_lib->vba.DCFCLK,
 539                         mode_lib->vba.FabricClock,
 540                         mode_lib->vba.DRAMSpeed);
 541
 542 #ifdef __DML_VBA_DEBUG__
 543         dml_print("DML::%s: mode_lib->vba.ReturnBusWidth = %f\n", __func__, mode_lib->vba.ReturnBusWidth);
 544         dml_print("DML::%s: mode_lib->vba.DCFCLK = %f\n", __func__, mode_lib->vba.DCFCLK);
 545         dml_print("DML::%s: mode_lib->vba.FabricClock = %f\n", __func__, mode_lib->vba.FabricClock);
 546         dml_print("DML::%s: mode_lib->vba.FabricDatapathToDCNDataReturn = %f\n", __func__,
 547                         mode_lib->vba.FabricDatapathToDCNDataReturn);
 548         dml_print("DML::%s: mode_lib->vba.PercentOfIdealSDPPortBWReceivedAfterUrgLatency = %f\n",
 549                         __func__, mode_lib->vba.PercentOfIdealSDPPortBWReceivedAfterUrgLatency);
 550         dml_print("DML::%s: mode_lib->vba.DRAMSpeed = %f\n", __func__, mode_lib->vba.DRAMSpeed);
 551         dml_print("DML::%s: mode_lib->vba.NumberOfChannels = %f\n", __func__, mode_lib->vba.NumberOfChannels);
 552         dml_print("DML::%s: mode_lib->vba.DRAMChannelWidth = %f\n", __func__, mode_lib->vba.DRAMChannelWidth);
 553         dml_print("DML::%s: mode_lib->vba.PercentOfIdealDRAMBWReceivedAfterUrgLatencyVMDataOnly = %f\n",
 554                         __func__, mode_lib->vba.PercentOfIdealDRAMBWReceivedAfterUrgLatencyVMDataOnly);
 555         dml_print("DML::%s: VMDataOnlyReturnBW = %f\n", __func__, VMDataOnlyReturnBW);
 556         dml_print("DML::%s: ReturnBW = %f\n", __func__, mode_lib->vba.ReturnBW);
 557 #endif
 558
 559         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.HostVMInefficiencyFactor = 1.0;
 560
 561         if (mode_lib->vba.GPUVMEnable && mode_lib->vba.HostVMEnable)
 562                 v->dummy_vars
 563                         .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 564                         .HostVMInefficiencyFactor =
 565                         mode_lib->vba.ReturnBW / v->dummy_vars
 566                                 .DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation
 567                                 .VMDataOnlyReturnBW;
 568
 569         mode_lib->vba.TotalDCCActiveDPP = 0;
 570         mode_lib->vba.TotalActiveDPP = 0;
 571         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 572                 mode_lib->vba.TotalActiveDPP = mode_lib->vba.TotalActiveDPP + mode_lib->vba.DPPPerPlane[k];
 573                 if (mode_lib->vba.DCCEnable[k])
 574                         mode_lib->vba.TotalDCCActiveDPP = mode_lib->vba.TotalDCCActiveDPP
 575                                         + mode_lib->vba.DPPPerPlane[k];
 576         }
 577
 578         v->UrgentExtraLatency = dml32_CalculateExtraLatency(
 579                         mode_lib->vba.RoundTripPingLatencyCycles,
 580                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.ReorderBytes,
 581                         mode_lib->vba.DCFCLK,
 582                         mode_lib->vba.TotalActiveDPP,
 583                         mode_lib->vba.PixelChunkSizeInKByte,
 584                         mode_lib->vba.TotalDCCActiveDPP,
 585                         mode_lib->vba.MetaChunkSize,
 586                         mode_lib->vba.ReturnBW,
 587                         mode_lib->vba.GPUVMEnable,
 588                         mode_lib->vba.HostVMEnable,
 589                         mode_lib->vba.NumberOfActiveSurfaces,
 590                         mode_lib->vba.DPPPerPlane,
 591                         v->dpte_group_bytes,
 592                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.HostVMInefficiencyFactor,
 593                         mode_lib->vba.HostVMMinPageSize,
 594                         mode_lib->vba.HostVMMaxNonCachedPageTableLevels);
 595
 596         mode_lib->vba.TCalc = 24.0 / v->DCFCLKDeepSleep;
 597
 598         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 599                 if (mode_lib->vba.BlendingAndTiming[k] == k) {
 600                         if (mode_lib->vba.WritebackEnable[k] == true) {
 601                                 v->WritebackDelay[mode_lib->vba.VoltageLevel][k] = mode_lib->vba.WritebackLatency
 602                                                 + dml32_CalculateWriteBackDelay(
 603                                                                 mode_lib->vba.WritebackPixelFormat[k],
 604                                                                 mode_lib->vba.WritebackHRatio[k],
 605                                                                 mode_lib->vba.WritebackVRatio[k],
 606                                                                 mode_lib->vba.WritebackVTaps[k],
 607                                                                 mode_lib->vba.WritebackDestinationWidth[k],
 608                                                                 mode_lib->vba.WritebackDestinationHeight[k],
 609                                                                 mode_lib->vba.WritebackSourceHeight[k],
 610                                                                 mode_lib->vba.HTotal[k]) / mode_lib->vba.DISPCLK;
 611                         } else
 612                                 v->WritebackDelay[mode_lib->vba.VoltageLevel][k] = 0;
 613                         for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) {
 614                                 if (mode_lib->vba.BlendingAndTiming[j] == k &&
 615                                         mode_lib->vba.WritebackEnable[j] == true) {
 616                                         v->WritebackDelay[mode_lib->vba.VoltageLevel][k] =
 617                                                 dml_max(v->WritebackDelay[mode_lib->vba.VoltageLevel][k],
 618                                                 mode_lib->vba.WritebackLatency +
 619                                                 dml32_CalculateWriteBackDelay(
 620                                                                 mode_lib->vba.WritebackPixelFormat[j],
 621                                                                 mode_lib->vba.WritebackHRatio[j],
 622                                                                 mode_lib->vba.WritebackVRatio[j],
 623                                                                 mode_lib->vba.WritebackVTaps[j],
 624                                                                 mode_lib->vba.WritebackDestinationWidth[j],
 625                                                                 mode_lib->vba.WritebackDestinationHeight[j],
 626                                                                 mode_lib->vba.WritebackSourceHeight[j],
 627                                                                 mode_lib->vba.HTotal[k]) / mode_lib->vba.DISPCLK);
 628                                 }
 629                         }
 630                 }
 631         }
 632
 633         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
 634                 for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j)
 635                         if (mode_lib->vba.BlendingAndTiming[k] == j)
 636                                 v->WritebackDelay[mode_lib->vba.VoltageLevel][k] =
 637                                                 v->WritebackDelay[mode_lib->vba.VoltageLevel][j];
 638
 639         v->UrgentLatency = dml32_CalculateUrgentLatency(mode_lib->vba.UrgentLatencyPixelDataOnly,
 640                         mode_lib->vba.UrgentLatencyPixelMixedWithVMData,
 641                         mode_lib->vba.UrgentLatencyVMDataOnly,
 642                         mode_lib->vba.DoUrgentLatencyAdjustment,
 643                         mode_lib->vba.UrgentLatencyAdjustmentFabricClockComponent,
 644                         mode_lib->vba.UrgentLatencyAdjustmentFabricClockReference,
 645                         mode_lib->vba.FabricClock);
 646
 647         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 648                 dml32_CalculateUrgentBurstFactor(mode_lib->vba.UsesMALLForPStateChange[k],
 649                                 v->swath_width_luma_ub[k],
 650                                 v->swath_width_chroma_ub[k],
 651                                 mode_lib->vba.SwathHeightY[k],
 652                                 mode_lib->vba.SwathHeightC[k],
 653                                 mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
 654                                 v->UrgentLatency,
 655                                 mode_lib->vba.CursorBufferSize,
 656                                 mode_lib->vba.CursorWidth[k][0],
 657                                 mode_lib->vba.CursorBPP[k][0],
 658                                 mode_lib->vba.VRatio[k],
 659                                 mode_lib->vba.VRatioChroma[k],
 660                                 v->BytePerPixelDETY[k],
 661                                 v->BytePerPixelDETC[k],
 662                                 mode_lib->vba.DETBufferSizeY[k],
 663                                 mode_lib->vba.DETBufferSizeC[k],
 664
 665                                 /* output */
 666                                 &v->UrgBurstFactorCursor[k],
 667                                 &v->UrgBurstFactorLuma[k],
 668                                 &v->UrgBurstFactorChroma[k],
 669                                 &v->NoUrgentLatencyHiding[k]);
 670
 671                 v->cursor_bw[k] = mode_lib->vba.NumberOfCursors[k] * mode_lib->vba.CursorWidth[k][0] * mode_lib->vba.CursorBPP[k][0] / 8 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k];
 672         }
 673
 674         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 675                 v->MaxVStartupLines[k] = ((mode_lib->vba.Interlace[k] &&
 676                                 !mode_lib->vba.ProgressiveToInterlaceUnitInOPP) ?
 677                                 dml_floor((mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]) / 2.0, 1.0) :
 678                                 mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]) - dml_max(1.0,
 679                                 dml_ceil((double) v->WritebackDelay[mode_lib->vba.VoltageLevel][k]
 680                                 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]), 1));
 681
 682         // Clamp to max OTG vstartup register limit
 683         if (v->MaxVStartupLines[k] > 1023)
 684                 v->MaxVStartupLines[k] = 1023;
 685
 686 #ifdef __DML_VBA_DEBUG__
 687                 dml_print("DML::%s: k=%d MaxVStartupLines = %d\n", __func__, k, v->MaxVStartupLines[k]);
 688                 dml_print("DML::%s: k=%d VoltageLevel = %d\n", __func__, k, mode_lib->vba.VoltageLevel);
 689                 dml_print("DML::%s: k=%d WritebackDelay = %f\n", __func__,
 690                                 k, v->WritebackDelay[mode_lib->vba.VoltageLevel][k]);
 691 #endif
 692         }
 693
 694         v->MaximumMaxVStartupLines = 0;
 695         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
 696                 v->MaximumMaxVStartupLines = dml_max(v->MaximumMaxVStartupLines, v->MaxVStartupLines[k]);
 697
 698         ImmediateFlipRequirementFinal = false;
 699
 700         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 701                 ImmediateFlipRequirementFinal = ImmediateFlipRequirementFinal
 702                                 || (mode_lib->vba.ImmediateFlipRequirement[k] == dm_immediate_flip_required);
 703         }
 704 #ifdef __DML_VBA_DEBUG__
 705         dml_print("DML::%s: ImmediateFlipRequirementFinal = %d\n", __func__, ImmediateFlipRequirementFinal);
 706 #endif
 707         // ModeProgramming will not repeat the schedule calculation using different prefetch mode,
 708         //it is just calcualated once with given prefetch mode
 709         dml32_CalculateMinAndMaxPrefetchMode(
 710                         mode_lib->vba.AllowForPStateChangeOrStutterInVBlankFinal,
 711                         &mode_lib->vba.MinPrefetchMode,
 712                         &mode_lib->vba.MaxPrefetchMode);
 713
 714         v->VStartupLines = __DML_VBA_MIN_VSTARTUP__;
 715
 716         iteration = 0;
 717         MaxTotalRDBandwidth = 0;
 718         NextPrefetchMode = mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb];
 719
 720         do {
 721                 MaxTotalRDBandwidth = 0;
 722 #ifdef __DML_VBA_DEBUG__
 723                 dml_print("DML::%s: Start loop: VStartup = %d\n", __func__, mode_lib->vba.VStartupLines);
 724 #endif
 725                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 726                         /* NOTE PerfetchMode variable is invalid in DAL as per the input received.
 727                          * Hence the direction is to use PrefetchModePerState.
 728                          */
 729                         TWait = dml32_CalculateTWait(
 730                                 mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb],
 731                                 mode_lib->vba.UsesMALLForPStateChange[k],
 732                                 mode_lib->vba.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
 733                                 mode_lib->vba.DRRDisplay[k],
 734                                 mode_lib->vba.DRAMClockChangeLatency,
 735                                 mode_lib->vba.FCLKChangeLatency, v->UrgentLatency,
 736                                 mode_lib->vba.SREnterPlusExitTime);
 737
 738                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.Dppclk = mode_lib->vba.DPPCLK[k];
 739                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.Dispclk = mode_lib->vba.DISPCLK;
 740                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.PixelClock = mode_lib->vba.PixelClock[k];
 741                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.DCFClkDeepSleep = v->DCFCLKDeepSleep;
 742                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.DPPPerSurface = mode_lib->vba.DPPPerPlane[k];
 743                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.ScalerEnabled = mode_lib->vba.ScalerEnabled[k];
 744                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.SourceRotation = mode_lib->vba.SourceRotation[k];
 745                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BlockWidth256BytesY = v->BlockWidth256BytesY[k];
 746                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BlockHeight256BytesY = v->BlockHeight256BytesY[k];
 747                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BlockWidth256BytesC = v->BlockWidth256BytesC[k];
 748                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BlockHeight256BytesC = v->BlockHeight256BytesC[k];
 749                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.InterlaceEnable = mode_lib->vba.Interlace[k];
 750                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.NumberOfCursors = mode_lib->vba.NumberOfCursors[k];
 751                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.VBlank = mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k];
 752                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.HTotal = mode_lib->vba.HTotal[k];
 753                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.HActive = mode_lib->vba.HActive[k];
 754                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.DCCEnable = mode_lib->vba.DCCEnable[k];
 755                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.ODMMode = mode_lib->vba.ODMCombineEnabled[k];
 756                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.SourcePixelFormat = mode_lib->vba.SourcePixelFormat[k];
 757                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BytePerPixelY = v->BytePerPixelY[k];
 758                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.BytePerPixelC = v->BytePerPixelC[k];
 759                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe.ProgressiveToInterlaceUnitInOPP = mode_lib->vba.ProgressiveToInterlaceUnitInOPP;
 760                         v->ErrorResult[k] = dml32_CalculatePrefetchSchedule(v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.HostVMInefficiencyFactor,
 761                                         &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.myPipe, v->DSCDelay[k],
 762                                         mode_lib->vba.DPPCLKDelaySubtotal + mode_lib->vba.DPPCLKDelayCNVCFormater,
 763                                         mode_lib->vba.DPPCLKDelaySCL,
 764                                         mode_lib->vba.DPPCLKDelaySCLLBOnly,
 765                                         mode_lib->vba.DPPCLKDelayCNVCCursor,
 766                                         mode_lib->vba.DISPCLKDelaySubtotal,
 767                                         (unsigned int) (v->SwathWidthY[k] / mode_lib->vba.HRatio[k]),
 768                                         mode_lib->vba.OutputFormat[k],
 769                                         mode_lib->vba.MaxInterDCNTileRepeaters,
 770                                         dml_min(v->VStartupLines, v->MaxVStartupLines[k]),
 771                                         v->MaxVStartupLines[k],
 772                                         mode_lib->vba.GPUVMMaxPageTableLevels,
 773                                         mode_lib->vba.GPUVMEnable,
 774                                         mode_lib->vba.HostVMEnable,
 775                                         mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
 776                                         mode_lib->vba.HostVMMinPageSize,
 777                                         mode_lib->vba.DynamicMetadataEnable[k],
 778                                         mode_lib->vba.DynamicMetadataVMEnabled,
 779                                         mode_lib->vba.DynamicMetadataLinesBeforeActiveRequired[k],
 780                                         mode_lib->vba.DynamicMetadataTransmittedBytes[k],
 781                                         v->UrgentLatency,
 782                                         v->UrgentExtraLatency,
 783                                         mode_lib->vba.TCalc,
 784                                         v->PDEAndMetaPTEBytesFrame[k],
 785                                         v->MetaRowByte[k],
 786                                         v->PixelPTEBytesPerRow[k],
 787                                         v->PrefetchSourceLinesY[k],
 788                                         v->SwathWidthY[k],
 789                                         v->VInitPreFillY[k],
 790                                         v->MaxNumSwathY[k],
 791                                         v->PrefetchSourceLinesC[k],
 792                                         v->SwathWidthC[k],
 793                                         v->VInitPreFillC[k],
 794                                         v->MaxNumSwathC[k],
 795                                         v->swath_width_luma_ub[k],
 796                                         v->swath_width_chroma_ub[k],
 797                                         mode_lib->vba.SwathHeightY[k],
 798                                         mode_lib->vba.SwathHeightC[k],
 799                                         TWait,
 800                                         /* Output */
 801                                         &v->DSTXAfterScaler[k],
 802                                         &v->DSTYAfterScaler[k],
 803                                         &v->DestinationLinesForPrefetch[k],
 804                                         &v->PrefetchBandwidth[k],
 805                                         &v->DestinationLinesToRequestVMInVBlank[k],
 806                                         &v->DestinationLinesToRequestRowInVBlank[k],
 807                                         &v->VRatioPrefetchY[k],
 808                                         &v->VRatioPrefetchC[k],
 809                                         &v->RequiredPrefetchPixDataBWLuma[k],
 810                                         &v->RequiredPrefetchPixDataBWChroma[k],
 811                                         &v->NotEnoughTimeForDynamicMetadata[k],
 812                                         &v->Tno_bw[k], &v->prefetch_vmrow_bw[k],
 813                                         &v->Tdmdl_vm[k],
 814                                         &v->Tdmdl[k],
 815                                         &v->TSetup[k],
 816                                         &v->VUpdateOffsetPix[k],
 817                                         &v->VUpdateWidthPix[k],
 818                                         &v->VReadyOffsetPix[k]);
 819
 820 #ifdef __DML_VBA_DEBUG__
 821                         dml_print("DML::%s: k=%0d Prefetch calculation errResult=%0d\n",
 822                                         __func__, k, mode_lib->vba.ErrorResult[k]);
 823 #endif
 824                         v->VStartup[k] = dml_min(v->VStartupLines, v->MaxVStartupLines[k]);
 825                 }
 826
 827                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 828                         dml32_CalculateUrgentBurstFactor(mode_lib->vba.UsesMALLForPStateChange[k],
 829                                         v->swath_width_luma_ub[k],
 830                                         v->swath_width_chroma_ub[k],
 831                                         mode_lib->vba.SwathHeightY[k],
 832                                         mode_lib->vba.SwathHeightC[k],
 833                                         mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
 834                                         v->UrgentLatency,
 835                                         mode_lib->vba.CursorBufferSize,
 836                                         mode_lib->vba.CursorWidth[k][0],
 837                                         mode_lib->vba.CursorBPP[k][0],
 838                                         v->VRatioPrefetchY[k],
 839                                         v->VRatioPrefetchC[k],
 840                                         v->BytePerPixelDETY[k],
 841                                         v->BytePerPixelDETC[k],
 842                                         mode_lib->vba.DETBufferSizeY[k],
 843                                         mode_lib->vba.DETBufferSizeC[k],
 844                                         /* Output */
 845                                         &v->UrgBurstFactorCursorPre[k],
 846                                         &v->UrgBurstFactorLumaPre[k],
 847                                         &v->UrgBurstFactorChromaPre[k],
 848                                         &v->NoUrgentLatencyHidingPre[k]);
 849
 850                         v->cursor_bw_pre[k] = mode_lib->vba.NumberOfCursors[k] * mode_lib->vba.CursorWidth[k][0] * mode_lib->vba.CursorBPP[k][0] /
 851                                         8.0 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * v->VRatioPrefetchY[k];
 852
 853 #ifdef __DML_VBA_DEBUG__
 854                         dml_print("DML::%s: k=%0d DPPPerSurface=%d\n", __func__, k, mode_lib->vba.DPPPerPlane[k]);
 855                         dml_print("DML::%s: k=%0d UrgBurstFactorLuma=%f\n", __func__, k, v->UrgBurstFactorLuma[k]);
 856                         dml_print("DML::%s: k=%0d UrgBurstFactorChroma=%f\n", __func__, k, v->UrgBurstFactorChroma[k]);
 857                         dml_print("DML::%s: k=%0d UrgBurstFactorLumaPre=%f\n", __func__, k,
 858                                         v->UrgBurstFactorLumaPre[k]);
 859                         dml_print("DML::%s: k=%0d UrgBurstFactorChromaPre=%f\n", __func__, k,
 860                                         v->UrgBurstFactorChromaPre[k]);
 861
 862                         dml_print("DML::%s: k=%0d VRatioPrefetchY=%f\n", __func__, k, v->VRatioPrefetchY[k]);
 863                         dml_print("DML::%s: k=%0d VRatioY=%f\n", __func__, k, mode_lib->vba.VRatio[k]);
 864
 865                         dml_print("DML::%s: k=%0d prefetch_vmrow_bw=%f\n", __func__, k, v->prefetch_vmrow_bw[k]);
 866                         dml_print("DML::%s: k=%0d ReadBandwidthSurfaceLuma=%f\n", __func__, k,
 867                                         v->ReadBandwidthSurfaceLuma[k]);
 868                         dml_print("DML::%s: k=%0d ReadBandwidthSurfaceChroma=%f\n", __func__, k,
 869                                         v->ReadBandwidthSurfaceChroma[k]);
 870                         dml_print("DML::%s: k=%0d cursor_bw=%f\n", __func__, k, v->cursor_bw[k]);
 871                         dml_print("DML::%s: k=%0d meta_row_bw=%f\n", __func__, k, v->meta_row_bw[k]);
 872                         dml_print("DML::%s: k=%0d dpte_row_bw=%f\n", __func__, k, v->dpte_row_bw[k]);
 873                         dml_print("DML::%s: k=%0d RequiredPrefetchPixDataBWLuma=%f\n", __func__, k,
 874                                         v->RequiredPrefetchPixDataBWLuma[k]);
 875                         dml_print("DML::%s: k=%0d RequiredPrefetchPixDataBWChroma=%f\n", __func__, k,
 876                                         v->RequiredPrefetchPixDataBWChroma[k]);
 877                         dml_print("DML::%s: k=%0d cursor_bw_pre=%f\n", __func__, k, v->cursor_bw_pre[k]);
 878                         dml_print("DML::%s: k=%0d MaxTotalRDBandwidthNoUrgentBurst=%f\n", __func__, k,
 879                                         MaxTotalRDBandwidthNoUrgentBurst);
 880 #endif
 881                         if (v->DestinationLinesForPrefetch[k] < 2)
 882                                 DestinationLineTimesForPrefetchLessThan2 = true;
 883
 884                         if (v->VRatioPrefetchY[k] > __DML_MAX_VRATIO_PRE__
 885                                         || v->VRatioPrefetchC[k] > __DML_MAX_VRATIO_PRE__)
 886                                 VRatioPrefetchMoreThanMax = true;
 887
 888                         //bool DestinationLinesToRequestVMInVBlankEqualOrMoreThan32 = false;
 889                         //bool DestinationLinesToRequestRowInVBlankEqualOrMoreThan16 = false;
 890                         //if (v->DestinationLinesToRequestVMInVBlank[k] >= 32) {
 891                         //    DestinationLinesToRequestVMInVBlankEqualOrMoreThan32 = true;
 892                         //}
 893
 894                         //if (v->DestinationLinesToRequestRowInVBlank[k] >= 16) {
 895                         //    DestinationLinesToRequestRowInVBlankEqualOrMoreThan16 = true;
 896                         //}
 897                 }
 898
 899                 v->FractionOfUrgentBandwidth = MaxTotalRDBandwidthNoUrgentBurst / mode_lib->vba.ReturnBW;
 900
 901 #ifdef __DML_VBA_DEBUG__
 902                 dml_print("DML::%s: MaxTotalRDBandwidthNoUrgentBurst=%f\n",
 903                                 __func__, MaxTotalRDBandwidthNoUrgentBurst);
 904                 dml_print("DML::%s: ReturnBW=%f\n", __func__, mode_lib->vba.ReturnBW);
 905                 dml_print("DML::%s: FractionOfUrgentBandwidth=%f\n",
 906                                 __func__, mode_lib->vba.FractionOfUrgentBandwidth);
 907 #endif
 908
 909                 {
 910                         dml32_CalculatePrefetchBandwithSupport(
 911                                         mode_lib->vba.NumberOfActiveSurfaces,
 912                                         mode_lib->vba.ReturnBW,
 913                                         v->NoUrgentLatencyHidingPre,
 914                                         v->ReadBandwidthSurfaceLuma,
 915                                         v->ReadBandwidthSurfaceChroma,
 916                                         v->RequiredPrefetchPixDataBWLuma,
 917                                         v->RequiredPrefetchPixDataBWChroma,
 918                                         v->cursor_bw,
 919                                         v->meta_row_bw,
 920                                         v->dpte_row_bw,
 921                                         v->cursor_bw_pre,
 922                                         v->prefetch_vmrow_bw,
 923                                         mode_lib->vba.DPPPerPlane,
 924                                         v->UrgBurstFactorLuma,
 925                                         v->UrgBurstFactorChroma,
 926                                         v->UrgBurstFactorCursor,
 927                                         v->UrgBurstFactorLumaPre,
 928                                         v->UrgBurstFactorChromaPre,
 929                                         v->UrgBurstFactorCursorPre,
 930
 931                                         /* output */
 932                                         &MaxTotalRDBandwidth,
 933                                         &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[0],
 934                                         &v->PrefetchModeSupported);
 935                 }
 936
 937                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
 938                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector[k] = 1.0;
 939
 940                 {
 941                         dml32_CalculatePrefetchBandwithSupport(mode_lib->vba.NumberOfActiveSurfaces,
 942                                         mode_lib->vba.ReturnBW,
 943                                         v->NoUrgentLatencyHidingPre,
 944                                         v->ReadBandwidthSurfaceLuma,
 945                                         v->ReadBandwidthSurfaceChroma,
 946                                         v->RequiredPrefetchPixDataBWLuma,
 947                                         v->RequiredPrefetchPixDataBWChroma,
 948                                         v->cursor_bw,
 949                                         v->meta_row_bw,
 950                                         v->dpte_row_bw,
 951                                         v->cursor_bw_pre,
 952                                         v->prefetch_vmrow_bw,
 953                                         mode_lib->vba.DPPPerPlane,
 954                                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
 955                                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
 956                                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
 957                                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
 958                                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
 959                                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
 960
 961                                         /* output */
 962                                         &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[0],
 963                                         &v->FractionOfUrgentBandwidth,
 964                                         &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean);
 965                 }
 966
 967                 if (VRatioPrefetchMoreThanMax != false || DestinationLineTimesForPrefetchLessThan2 != false) {
 968                         v->PrefetchModeSupported = false;
 969                 }
 970
 971                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 972                         if (v->ErrorResult[k] == true || v->NotEnoughTimeForDynamicMetadata[k]) {
 973                                 v->PrefetchModeSupported = false;
 974                         }
 975                 }
 976
 977                 if (v->PrefetchModeSupported == true && mode_lib->vba.ImmediateFlipSupport == true) {
 978                         mode_lib->vba.BandwidthAvailableForImmediateFlip = dml32_CalculateBandwidthAvailableForImmediateFlip(
 979                                         mode_lib->vba.NumberOfActiveSurfaces,
 980                                         mode_lib->vba.ReturnBW,
 981                                         v->ReadBandwidthSurfaceLuma,
 982                                         v->ReadBandwidthSurfaceChroma,
 983                                         v->RequiredPrefetchPixDataBWLuma,
 984                                         v->RequiredPrefetchPixDataBWChroma,
 985                                         v->cursor_bw,
 986                                         v->cursor_bw_pre,
 987                                         mode_lib->vba.DPPPerPlane,
 988                                         v->UrgBurstFactorLuma,
 989                                         v->UrgBurstFactorChroma,
 990                                         v->UrgBurstFactorCursor,
 991                                         v->UrgBurstFactorLumaPre,
 992                                         v->UrgBurstFactorChromaPre,
 993                                         v->UrgBurstFactorCursorPre);
 994
 995                         mode_lib->vba.TotImmediateFlipBytes = 0;
 996                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
 997                                 if (mode_lib->vba.ImmediateFlipRequirement[k] != dm_immediate_flip_not_required) {
 998                                         mode_lib->vba.TotImmediateFlipBytes = mode_lib->vba.TotImmediateFlipBytes
 999                                                         + mode_lib->vba.DPPPerPlane[k]
1000                                                                         * (v->PDEAndMetaPTEBytesFrame[k]
1001                                                                                         + v->MetaRowByte[k]);
1002                                         if (v->use_one_row_for_frame_flip[k][0][0]) {
1003                                                 mode_lib->vba.TotImmediateFlipBytes =
1004                                                                 mode_lib->vba.TotImmediateFlipBytes
1005                                                                                 + 2 * v->PixelPTEBytesPerRow[k];
1006                                         } else {
1007                                                 mode_lib->vba.TotImmediateFlipBytes =
1008                                                                 mode_lib->vba.TotImmediateFlipBytes
1009                                                                                 + v->PixelPTEBytesPerRow[k];
1010                                         }
1011                                 }
1012                         }
1013                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1014                                 dml32_CalculateFlipSchedule(v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.HostVMInefficiencyFactor,
1015                                                 v->UrgentExtraLatency,
1016                                                 v->UrgentLatency,
1017                                                 mode_lib->vba.GPUVMMaxPageTableLevels,
1018                                                 mode_lib->vba.HostVMEnable,
1019                                                 mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
1020                                                 mode_lib->vba.GPUVMEnable,
1021                                                 mode_lib->vba.HostVMMinPageSize,
1022                                                 v->PDEAndMetaPTEBytesFrame[k],
1023                                                 v->MetaRowByte[k],
1024                                                 v->PixelPTEBytesPerRow[k],
1025                                                 mode_lib->vba.BandwidthAvailableForImmediateFlip,
1026                                                 mode_lib->vba.TotImmediateFlipBytes,
1027                                                 mode_lib->vba.SourcePixelFormat[k],
1028                                                 mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
1029                                                 mode_lib->vba.VRatio[k],
1030                                                 mode_lib->vba.VRatioChroma[k],
1031                                                 v->Tno_bw[k],
1032                                                 mode_lib->vba.DCCEnable[k],
1033                                                 v->dpte_row_height[k],
1034                                                 v->meta_row_height[k],
1035                                                 v->dpte_row_height_chroma[k],
1036                                                 v->meta_row_height_chroma[k],
1037                                                 v->Use_One_Row_For_Frame_Flip[k],
1038
1039                                                 /* Output */
1040                                                 &v->DestinationLinesToRequestVMInImmediateFlip[k],
1041                                                 &v->DestinationLinesToRequestRowInImmediateFlip[k],
1042                                                 &v->final_flip_bw[k],
1043                                                 &v->ImmediateFlipSupportedForPipe[k]);
1044                         }
1045
1046                         {
1047                                 dml32_CalculateImmediateFlipBandwithSupport(mode_lib->vba.NumberOfActiveSurfaces,
1048                                                 mode_lib->vba.ReturnBW,
1049                                                 mode_lib->vba.ImmediateFlipRequirement,
1050                                                 v->final_flip_bw,
1051                                                 v->ReadBandwidthSurfaceLuma,
1052                                                 v->ReadBandwidthSurfaceChroma,
1053                                                 v->RequiredPrefetchPixDataBWLuma,
1054                                                 v->RequiredPrefetchPixDataBWChroma,
1055                                                 v->cursor_bw,
1056                                                 v->meta_row_bw,
1057                                                 v->dpte_row_bw,
1058                                                 v->cursor_bw_pre,
1059                                                 v->prefetch_vmrow_bw,
1060                                                 mode_lib->vba.DPPPerPlane,
1061                                                 v->UrgBurstFactorLuma,
1062                                                 v->UrgBurstFactorChroma,
1063                                                 v->UrgBurstFactorCursor,
1064                                                 v->UrgBurstFactorLumaPre,
1065                                                 v->UrgBurstFactorChromaPre,
1066                                                 v->UrgBurstFactorCursorPre,
1067
1068                                                 /* output */
1069                                                 &v->total_dcn_read_bw_with_flip,    // Single  *TotalBandwidth
1070                                                 &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[0],                        // Single  *FractionOfUrgentBandwidth
1071                                                 &v->ImmediateFlipSupported);        // Boolean *ImmediateFlipBandwidthSupport
1072
1073                                 dml32_CalculateImmediateFlipBandwithSupport(mode_lib->vba.NumberOfActiveSurfaces,
1074                                                 mode_lib->vba.ReturnBW,
1075                                                 mode_lib->vba.ImmediateFlipRequirement,
1076                                                 v->final_flip_bw,
1077                                                 v->ReadBandwidthSurfaceLuma,
1078                                                 v->ReadBandwidthSurfaceChroma,
1079                                                 v->RequiredPrefetchPixDataBWLuma,
1080                                                 v->RequiredPrefetchPixDataBWChroma,
1081                                                 v->cursor_bw,
1082                                                 v->meta_row_bw,
1083                                                 v->dpte_row_bw,
1084                                                 v->cursor_bw_pre,
1085                                                 v->prefetch_vmrow_bw,
1086                                                 mode_lib->vba.DPPPerPlane,
1087                                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1088                                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1089                                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1090                                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1091                                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1092                                                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_unit_vector,
1093
1094                                                 /* output */
1095                                                 &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[1],                                // Single  *TotalBandwidth
1096                                                 &v->FractionOfUrgentBandwidthImmediateFlip, // Single  *FractionOfUrgentBandwidth
1097                                                 &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean);                              // Boolean *ImmediateFlipBandwidthSupport
1098                         }
1099
1100                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1101                                 if (mode_lib->vba.ImmediateFlipRequirement[k] != dm_immediate_flip_not_required && v->ImmediateFlipSupportedForPipe[k] == false) {
1102                                         v->ImmediateFlipSupported = false;
1103 #ifdef __DML_VBA_DEBUG__
1104                                         dml_print("DML::%s: Pipe %0d not supporting iflip\n", __func__, k);
1105 #endif
1106                                 }
1107                         }
1108                 } else {
1109                         v->ImmediateFlipSupported = false;
1110                 }
1111
1112                 /* consider flip support is okay if the flip bw is ok or (when user does't require a iflip and there is no host vm) */
1113                 v->PrefetchAndImmediateFlipSupported = (v->PrefetchModeSupported == true &&
1114                                 ((!mode_lib->vba.ImmediateFlipSupport && !mode_lib->vba.HostVMEnable && !ImmediateFlipRequirementFinal) ||
1115                                                 v->ImmediateFlipSupported)) ? true : false;
1116
1117 #ifdef __DML_VBA_DEBUG__
1118                 dml_print("DML::%s: PrefetchModeSupported = %d\n", __func__, locals->PrefetchModeSupported);
1119                 for (uint k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
1120                         dml_print("DML::%s: ImmediateFlipRequirement[%d] = %d\n", __func__, k,  mode_lib->vba.ImmediateFlipRequirement[k] == dm_immediate_flip_required);
1121                 dml_print("DML::%s: ImmediateFlipSupported = %d\n", __func__, locals->ImmediateFlipSupported);
1122                 dml_print("DML::%s: ImmediateFlipSupport = %d\n", __func__, mode_lib->vba.ImmediateFlipSupport);
1123                 dml_print("DML::%s: HostVMEnable = %d\n", __func__, mode_lib->vba.HostVMEnable);
1124                 dml_print("DML::%s: PrefetchAndImmediateFlipSupported = %d\n", __func__, locals->PrefetchAndImmediateFlipSupported);
1125                 dml_print("DML::%s: Done loop: Vstartup=%d, Max Vstartup=%d\n", __func__, locals->VStartupLines, locals->MaximumMaxVStartupLines);
1126 #endif
1127
1128                 v->VStartupLines = v->VStartupLines + 1;
1129
1130                 if (v->VStartupLines > v->MaximumMaxVStartupLines) {
1131 #ifdef __DML_VBA_DEBUG__
1132                         dml_print("DML::%s: Vstartup exceeds max vstartup, exiting loop\n", __func__);
1133 #endif
1134                         break; // VBA_DELTA: Implementation divergence! Gabe is *still* iterating across prefetch modes which we don't care to do
1135                 }
1136                 iteration++;
1137                 if (iteration > 2500) {
1138 #ifdef __DML_VBA_DEBUG__
1139                         dml_print("DML::%s: too many errors, exit now\n", __func__);
1140                         assert(0);
1141 #endif
1142                 }
1143         } while (!(v->PrefetchAndImmediateFlipSupported || NextPrefetchMode > mode_lib->vba.MaxPrefetchMode));
1144
1145
1146         if (v->VStartupLines <= v->MaximumMaxVStartupLines) {
1147 #ifdef __DML_VBA_DEBUG__
1148                 dml_print("DML::%s: Good, Prefetch and flip scheduling found solution at VStartupLines=%d\n", __func__, locals->VStartupLines-1);
1149 #endif
1150         }
1151
1152
1153         //Watermarks and NB P-State/DRAM Clock Change Support
1154         {
1155                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.UrgentLatency = v->UrgentLatency;
1156                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.ExtraLatency = v->UrgentExtraLatency;
1157                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.WritebackLatency = mode_lib->vba.WritebackLatency;
1158                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.DRAMClockChangeLatency = mode_lib->vba.DRAMClockChangeLatency;
1159                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.FCLKChangeLatency = mode_lib->vba.FCLKChangeLatency;
1160                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SRExitTime = mode_lib->vba.SRExitTime;
1161                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SREnterPlusExitTime = mode_lib->vba.SREnterPlusExitTime;
1162                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SRExitZ8Time = mode_lib->vba.SRExitZ8Time;
1163                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SREnterPlusExitZ8Time = mode_lib->vba.SREnterPlusExitZ8Time;
1164                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.USRRetrainingLatency = mode_lib->vba.USRRetrainingLatency;
1165                 v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters.SMNLatency = mode_lib->vba.SMNLatency;
1166
1167                 dml32_CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(
1168                         &v->dummy_vars.dml32_CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport,
1169                         mode_lib->vba.USRRetrainingRequiredFinal,
1170                         mode_lib->vba.UsesMALLForPStateChange,
1171                         mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb],
1172                         mode_lib->vba.NumberOfActiveSurfaces,
1173                         mode_lib->vba.MaxLineBufferLines,
1174                         mode_lib->vba.LineBufferSizeFinal,
1175                         mode_lib->vba.WritebackInterfaceBufferSize,
1176                         mode_lib->vba.DCFCLK,
1177                         mode_lib->vba.ReturnBW,
1178                         mode_lib->vba.SynchronizeTimingsFinal,
1179                         mode_lib->vba.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
1180                         mode_lib->vba.DRRDisplay,
1181                         v->dpte_group_bytes,
1182                         v->meta_row_height,
1183                         v->meta_row_height_chroma,
1184                         v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.mmSOCParameters,
1185                         mode_lib->vba.WritebackChunkSize,
1186                         mode_lib->vba.SOCCLK,
1187                         v->DCFCLKDeepSleep,
1188                         mode_lib->vba.DETBufferSizeY,
1189                         mode_lib->vba.DETBufferSizeC,
1190                         mode_lib->vba.SwathHeightY,
1191                         mode_lib->vba.SwathHeightC,
1192                         mode_lib->vba.LBBitPerPixel,
1193                         v->SwathWidthY,
1194                         v->SwathWidthC,
1195                         mode_lib->vba.HRatio,
1196                         mode_lib->vba.HRatioChroma,
1197                         mode_lib->vba.vtaps,
1198                         mode_lib->vba.VTAPsChroma,
1199                         mode_lib->vba.VRatio,
1200                         mode_lib->vba.VRatioChroma,
1201                         mode_lib->vba.HTotal,
1202                         mode_lib->vba.VTotal,
1203                         mode_lib->vba.VActive,
1204                         mode_lib->vba.PixelClock,
1205                         mode_lib->vba.BlendingAndTiming,
1206                         mode_lib->vba.DPPPerPlane,
1207                         v->BytePerPixelDETY,
1208                         v->BytePerPixelDETC,
1209                         v->DSTXAfterScaler,
1210                         v->DSTYAfterScaler,
1211                         mode_lib->vba.WritebackEnable,
1212                         mode_lib->vba.WritebackPixelFormat,
1213                         mode_lib->vba.WritebackDestinationWidth,
1214                         mode_lib->vba.WritebackDestinationHeight,
1215                         mode_lib->vba.WritebackSourceHeight,
1216                         v->UnboundedRequestEnabled,
1217                         v->CompressedBufferSizeInkByte,
1218
1219                         /* Output */
1220                         &v->Watermark,
1221                         &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_dramchange_support,
1222                         v->MaxActiveDRAMClockChangeLatencySupported,
1223                         v->SubViewportLinesNeededInMALL,
1224                         &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_fclkchange_support,
1225                         &v->MinActiveFCLKChangeLatencySupported,
1226                         &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_USRRetrainingSupport,
1227                         mode_lib->vba.ActiveDRAMClockChangeLatencyMargin);
1228
1229                 /* DCN32 has a new struct Watermarks (typedef) which is used to store
1230                  * calculated WM values. Copy over values from struct to vba varaibles
1231                  * to ensure that the DCN32 getters return the correct value.
1232                  */
1233                 v->UrgentWatermark = v->Watermark.UrgentWatermark;
1234                 v->WritebackUrgentWatermark = v->Watermark.WritebackUrgentWatermark;
1235                 v->DRAMClockChangeWatermark = v->Watermark.DRAMClockChangeWatermark;
1236                 v->WritebackDRAMClockChangeWatermark = v->Watermark.WritebackDRAMClockChangeWatermark;
1237                 v->StutterExitWatermark = v->Watermark.StutterExitWatermark;
1238                 v->StutterEnterPlusExitWatermark = v->Watermark.StutterEnterPlusExitWatermark;
1239                 v->Z8StutterExitWatermark = v->Watermark.Z8StutterExitWatermark;
1240                 v->Z8StutterEnterPlusExitWatermark = v->Watermark.Z8StutterEnterPlusExitWatermark;
1241
1242                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1243                         if (mode_lib->vba.WritebackEnable[k] == true) {
1244                                 v->WritebackAllowDRAMClockChangeEndPosition[k] = dml_max(0,
1245                                                 v->VStartup[k] * mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]
1246                                                                 - v->Watermark.WritebackDRAMClockChangeWatermark);
1247                                 v->WritebackAllowFCLKChangeEndPosition[k] = dml_max(0,
1248                                                 v->VStartup[k] * mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]
1249                                                                 - v->Watermark.WritebackFCLKChangeWatermark);
1250                         } else {
1251                                 v->WritebackAllowDRAMClockChangeEndPosition[k] = 0;
1252                                 v->WritebackAllowFCLKChangeEndPosition[k] = 0;
1253                         }
1254                 }
1255         }
1256
1257         //Display Pipeline Delivery Time in Prefetch, Groups
1258         dml32_CalculatePixelDeliveryTimes(
1259                         mode_lib->vba.NumberOfActiveSurfaces,
1260                         mode_lib->vba.VRatio,
1261                         mode_lib->vba.VRatioChroma,
1262                         v->VRatioPrefetchY,
1263                         v->VRatioPrefetchC,
1264                         v->swath_width_luma_ub,
1265                         v->swath_width_chroma_ub,
1266                         mode_lib->vba.DPPPerPlane,
1267                         mode_lib->vba.HRatio,
1268                         mode_lib->vba.HRatioChroma,
1269                         mode_lib->vba.PixelClock,
1270                         v->PSCL_THROUGHPUT_LUMA,
1271                         v->PSCL_THROUGHPUT_CHROMA,
1272                         mode_lib->vba.DPPCLK,
1273                         v->BytePerPixelC,
1274                         mode_lib->vba.SourceRotation,
1275                         mode_lib->vba.NumberOfCursors,
1276                         mode_lib->vba.CursorWidth,
1277                         mode_lib->vba.CursorBPP,
1278                         v->BlockWidth256BytesY,
1279                         v->BlockHeight256BytesY,
1280                         v->BlockWidth256BytesC,
1281                         v->BlockHeight256BytesC,
1282
1283                         /* Output */
1284                         v->DisplayPipeLineDeliveryTimeLuma,
1285                         v->DisplayPipeLineDeliveryTimeChroma,
1286                         v->DisplayPipeLineDeliveryTimeLumaPrefetch,
1287                         v->DisplayPipeLineDeliveryTimeChromaPrefetch,
1288                         v->DisplayPipeRequestDeliveryTimeLuma,
1289                         v->DisplayPipeRequestDeliveryTimeChroma,
1290                         v->DisplayPipeRequestDeliveryTimeLumaPrefetch,
1291                         v->DisplayPipeRequestDeliveryTimeChromaPrefetch,
1292                         v->CursorRequestDeliveryTime,
1293                         v->CursorRequestDeliveryTimePrefetch);
1294
1295         dml32_CalculateMetaAndPTETimes(v->Use_One_Row_For_Frame,
1296                         mode_lib->vba.NumberOfActiveSurfaces,
1297                         mode_lib->vba.GPUVMEnable,
1298                         mode_lib->vba.MetaChunkSize,
1299                         mode_lib->vba.MinMetaChunkSizeBytes,
1300                         mode_lib->vba.HTotal,
1301                         mode_lib->vba.VRatio,
1302                         mode_lib->vba.VRatioChroma,
1303                         v->DestinationLinesToRequestRowInVBlank,
1304                         v->DestinationLinesToRequestRowInImmediateFlip,
1305                         mode_lib->vba.DCCEnable,
1306                         mode_lib->vba.PixelClock,
1307                         v->BytePerPixelY,
1308                         v->BytePerPixelC,
1309                         mode_lib->vba.SourceRotation,
1310                         v->dpte_row_height,
1311                         v->dpte_row_height_chroma,
1312                         v->meta_row_width,
1313                         v->meta_row_width_chroma,
1314                         v->meta_row_height,
1315                         v->meta_row_height_chroma,
1316                         v->meta_req_width,
1317                         v->meta_req_width_chroma,
1318                         v->meta_req_height,
1319                         v->meta_req_height_chroma,
1320                         v->dpte_group_bytes,
1321                         v->PTERequestSizeY,
1322                         v->PTERequestSizeC,
1323                         v->PixelPTEReqWidthY,
1324                         v->PixelPTEReqHeightY,
1325                         v->PixelPTEReqWidthC,
1326                         v->PixelPTEReqHeightC,
1327                         v->dpte_row_width_luma_ub,
1328                         v->dpte_row_width_chroma_ub,
1329
1330                         /* Output */
1331                         v->DST_Y_PER_PTE_ROW_NOM_L,
1332                         v->DST_Y_PER_PTE_ROW_NOM_C,
1333                         v->DST_Y_PER_META_ROW_NOM_L,
1334                         v->DST_Y_PER_META_ROW_NOM_C,
1335                         v->TimePerMetaChunkNominal,
1336                         v->TimePerChromaMetaChunkNominal,
1337                         v->TimePerMetaChunkVBlank,
1338                         v->TimePerChromaMetaChunkVBlank,
1339                         v->TimePerMetaChunkFlip,
1340                         v->TimePerChromaMetaChunkFlip,
1341                         v->time_per_pte_group_nom_luma,
1342                         v->time_per_pte_group_vblank_luma,
1343                         v->time_per_pte_group_flip_luma,
1344                         v->time_per_pte_group_nom_chroma,
1345                         v->time_per_pte_group_vblank_chroma,
1346                         v->time_per_pte_group_flip_chroma);
1347
1348         dml32_CalculateVMGroupAndRequestTimes(
1349                         mode_lib->vba.NumberOfActiveSurfaces,
1350                         mode_lib->vba.GPUVMEnable,
1351                         mode_lib->vba.GPUVMMaxPageTableLevels,
1352                         mode_lib->vba.HTotal,
1353                         v->BytePerPixelC,
1354                         v->DestinationLinesToRequestVMInVBlank,
1355                         v->DestinationLinesToRequestVMInImmediateFlip,
1356                         mode_lib->vba.DCCEnable,
1357                         mode_lib->vba.PixelClock,
1358                         v->dpte_row_width_luma_ub,
1359                         v->dpte_row_width_chroma_ub,
1360                         v->vm_group_bytes,
1361                         v->dpde0_bytes_per_frame_ub_l,
1362                         v->dpde0_bytes_per_frame_ub_c,
1363                         v->meta_pte_bytes_per_frame_ub_l,
1364                         v->meta_pte_bytes_per_frame_ub_c,
1365
1366                         /* Output */
1367                         v->TimePerVMGroupVBlank,
1368                         v->TimePerVMGroupFlip,
1369                         v->TimePerVMRequestVBlank,
1370                         v->TimePerVMRequestFlip);
1371
1372         // Min TTUVBlank
1373         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1374                 if (mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb] == 0) {
1375                         v->MinTTUVBlank[k] = dml_max4(v->Watermark.DRAMClockChangeWatermark,
1376                                         v->Watermark.FCLKChangeWatermark, v->Watermark.StutterEnterPlusExitWatermark,
1377                                         v->Watermark.UrgentWatermark);
1378                 } else if (mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb]
1379                                 == 1) {
1380                         v->MinTTUVBlank[k] = dml_max3(v->Watermark.FCLKChangeWatermark,
1381                                         v->Watermark.StutterEnterPlusExitWatermark, v->Watermark.UrgentWatermark);
1382                 } else if (mode_lib->vba.PrefetchModePerState[mode_lib->vba.VoltageLevel][mode_lib->vba.maxMpcComb]
1383                                 == 2) {
1384                         v->MinTTUVBlank[k] = dml_max(v->Watermark.StutterEnterPlusExitWatermark,
1385                                         v->Watermark.UrgentWatermark);
1386                 } else {
1387                         v->MinTTUVBlank[k] = v->Watermark.UrgentWatermark;
1388                 }
1389                 if (!mode_lib->vba.DynamicMetadataEnable[k])
1390                         v->MinTTUVBlank[k] = mode_lib->vba.TCalc + v->MinTTUVBlank[k];
1391         }
1392
1393         // DCC Configuration
1394         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1395 #ifdef __DML_VBA_DEBUG__
1396                 dml_print("DML::%s: Calculate DCC configuration for surface k=%d\n", __func__, k);
1397 #endif
1398                 dml32_CalculateDCCConfiguration(
1399                                 mode_lib->vba.DCCEnable[k],
1400                                 mode_lib->vba.DCCProgrammingAssumesScanDirectionUnknownFinal,
1401                                 mode_lib->vba.SourcePixelFormat[k], mode_lib->vba.SurfaceWidthY[k],
1402                                 mode_lib->vba.SurfaceWidthC[k],
1403                                 mode_lib->vba.SurfaceHeightY[k],
1404                                 mode_lib->vba.SurfaceHeightC[k],
1405                                 mode_lib->vba.nomDETInKByte,
1406                                 v->BlockHeight256BytesY[k],
1407                                 v->BlockHeight256BytesC[k],
1408                                 mode_lib->vba.SurfaceTiling[k],
1409                                 v->BytePerPixelY[k],
1410                                 v->BytePerPixelC[k],
1411                                 v->BytePerPixelDETY[k],
1412                                 v->BytePerPixelDETC[k],
1413                                 (enum dm_rotation_angle) mode_lib->vba.SourceScan[k],
1414                                 /* Output */
1415                                 &v->DCCYMaxUncompressedBlock[k],
1416                                 &v->DCCCMaxUncompressedBlock[k],
1417                                 &v->DCCYMaxCompressedBlock[k],
1418                                 &v->DCCCMaxCompressedBlock[k],
1419                                 &v->DCCYIndependentBlock[k],
1420                                 &v->DCCCIndependentBlock[k]);
1421         }
1422
1423         // VStartup Adjustment
1424         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1425                 bool isInterlaceTiming;
1426                 double Tvstartup_margin = (v->MaxVStartupLines[k] - v->VStartup[k]) * mode_lib->vba.HTotal[k]
1427                                 / mode_lib->vba.PixelClock[k];
1428 #ifdef __DML_VBA_DEBUG__
1429                 dml_print("DML::%s: k=%d, MinTTUVBlank = %f (before vstartup margin)\n", __func__, k,
1430                                 v->MinTTUVBlank[k]);
1431 #endif
1432
1433                 v->MinTTUVBlank[k] = v->MinTTUVBlank[k] + Tvstartup_margin;
1434
1435 #ifdef __DML_VBA_DEBUG__
1436                 dml_print("DML::%s: k=%d, Tvstartup_margin = %f\n", __func__, k, Tvstartup_margin);
1437                 dml_print("DML::%s: k=%d, MaxVStartupLines = %d\n", __func__, k, v->MaxVStartupLines[k]);
1438                 dml_print("DML::%s: k=%d, VStartup = %d\n", __func__, k, v->VStartup[k]);
1439                 dml_print("DML::%s: k=%d, MinTTUVBlank = %f\n", __func__, k, v->MinTTUVBlank[k]);
1440 #endif
1441
1442                 v->Tdmdl[k] = v->Tdmdl[k] + Tvstartup_margin;
1443                 if (mode_lib->vba.DynamicMetadataEnable[k] && mode_lib->vba.DynamicMetadataVMEnabled)
1444                         v->Tdmdl_vm[k] = v->Tdmdl_vm[k] + Tvstartup_margin;
1445
1446                 isInterlaceTiming = (mode_lib->vba.Interlace[k] &&
1447                                 !mode_lib->vba.ProgressiveToInterlaceUnitInOPP);
1448
1449                 v->MIN_DST_Y_NEXT_START[k] = ((isInterlaceTiming ? dml_floor((mode_lib->vba.VTotal[k] -
1450                                                 mode_lib->vba.VFrontPorch[k]) / 2.0, 1.0) :
1451                                                 mode_lib->vba.VTotal[k]) - mode_lib->vba.VFrontPorch[k])
1452                                                 + dml_max(1.0,
1453                                                 dml_ceil(v->WritebackDelay[mode_lib->vba.VoltageLevel][k]
1454                                                 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]), 1.0))
1455                                                 + dml_floor(4.0 * v->TSetup[k] / (mode_lib->vba.HTotal[k]
1456                                                 / mode_lib->vba.PixelClock[k]), 1.0) / 4.0;
1457
1458                 v->VStartup[k] = (isInterlaceTiming ? (2 * v->MaxVStartupLines[k]) : v->MaxVStartupLines[k]);
1459
1460                 if (((v->VUpdateOffsetPix[k] + v->VUpdateWidthPix[k] + v->VReadyOffsetPix[k])
1461                         / mode_lib->vba.HTotal[k]) <= (isInterlaceTiming ? dml_floor((mode_lib->vba.VTotal[k]
1462                         - mode_lib->vba.VActive[k] - mode_lib->vba.VFrontPorch[k] - v->VStartup[k]) / 2.0, 1.0) :
1463                         (int) (mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k]
1464                        - mode_lib->vba.VFrontPorch[k] - v->VStartup[k]))) {
1465                         v->VREADY_AT_OR_AFTER_VSYNC[k] = true;
1466                 } else {
1467                         v->VREADY_AT_OR_AFTER_VSYNC[k] = false;
1468                 }
1469 #ifdef __DML_VBA_DEBUG__
1470                 dml_print("DML::%s: k=%d, VStartup = %d (max)\n", __func__, k, v->VStartup[k]);
1471                 dml_print("DML::%s: k=%d, VUpdateOffsetPix = %d\n", __func__, k, v->VUpdateOffsetPix[k]);
1472                 dml_print("DML::%s: k=%d, VUpdateWidthPix = %d\n", __func__, k, v->VUpdateWidthPix[k]);
1473                 dml_print("DML::%s: k=%d, VReadyOffsetPix = %d\n", __func__, k, v->VReadyOffsetPix[k]);
1474                 dml_print("DML::%s: k=%d, HTotal = %d\n", __func__, k, mode_lib->vba.HTotal[k]);
1475                 dml_print("DML::%s: k=%d, VTotal = %d\n", __func__, k, mode_lib->vba.VTotal[k]);
1476                 dml_print("DML::%s: k=%d, VActive = %d\n", __func__, k, mode_lib->vba.VActive[k]);
1477                 dml_print("DML::%s: k=%d, VFrontPorch = %d\n", __func__, k, mode_lib->vba.VFrontPorch[k]);
1478                 dml_print("DML::%s: k=%d, VStartup = %d\n", __func__, k, v->VStartup[k]);
1479                 dml_print("DML::%s: k=%d, TSetup = %f\n", __func__, k, v->TSetup[k]);
1480                 dml_print("DML::%s: k=%d, MIN_DST_Y_NEXT_START = %f\n", __func__, k, v->MIN_DST_Y_NEXT_START[k]);
1481                 dml_print("DML::%s: k=%d, VREADY_AT_OR_AFTER_VSYNC = %d\n", __func__, k,
1482                                 v->VREADY_AT_OR_AFTER_VSYNC[k]);
1483 #endif
1484         }
1485
1486         {
1487                 //Maximum Bandwidth Used
1488                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1489                         if (mode_lib->vba.WritebackEnable[k] == true
1490                                         && mode_lib->vba.WritebackPixelFormat[k] == dm_444_32) {
1491                                 WRBandwidth = mode_lib->vba.WritebackDestinationWidth[k]
1492                                                 * mode_lib->vba.WritebackDestinationHeight[k]
1493                                                 / (mode_lib->vba.HTotal[k] * mode_lib->vba.WritebackSourceHeight[k]
1494                                                                 / mode_lib->vba.PixelClock[k]) * 4;
1495                         } else if (mode_lib->vba.WritebackEnable[k] == true) {
1496                                 WRBandwidth = mode_lib->vba.WritebackDestinationWidth[k]
1497                                                 * mode_lib->vba.WritebackDestinationHeight[k]
1498                                                 / (mode_lib->vba.HTotal[k] * mode_lib->vba.WritebackSourceHeight[k]
1499                                                                 / mode_lib->vba.PixelClock[k]) * 8;
1500                         }
1501                         TotalWRBandwidth = TotalWRBandwidth + WRBandwidth;
1502                 }
1503
1504                 v->TotalDataReadBandwidth = 0;
1505                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1506                         v->TotalDataReadBandwidth = v->TotalDataReadBandwidth + v->ReadBandwidthSurfaceLuma[k]
1507                                         + v->ReadBandwidthSurfaceChroma[k];
1508 #ifdef __DML_VBA_DEBUG__
1509                         dml_print("DML::%s: k=%d, TotalDataReadBandwidth = %f\n",
1510                                         __func__, k, v->TotalDataReadBandwidth);
1511                         dml_print("DML::%s: k=%d, ReadBandwidthSurfaceLuma = %f\n",
1512                                         __func__, k, v->ReadBandwidthSurfaceLuma[k]);
1513                         dml_print("DML::%s: k=%d, ReadBandwidthSurfaceChroma = %f\n",
1514                                         __func__, k, v->ReadBandwidthSurfaceChroma[k]);
1515 #endif
1516                 }
1517         }
1518
1519         // Stutter Efficiency
1520         dml32_CalculateStutterEfficiency(v->CompressedBufferSizeInkByte,
1521                         mode_lib->vba.UsesMALLForPStateChange,
1522                         v->UnboundedRequestEnabled,
1523                         mode_lib->vba.MetaFIFOSizeInKEntries,
1524                         mode_lib->vba.ZeroSizeBufferEntries,
1525                         mode_lib->vba.PixelChunkSizeInKByte,
1526                         mode_lib->vba.NumberOfActiveSurfaces,
1527                         mode_lib->vba.ROBBufferSizeInKByte,
1528                         v->TotalDataReadBandwidth,
1529                         mode_lib->vba.DCFCLK,
1530                         mode_lib->vba.ReturnBW,
1531                         v->CompbufReservedSpace64B,
1532                         v->CompbufReservedSpaceZs,
1533                         mode_lib->vba.SRExitTime,
1534                         mode_lib->vba.SRExitZ8Time,
1535                         mode_lib->vba.SynchronizeTimingsFinal,
1536                         mode_lib->vba.BlendingAndTiming,
1537                         v->Watermark.StutterEnterPlusExitWatermark,
1538                         v->Watermark.Z8StutterEnterPlusExitWatermark,
1539                         mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
1540                         mode_lib->vba.Interlace,
1541                         v->MinTTUVBlank, mode_lib->vba.DPPPerPlane,
1542                         mode_lib->vba.DETBufferSizeY,
1543                         v->BytePerPixelY,
1544                         v->BytePerPixelDETY,
1545                         v->SwathWidthY,
1546                         mode_lib->vba.SwathHeightY,
1547                         mode_lib->vba.SwathHeightC,
1548                         mode_lib->vba.DCCRateLuma,
1549                         mode_lib->vba.DCCRateChroma,
1550                         mode_lib->vba.DCCFractionOfZeroSizeRequestsLuma,
1551                         mode_lib->vba.DCCFractionOfZeroSizeRequestsChroma,
1552                         mode_lib->vba.HTotal, mode_lib->vba.VTotal,
1553                         mode_lib->vba.PixelClock,
1554                         mode_lib->vba.VRatio,
1555                         mode_lib->vba.SourceRotation,
1556                         v->BlockHeight256BytesY,
1557                         v->BlockWidth256BytesY,
1558                         v->BlockHeight256BytesC,
1559                         v->BlockWidth256BytesC,
1560                         v->DCCYMaxUncompressedBlock,
1561                         v->DCCCMaxUncompressedBlock,
1562                         mode_lib->vba.VActive,
1563                         mode_lib->vba.DCCEnable,
1564                         mode_lib->vba.WritebackEnable,
1565                         v->ReadBandwidthSurfaceLuma,
1566                         v->ReadBandwidthSurfaceChroma,
1567                         v->meta_row_bw,
1568                         v->dpte_row_bw,
1569                         /* Output */
1570                         &v->StutterEfficiencyNotIncludingVBlank,
1571                         &v->StutterEfficiency,
1572                         &v->NumberOfStutterBurstsPerFrame,
1573                         &v->Z8StutterEfficiencyNotIncludingVBlank,
1574                         &v->Z8StutterEfficiency,
1575                         &v->Z8NumberOfStutterBurstsPerFrame,
1576                         &v->StutterPeriod,
1577                         &v->DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE);
1578
1579 #ifdef __DML_VBA_ALLOW_DELTA__
1580         {
1581                 unsigned int dummy_integer[1];
1582
1583                 // Calculate z8 stutter eff assuming 0 reserved space
1584                 dml32_CalculateStutterEfficiency(v->CompressedBufferSizeInkByte,
1585                                 mode_lib->vba.UsesMALLForPStateChange,
1586                                 v->UnboundedRequestEnabled,
1587                                 mode_lib->vba.MetaFIFOSizeInKEntries,
1588                                 mode_lib->vba.ZeroSizeBufferEntries,
1589                                 mode_lib->vba.PixelChunkSizeInKByte,
1590                                 mode_lib->vba.NumberOfActiveSurfaces,
1591                                 mode_lib->vba.ROBBufferSizeInKByte,
1592                                 v->TotalDataReadBandwidth,
1593                                 mode_lib->vba.DCFCLK,
1594                                 mode_lib->vba.ReturnBW,
1595                                 0, //CompbufReservedSpace64B,
1596                                 0, //CompbufReservedSpaceZs,
1597                                 mode_lib->vba.SRExitTime,
1598                                 mode_lib->vba.SRExitZ8Time,
1599                                 mode_lib->vba.SynchronizeTimingsFinal,
1600                                 mode_lib->vba.BlendingAndTiming,
1601                                 v->Watermark.StutterEnterPlusExitWatermark,
1602                                 v->Watermark.Z8StutterEnterPlusExitWatermark,
1603                                 mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
1604                                 mode_lib->vba.Interlace,
1605                                 v->MinTTUVBlank,
1606                                 mode_lib->vba.DPPPerPlane,
1607                                 mode_lib->vba.DETBufferSizeY,
1608                                 v->BytePerPixelY, v->BytePerPixelDETY,
1609                                 v->SwathWidthY, mode_lib->vba.SwathHeightY,
1610                                 mode_lib->vba.SwathHeightC,
1611                                 mode_lib->vba.DCCRateLuma,
1612                                 mode_lib->vba.DCCRateChroma,
1613                                 mode_lib->vba.DCCFractionOfZeroSizeRequestsLuma,
1614                                 mode_lib->vba.DCCFractionOfZeroSizeRequestsChroma,
1615                                 mode_lib->vba.HTotal,
1616                                 mode_lib->vba.VTotal,
1617                                 mode_lib->vba.PixelClock,
1618                                 mode_lib->vba.VRatio,
1619                                 mode_lib->vba.SourceRotation,
1620                                 v->BlockHeight256BytesY,
1621                                 v->BlockWidth256BytesY,
1622                                 v->BlockHeight256BytesC,
1623                                 v->BlockWidth256BytesC,
1624                                 v->DCCYMaxUncompressedBlock,
1625                                 v->DCCCMaxUncompressedBlock,
1626                                 mode_lib->vba.VActive,
1627                                 mode_lib->vba.DCCEnable,
1628                                 mode_lib->vba.WritebackEnable,
1629                                 v->ReadBandwidthSurfaceLuma,
1630                                 v->ReadBandwidthSurfaceChroma,
1631                                 v->meta_row_bw, v->dpte_row_bw,
1632
1633                                 /* Output */
1634                                 &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[0],
1635                                 &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_single[1],
1636                                 &dummy_integer[0],
1637                                 &v->Z8StutterEfficiencyNotIncludingVBlankBestCase,
1638                                 &v->Z8StutterEfficiencyBestCase,
1639                                 &v->Z8NumberOfStutterBurstsPerFrameBestCase,
1640                                 &v->StutterPeriodBestCase,
1641                                 &v->dummy_vars.DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation.dummy_boolean);
1642         }
1643 #else
1644         v->Z8StutterEfficiencyNotIncludingVBlankBestCase = v->Z8StutterEfficiencyNotIncludingVBlank;
1645         v->Z8StutterEfficiencyBestCase = v->Z8StutterEfficiency;
1646         v->Z8NumberOfStutterBurstsPerFrameBestCase = v->Z8NumberOfStutterBurstsPerFrame;
1647         v->StutterPeriodBestCase = v->StutterPeriod;
1648 #endif
1649
1650 #ifdef __DML_VBA_DEBUG__
1651         dml_print("DML::%s: --- END ---\n", __func__);
1652 #endif
1653 }
1654
1655 void dml32_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_lib)
1656 {
1657         struct vba_vars_st *v = &mode_lib->vba;
1658         int i, j;
1659         unsigned int k, m;
1660         unsigned int MaximumMPCCombine;
1661         unsigned int NumberOfNonCombinedSurfaceOfMaximumBandwidth;
1662         unsigned int TotalSlots;
1663         bool CompBufReservedSpaceNeedAdjustment;
1664         bool CompBufReservedSpaceNeedAdjustmentSingleDPP;
1665
1666 #ifdef __DML_VBA_DEBUG__
1667         dml_print("DML::%s: called\n", __func__);
1668 #endif
1669
1670         /*MODE SUPPORT, VOLTAGE STATE AND SOC CONFIGURATION*/
1671
1672         /*Scale Ratio, taps Support Check*/
1673
1674         mode_lib->vba.ScaleRatioAndTapsSupport = true;
1675         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1676                 if (mode_lib->vba.ScalerEnabled[k] == false
1677                                 && ((mode_lib->vba.SourcePixelFormat[k] != dm_444_64
1678                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
1679                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
1680                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
1681                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8
1682                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_rgbe
1683                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_rgbe_alpha)
1684                                                 || mode_lib->vba.HRatio[k] != 1.0 || mode_lib->vba.htaps[k] != 1.0
1685                                                 || mode_lib->vba.VRatio[k] != 1.0 || mode_lib->vba.vtaps[k] != 1.0)) {
1686                         mode_lib->vba.ScaleRatioAndTapsSupport = false;
1687                 } else if (mode_lib->vba.vtaps[k] < 1.0 || mode_lib->vba.vtaps[k] > 8.0 || mode_lib->vba.htaps[k] < 1.0
1688                                 || mode_lib->vba.htaps[k] > 8.0
1689                                 || (mode_lib->vba.htaps[k] > 1.0 && (mode_lib->vba.htaps[k] % 2) == 1)
1690                                 || mode_lib->vba.HRatio[k] > mode_lib->vba.MaxHSCLRatio
1691                                 || mode_lib->vba.VRatio[k] > mode_lib->vba.MaxVSCLRatio
1692                                 || mode_lib->vba.HRatio[k] > mode_lib->vba.htaps[k]
1693                                 || mode_lib->vba.VRatio[k] > mode_lib->vba.vtaps[k]
1694                                 || (mode_lib->vba.SourcePixelFormat[k] != dm_444_64
1695                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
1696                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
1697                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
1698                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8
1699                                                 && mode_lib->vba.SourcePixelFormat[k] != dm_rgbe
1700                                                 && (mode_lib->vba.VTAPsChroma[k] < 1
1701                                                                 || mode_lib->vba.VTAPsChroma[k] > 8
1702                                                                 || mode_lib->vba.HTAPsChroma[k] < 1
1703                                                                 || mode_lib->vba.HTAPsChroma[k] > 8
1704                                                                 || (mode_lib->vba.HTAPsChroma[k] > 1
1705                                                                                 && mode_lib->vba.HTAPsChroma[k] % 2
1706                                                                                                 == 1)
1707                                                                 || mode_lib->vba.HRatioChroma[k]
1708                                                                                 > mode_lib->vba.MaxHSCLRatio
1709                                                                 || mode_lib->vba.VRatioChroma[k]
1710                                                                                 > mode_lib->vba.MaxVSCLRatio
1711                                                                 || mode_lib->vba.HRatioChroma[k]
1712                                                                                 > mode_lib->vba.HTAPsChroma[k]
1713                                                                 || mode_lib->vba.VRatioChroma[k]
1714                                                                                 > mode_lib->vba.VTAPsChroma[k]))) {
1715                         mode_lib->vba.ScaleRatioAndTapsSupport = false;
1716                 }
1717         }
1718
1719         /*Source Format, Pixel Format and Scan Support Check*/
1720         mode_lib->vba.SourceFormatPixelAndScanSupport = true;
1721         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1722                 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear
1723                         && (!(!IsVertical((enum dm_rotation_angle) mode_lib->vba.SourceScan[k]))
1724                                 || mode_lib->vba.DCCEnable[k] == true)) {
1725                         mode_lib->vba.SourceFormatPixelAndScanSupport = false;
1726                 }
1727         }
1728
1729         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1730                 dml32_CalculateBytePerPixelAndBlockSizes(
1731                                 mode_lib->vba.SourcePixelFormat[k],
1732                                 mode_lib->vba.SurfaceTiling[k],
1733
1734                                 /* Output */
1735                                 &mode_lib->vba.BytePerPixelY[k],
1736                                 &mode_lib->vba.BytePerPixelC[k],
1737                                 &mode_lib->vba.BytePerPixelInDETY[k],
1738                                 &mode_lib->vba.BytePerPixelInDETC[k],
1739                                 &mode_lib->vba.Read256BlockHeightY[k],
1740                                 &mode_lib->vba.Read256BlockHeightC[k],
1741                                 &mode_lib->vba.Read256BlockWidthY[k],
1742                                 &mode_lib->vba.Read256BlockWidthC[k],
1743                                 &mode_lib->vba.MicroTileHeightY[k],
1744                                 &mode_lib->vba.MicroTileHeightC[k],
1745                                 &mode_lib->vba.MicroTileWidthY[k],
1746                                 &mode_lib->vba.MicroTileWidthC[k]);
1747         }
1748
1749         /*Bandwidth Support Check*/
1750         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1751                 if (!IsVertical(mode_lib->vba.SourceRotation[k])) {
1752                         v->SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportWidth[k];
1753                         v->SwathWidthCSingleDPP[k] = mode_lib->vba.ViewportWidthChroma[k];
1754                 } else {
1755                         v->SwathWidthYSingleDPP[k] = mode_lib->vba.ViewportHeight[k];
1756                         v->SwathWidthCSingleDPP[k] = mode_lib->vba.ViewportHeightChroma[k];
1757                 }
1758         }
1759         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1760                 v->ReadBandwidthLuma[k] = v->SwathWidthYSingleDPP[k] * dml_ceil(v->BytePerPixelInDETY[k], 1.0)
1761                                 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k];
1762                 v->ReadBandwidthChroma[k] = v->SwathWidthYSingleDPP[k] / 2 * dml_ceil(v->BytePerPixelInDETC[k], 2.0)
1763                                 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k]
1764                                 / 2.0;
1765         }
1766         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1767                 if (mode_lib->vba.WritebackEnable[k] == true && mode_lib->vba.WritebackPixelFormat[k] == dm_444_64) {
1768                         v->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k]
1769                                         * mode_lib->vba.WritebackDestinationHeight[k]
1770                                         / (mode_lib->vba.WritebackSourceHeight[k] * mode_lib->vba.HTotal[k]
1771                                                         / mode_lib->vba.PixelClock[k]) * 8.0;
1772                 } else if (mode_lib->vba.WritebackEnable[k] == true) {
1773                         v->WriteBandwidth[k] = mode_lib->vba.WritebackDestinationWidth[k]
1774                                         * mode_lib->vba.WritebackDestinationHeight[k]
1775                                         / (mode_lib->vba.WritebackSourceHeight[k] * mode_lib->vba.HTotal[k]
1776                                                         / mode_lib->vba.PixelClock[k]) * 4.0;
1777                 } else {
1778                         v->WriteBandwidth[k] = 0.0;
1779                 }
1780         }
1781
1782         /*Writeback Latency support check*/
1783
1784         mode_lib->vba.WritebackLatencySupport = true;
1785         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1786                 if (mode_lib->vba.WritebackEnable[k] == true
1787                                 && (v->WriteBandwidth[k]
1788                                                 > mode_lib->vba.WritebackInterfaceBufferSize * 1024
1789                                                                 / mode_lib->vba.WritebackLatency)) {
1790                         mode_lib->vba.WritebackLatencySupport = false;
1791                 }
1792         }
1793
1794         /*Writeback Mode Support Check*/
1795         mode_lib->vba.EnoughWritebackUnits = true;
1796         mode_lib->vba.TotalNumberOfActiveWriteback = 0;
1797         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1798                 if (mode_lib->vba.WritebackEnable[k] == true)
1799                         mode_lib->vba.TotalNumberOfActiveWriteback = mode_lib->vba.TotalNumberOfActiveWriteback + 1;
1800         }
1801
1802         if (mode_lib->vba.TotalNumberOfActiveWriteback > mode_lib->vba.MaxNumWriteback)
1803                 mode_lib->vba.EnoughWritebackUnits = false;
1804
1805         /*Writeback Scale Ratio and Taps Support Check*/
1806         mode_lib->vba.WritebackScaleRatioAndTapsSupport = true;
1807         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1808                 if (mode_lib->vba.WritebackEnable[k] == true) {
1809                         if (mode_lib->vba.WritebackHRatio[k] > mode_lib->vba.WritebackMaxHSCLRatio
1810                                         || mode_lib->vba.WritebackVRatio[k] > mode_lib->vba.WritebackMaxVSCLRatio
1811                                         || mode_lib->vba.WritebackHRatio[k] < mode_lib->vba.WritebackMinHSCLRatio
1812                                         || mode_lib->vba.WritebackVRatio[k] < mode_lib->vba.WritebackMinVSCLRatio
1813                                         || mode_lib->vba.WritebackHTaps[k] > mode_lib->vba.WritebackMaxHSCLTaps
1814                                         || mode_lib->vba.WritebackVTaps[k] > mode_lib->vba.WritebackMaxVSCLTaps
1815                                         || mode_lib->vba.WritebackHRatio[k] > mode_lib->vba.WritebackHTaps[k]
1816                                         || mode_lib->vba.WritebackVRatio[k] > mode_lib->vba.WritebackVTaps[k]
1817                                         || (mode_lib->vba.WritebackHTaps[k] > 2.0
1818                                                         && ((mode_lib->vba.WritebackHTaps[k] % 2) == 1))) {
1819                                 mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
1820                         }
1821                         if (2.0 * mode_lib->vba.WritebackDestinationWidth[k] * (mode_lib->vba.WritebackVTaps[k] - 1)
1822                                         * 57 > mode_lib->vba.WritebackLineBufferSize) {
1823                                 mode_lib->vba.WritebackScaleRatioAndTapsSupport = false;
1824                         }
1825                 }
1826         }
1827
1828         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1829                 dml32_CalculateSinglePipeDPPCLKAndSCLThroughput(mode_lib->vba.HRatio[k], mode_lib->vba.HRatioChroma[k],
1830                                 mode_lib->vba.VRatio[k], mode_lib->vba.VRatioChroma[k],
1831                                 mode_lib->vba.MaxDCHUBToPSCLThroughput, mode_lib->vba.MaxPSCLToLBThroughput,
1832                                 mode_lib->vba.PixelClock[k], mode_lib->vba.SourcePixelFormat[k],
1833                                 mode_lib->vba.htaps[k], mode_lib->vba.HTAPsChroma[k], mode_lib->vba.vtaps[k],
1834                                 mode_lib->vba.VTAPsChroma[k],
1835                                 /* Output */
1836                                 &mode_lib->vba.PSCL_FACTOR[k], &mode_lib->vba.PSCL_FACTOR_CHROMA[k],
1837                                 &mode_lib->vba.MinDPPCLKUsingSingleDPP[k]);
1838         }
1839
1840         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
1841
1842                 if (mode_lib->vba.SurfaceTiling[k] == dm_sw_linear) {
1843                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 8192;
1844                 } else if (!IsVertical(mode_lib->vba.SourceRotation[k]) && v->BytePerPixelC[k] > 0
1845                                 && mode_lib->vba.SourcePixelFormat[k] != dm_rgbe_alpha) {
1846                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 7680;
1847                 } else if (IsVertical(mode_lib->vba.SourceRotation[k]) && v->BytePerPixelC[k] > 0
1848                                 && mode_lib->vba.SourcePixelFormat[k] != dm_rgbe_alpha) {
1849                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 4320;
1850                 } else if (mode_lib->vba.SourcePixelFormat[k] == dm_rgbe_alpha) {
1851                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 3840;
1852                 } else if (IsVertical(mode_lib->vba.SourceRotation[k]) && v->BytePerPixelY[k] == 8 &&
1853                                 mode_lib->vba.DCCEnable[k] == true) {
1854                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 3072;
1855                 } else {
1856                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma = 6144;
1857                 }
1858
1859                 if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8 || mode_lib->vba.SourcePixelFormat[k] == dm_420_10
1860                                 || mode_lib->vba.SourcePixelFormat[k] == dm_420_12) {
1861                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportChroma = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma / 2.0;
1862                 } else {
1863                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportChroma = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma;
1864                 }
1865                 v->MaximumSwathWidthInLineBufferLuma = mode_lib->vba.LineBufferSizeFinal
1866                                 * dml_max(mode_lib->vba.HRatio[k], 1.0) / mode_lib->vba.LBBitPerPixel[k]
1867                                 / (mode_lib->vba.vtaps[k] + dml_max(dml_ceil(mode_lib->vba.VRatio[k], 1.0) - 2, 0.0));
1868                 if (v->BytePerPixelC[k] == 0.0) {
1869                         v->MaximumSwathWidthInLineBufferChroma = 0;
1870                 } else {
1871                         v->MaximumSwathWidthInLineBufferChroma = mode_lib->vba.LineBufferSizeFinal
1872                                         * dml_max(mode_lib->vba.HRatioChroma[k], 1.0) / mode_lib->vba.LBBitPerPixel[k]
1873                                         / (mode_lib->vba.VTAPsChroma[k]
1874                                                         + dml_max(dml_ceil(mode_lib->vba.VRatioChroma[k], 1.0) - 2,
1875                                                                         0.0));
1876                 }
1877                 v->MaximumSwathWidthLuma[k] = dml_min(v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportLuma,
1878                                 v->MaximumSwathWidthInLineBufferLuma);
1879                 v->MaximumSwathWidthChroma[k] = dml_min(v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaximumSwathWidthSupportChroma,
1880                                 v->MaximumSwathWidthInLineBufferChroma);
1881         }
1882
1883         dml32_CalculateSwathAndDETConfiguration(
1884                         &v->dummy_vars.dml32_CalculateSwathAndDETConfiguration,
1885                         mode_lib->vba.DETSizeOverride,
1886                         mode_lib->vba.UsesMALLForPStateChange,
1887                         mode_lib->vba.ConfigReturnBufferSizeInKByte,
1888                         mode_lib->vba.MaxTotalDETInKByte,
1889                         mode_lib->vba.MinCompressedBufferSizeInKByte,
1890                         1, /* ForceSingleDPP */
1891                         mode_lib->vba.NumberOfActiveSurfaces,
1892                         mode_lib->vba.nomDETInKByte,
1893                         mode_lib->vba.UseUnboundedRequesting,
1894                         mode_lib->vba.DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment,
1895                         mode_lib->vba.ip.pixel_chunk_size_kbytes,
1896                         mode_lib->vba.ip.rob_buffer_size_kbytes,
1897                         mode_lib->vba.CompressedBufferSegmentSizeInkByteFinal,
1898                         mode_lib->vba.Output,
1899                         mode_lib->vba.ReadBandwidthLuma,
1900                         mode_lib->vba.ReadBandwidthChroma,
1901                         mode_lib->vba.MaximumSwathWidthLuma,
1902                         mode_lib->vba.MaximumSwathWidthChroma,
1903                         mode_lib->vba.SourceRotation,
1904                         mode_lib->vba.ViewportStationary,
1905                         mode_lib->vba.SourcePixelFormat,
1906                         mode_lib->vba.SurfaceTiling,
1907                         mode_lib->vba.ViewportWidth,
1908                         mode_lib->vba.ViewportHeight,
1909                         mode_lib->vba.ViewportXStartY,
1910                         mode_lib->vba.ViewportYStartY,
1911                         mode_lib->vba.ViewportXStartC,
1912                         mode_lib->vba.ViewportYStartC,
1913                         mode_lib->vba.SurfaceWidthY,
1914                         mode_lib->vba.SurfaceWidthC,
1915                         mode_lib->vba.SurfaceHeightY,
1916                         mode_lib->vba.SurfaceHeightC,
1917                         mode_lib->vba.Read256BlockHeightY,
1918                         mode_lib->vba.Read256BlockHeightC,
1919                         mode_lib->vba.Read256BlockWidthY,
1920                         mode_lib->vba.Read256BlockWidthC,
1921                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_odm_mode,
1922                         mode_lib->vba.BlendingAndTiming,
1923                         mode_lib->vba.BytePerPixelY,
1924                         mode_lib->vba.BytePerPixelC,
1925                         mode_lib->vba.BytePerPixelInDETY,
1926                         mode_lib->vba.BytePerPixelInDETC,
1927                         mode_lib->vba.HActive,
1928                         mode_lib->vba.HRatio,
1929                         mode_lib->vba.HRatioChroma,
1930                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[0], /*  Integer DPPPerSurface[] */
1931
1932                         /* Output */
1933                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[1], /* Long            swath_width_luma_ub[] */
1934                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[2], /* Long            swath_width_chroma_ub[]  */
1935                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_double_array[0], /* Long            SwathWidth[]  */
1936                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_double_array[1], /* Long            SwathWidthChroma[]  */
1937                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[3], /* Integer         SwathHeightY[]  */
1938                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[4], /* Integer         SwathHeightC[]  */
1939                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[5], /* Long            DETBufferSizeInKByte[]  */
1940                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[6], /* Long            DETBufferSizeY[]  */
1941                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[7], /* Long            DETBufferSizeC[]  */
1942                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[0][0], /* bool           *UnboundedRequestEnabled  */
1943                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[0][0], /* Long           *CompressedBufferSizeInkByte  */
1944                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[1][0], /* Long           *CompBufReservedSpaceKBytes */
1945                         &CompBufReservedSpaceNeedAdjustmentSingleDPP,
1946                         mode_lib->vba.SingleDPPViewportSizeSupportPerSurface,/* bool ViewportSizeSupportPerSurface[] */
1947                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[1][0]); /* bool           *ViewportSizeSupport */
1948
1949         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsNeededForPStateChangeAndVoltage = false;
1950         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsPossible = false;
1951
1952         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1953                 if (mode_lib->vba.MPCCombineUse[k] == dm_mpc_reduce_voltage_and_clocks)
1954                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsNeededForPStateChangeAndVoltage = true;
1955                 if (mode_lib->vba.MPCCombineUse[k] == dm_mpc_always_when_possible)
1956                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsPossible = true;
1957         }
1958         mode_lib->vba.MPCCombineMethodIncompatible = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsNeededForPStateChangeAndVoltage
1959                         && v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MPCCombineMethodAsPossible;
1960
1961         for (i = 0; i < v->soc.num_states; i++) {
1962                 for (j = 0; j < 2; j++) {
1963                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] = 0;
1964                         mode_lib->vba.TotalAvailablePipesSupport[i][j] = true;
1965                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeNoDSC = dm_odm_combine_mode_disabled;
1966                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeDSC = dm_odm_combine_mode_disabled;
1967
1968                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
1969                                 dml32_CalculateODMMode(
1970                                                 mode_lib->vba.MaximumPixelsPerLinePerDSCUnit,
1971                                                 mode_lib->vba.HActive[k],
1972                                                 mode_lib->vba.Output[k],
1973                                                 mode_lib->vba.ODMUse[k],
1974                                                 mode_lib->vba.MaxDispclk[i],
1975                                                 mode_lib->vba.MaxDispclk[v->soc.num_states - 1],
1976                                                 false,
1977                                                 mode_lib->vba.TotalNumberOfActiveDPP[i][j],
1978                                                 mode_lib->vba.MaxNumDPP,
1979                                                 mode_lib->vba.PixelClock[k],
1980                                                 mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
1981                                                 mode_lib->vba.DISPCLKRampingMargin,
1982                                                 mode_lib->vba.DISPCLKDPPCLKVCOSpeed,
1983
1984                                                 /* Output */
1985                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalAvailablePipesSupportNoDSC,
1986                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NumberOfDPPNoDSC,
1987                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeNoDSC,
1988                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.RequiredDISPCLKPerSurfaceNoDSC);
1989
1990                                 dml32_CalculateODMMode(
1991                                                 mode_lib->vba.MaximumPixelsPerLinePerDSCUnit,
1992                                                 mode_lib->vba.HActive[k],
1993                                                 mode_lib->vba.Output[k],
1994                                                 mode_lib->vba.ODMUse[k],
1995                                                 mode_lib->vba.MaxDispclk[i],
1996                                                 mode_lib->vba.MaxDispclk[v->soc.num_states - 1],
1997                                                 true,
1998                                                 mode_lib->vba.TotalNumberOfActiveDPP[i][j],
1999                                                 mode_lib->vba.MaxNumDPP,
2000                                                 mode_lib->vba.PixelClock[k],
2001                                                 mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
2002                                                 mode_lib->vba.DISPCLKRampingMargin,
2003                                                 mode_lib->vba.DISPCLKDPPCLKVCOSpeed,
2004
2005                                                 /* Output */
2006                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalAvailablePipesSupportDSC,
2007                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NumberOfDPPDSC,
2008                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeDSC,
2009                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.RequiredDISPCLKPerSurfaceDSC);
2010
2011                                 dml32_CalculateOutputLink(
2012                                                 mode_lib->vba.PHYCLKPerState[i],
2013                                                 mode_lib->vba.PHYCLKD18PerState[i],
2014                                                 mode_lib->vba.PHYCLKD32PerState[i],
2015                                                 mode_lib->vba.Downspreading,
2016                                                 (mode_lib->vba.BlendingAndTiming[k] == k),
2017                                                 mode_lib->vba.Output[k],
2018                                                 mode_lib->vba.OutputFormat[k],
2019                                                 mode_lib->vba.HTotal[k],
2020                                                 mode_lib->vba.HActive[k],
2021                                                 mode_lib->vba.PixelClockBackEnd[k],
2022                                                 mode_lib->vba.ForcedOutputLinkBPP[k],
2023                                                 mode_lib->vba.DSCInputBitPerComponent[k],
2024                                                 mode_lib->vba.NumberOfDSCSlices[k],
2025                                                 mode_lib->vba.AudioSampleRate[k],
2026                                                 mode_lib->vba.AudioSampleLayout[k],
2027                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeNoDSC,
2028                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeDSC,
2029                                                 mode_lib->vba.DSCEnable[k],
2030                                                 mode_lib->vba.OutputLinkDPLanes[k],
2031                                                 mode_lib->vba.OutputLinkDPRate[k],
2032
2033                                                 /* Output */
2034                                                 &mode_lib->vba.RequiresDSC[i][k],
2035                                                 &mode_lib->vba.RequiresFEC[i][k],
2036                                                 &mode_lib->vba.OutputBppPerState[i][k],
2037                                                 &mode_lib->vba.OutputTypePerState[i][k],
2038                                                 &mode_lib->vba.OutputRatePerState[i][k],
2039                                                 &mode_lib->vba.RequiredSlots[i][k]);
2040
2041                                 if (mode_lib->vba.RequiresDSC[i][k] == false) {
2042                                         mode_lib->vba.ODMCombineEnablePerState[i][k] = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeNoDSC;
2043                                         mode_lib->vba.RequiredDISPCLKPerSurface[i][j][k] =
2044                                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.RequiredDISPCLKPerSurfaceNoDSC;
2045                                         if (!v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalAvailablePipesSupportNoDSC)
2046                                                 mode_lib->vba.TotalAvailablePipesSupport[i][j] = false;
2047                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] =
2048                                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] + v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NumberOfDPPNoDSC;
2049                                 } else {
2050                                         mode_lib->vba.ODMCombineEnablePerState[i][k] = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ODMModeDSC;
2051                                         mode_lib->vba.RequiredDISPCLKPerSurface[i][j][k] =
2052                                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.RequiredDISPCLKPerSurfaceDSC;
2053                                         if (!v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalAvailablePipesSupportDSC)
2054                                                 mode_lib->vba.TotalAvailablePipesSupport[i][j] = false;
2055                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] =
2056                                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] + v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NumberOfDPPDSC;
2057                                 }
2058                         }
2059
2060                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2061                                 if (mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1) {
2062                                         mode_lib->vba.MPCCombine[i][j][k] = false;
2063                                         mode_lib->vba.NoOfDPP[i][j][k] = 4;
2064                                 } else if (mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
2065                                         mode_lib->vba.MPCCombine[i][j][k] = false;
2066                                         mode_lib->vba.NoOfDPP[i][j][k] = 2;
2067                                 } else if (mode_lib->vba.MPCCombineUse[k] == dm_mpc_never) {
2068                                         mode_lib->vba.MPCCombine[i][j][k] = false;
2069                                         mode_lib->vba.NoOfDPP[i][j][k] = 1;
2070                                 } else if (dml32_RoundToDFSGranularity(
2071                                                 mode_lib->vba.MinDPPCLKUsingSingleDPP[k]
2072                                                                 * (1 + mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading
2073                                                                                                 / 100), 1,
2074                                                 mode_lib->vba.DISPCLKDPPCLKVCOSpeed) <= mode_lib->vba.MaxDppclk[i] &&
2075                                 mode_lib->vba.SingleDPPViewportSizeSupportPerSurface[k] == true) {
2076                                         mode_lib->vba.MPCCombine[i][j][k] = false;
2077                                         mode_lib->vba.NoOfDPP[i][j][k] = 1;
2078                                 } else if (mode_lib->vba.TotalNumberOfActiveDPP[i][j] < mode_lib->vba.MaxNumDPP) {
2079                                         mode_lib->vba.MPCCombine[i][j][k] = true;
2080                                         mode_lib->vba.NoOfDPP[i][j][k] = 2;
2081                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] =
2082                                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] + 1;
2083                                 } else {
2084                                         mode_lib->vba.MPCCombine[i][j][k] = false;
2085                                         mode_lib->vba.NoOfDPP[i][j][k] = 1;
2086                                         mode_lib->vba.TotalAvailablePipesSupport[i][j] = false;
2087                                 }
2088                         }
2089
2090                         mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] = 0;
2091                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NoChroma = true;
2092
2093                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2094                                 if (mode_lib->vba.NoOfDPP[i][j][k] == 1)
2095                                         mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] =
2096                                                         mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] + 1;
2097                                 if (mode_lib->vba.SourcePixelFormat[k] == dm_420_8
2098                                                 || mode_lib->vba.SourcePixelFormat[k] == dm_420_10
2099                                                 || mode_lib->vba.SourcePixelFormat[k] == dm_420_12
2100                                                 || mode_lib->vba.SourcePixelFormat[k] == dm_rgbe_alpha) {
2101                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NoChroma = false;
2102                                 }
2103                         }
2104
2105                         // if TotalNumberOfActiveDPP is > 1, then there should be no unbounded req mode (hw limitation), the comp buf reserved adjustment is not needed regardless
2106                         // if TotalNumberOfActiveDPP is == 1, then will use the SingleDPP version of unbounded_req for the decision
2107                         CompBufReservedSpaceNeedAdjustment = (mode_lib->vba.TotalNumberOfActiveDPP[i][j] > 1) ? 0 : CompBufReservedSpaceNeedAdjustmentSingleDPP;
2108
2109
2110
2111                         if (j == 1 && !dml32_UnboundedRequest(mode_lib->vba.UseUnboundedRequesting,
2112                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j], v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NoChroma,
2113                                         mode_lib->vba.Output[0],
2114                                         mode_lib->vba.SurfaceTiling[0],
2115                                         CompBufReservedSpaceNeedAdjustment,
2116                                         mode_lib->vba.DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment)) {
2117                                 while (!(mode_lib->vba.TotalNumberOfActiveDPP[i][j] >= mode_lib->vba.MaxNumDPP
2118                                                 || mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] == 0)) {
2119                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.BWOfNonCombinedSurfaceOfMaximumBandwidth = 0;
2120                                         NumberOfNonCombinedSurfaceOfMaximumBandwidth = 0;
2121
2122                                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2123                                                 if (mode_lib->vba.MPCCombineUse[k]
2124                                                         != dm_mpc_never &&
2125                                                         mode_lib->vba.MPCCombineUse[k] != dm_mpc_reduce_voltage &&
2126                                                         mode_lib->vba.ReadBandwidthLuma[k] +
2127                                                         mode_lib->vba.ReadBandwidthChroma[k] >
2128                                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.BWOfNonCombinedSurfaceOfMaximumBandwidth &&
2129                                                         (mode_lib->vba.ODMCombineEnablePerState[i][k] !=
2130                                                         dm_odm_combine_mode_2to1 &&
2131                                                         mode_lib->vba.ODMCombineEnablePerState[i][k] !=
2132                                                         dm_odm_combine_mode_4to1) &&
2133                                                                 mode_lib->vba.MPCCombine[i][j][k] == false) {
2134                                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.BWOfNonCombinedSurfaceOfMaximumBandwidth =
2135                                                                 mode_lib->vba.ReadBandwidthLuma[k]
2136                                                                 + mode_lib->vba.ReadBandwidthChroma[k];
2137                                                         NumberOfNonCombinedSurfaceOfMaximumBandwidth = k;
2138                                                 }
2139                                         }
2140                                         mode_lib->vba.MPCCombine[i][j][NumberOfNonCombinedSurfaceOfMaximumBandwidth] =
2141                                                         true;
2142                                         mode_lib->vba.NoOfDPP[i][j][NumberOfNonCombinedSurfaceOfMaximumBandwidth] = 2;
2143                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] =
2144                                                         mode_lib->vba.TotalNumberOfActiveDPP[i][j] + 1;
2145                                         mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] =
2146                                                         mode_lib->vba.TotalNumberOfSingleDPPSurfaces[i][j] - 1;
2147                                 }
2148                         }
2149
2150                         //DISPCLK/DPPCLK
2151                         mode_lib->vba.WritebackRequiredDISPCLK = 0;
2152                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2153                                 if (mode_lib->vba.WritebackEnable[k]) {
2154                                         mode_lib->vba.WritebackRequiredDISPCLK = dml_max(
2155                                                         mode_lib->vba.WritebackRequiredDISPCLK,
2156                                                         dml32_CalculateWriteBackDISPCLK(
2157                                                                         mode_lib->vba.WritebackPixelFormat[k],
2158                                                                         mode_lib->vba.PixelClock[k],
2159                                                                         mode_lib->vba.WritebackHRatio[k],
2160                                                                         mode_lib->vba.WritebackVRatio[k],
2161                                                                         mode_lib->vba.WritebackHTaps[k],
2162                                                                         mode_lib->vba.WritebackVTaps[k],
2163                                                                         mode_lib->vba.WritebackSourceWidth[k],
2164                                                                         mode_lib->vba.WritebackDestinationWidth[k],
2165                                                                         mode_lib->vba.HTotal[k],
2166                                                                         mode_lib->vba.WritebackLineBufferSize,
2167                                                                         mode_lib->vba.DISPCLKDPPCLKVCOSpeed));
2168                                 }
2169                         }
2170
2171                         mode_lib->vba.RequiredDISPCLK[i][j] = mode_lib->vba.WritebackRequiredDISPCLK;
2172                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2173                                 mode_lib->vba.RequiredDISPCLK[i][j] = dml_max(mode_lib->vba.RequiredDISPCLK[i][j],
2174                                                 mode_lib->vba.RequiredDISPCLKPerSurface[i][j][k]);
2175                         }
2176
2177                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
2178                                 mode_lib->vba.NoOfDPPThisState[k] = mode_lib->vba.NoOfDPP[i][j][k];
2179
2180                         dml32_CalculateDPPCLK(mode_lib->vba.NumberOfActiveSurfaces,
2181                                         mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading,
2182                                         mode_lib->vba.DISPCLKDPPCLKVCOSpeed, mode_lib->vba.MinDPPCLKUsingSingleDPP,
2183                                         mode_lib->vba.NoOfDPPThisState,
2184                                         /* Output */
2185                                         &mode_lib->vba.GlobalDPPCLK, mode_lib->vba.RequiredDPPCLKThisState);
2186
2187                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k)
2188                                 mode_lib->vba.RequiredDPPCLK[i][j][k] = mode_lib->vba.RequiredDPPCLKThisState[k];
2189
2190                         mode_lib->vba.DISPCLK_DPPCLK_Support[i][j] = !((mode_lib->vba.RequiredDISPCLK[i][j]
2191                                         > mode_lib->vba.MaxDispclk[i])
2192                                         || (mode_lib->vba.GlobalDPPCLK > mode_lib->vba.MaxDppclk[i]));
2193
2194                         if (mode_lib->vba.TotalNumberOfActiveDPP[i][j] > mode_lib->vba.MaxNumDPP)
2195                                 mode_lib->vba.TotalAvailablePipesSupport[i][j] = false;
2196                 } // j
2197         } // i (VOLTAGE_STATE)
2198
2199         /* Total Available OTG, HDMIFRL, DP Support Check */
2200         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveOTG = 0;
2201         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveHDMIFRL = 0;
2202         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0 = 0;
2203         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0Outputs = 0;
2204
2205         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2206                 if (mode_lib->vba.BlendingAndTiming[k] == k) {
2207                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveOTG = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveOTG + 1;
2208                         if (mode_lib->vba.Output[k] == dm_dp2p0) {
2209                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0 = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0 + 1;
2210                                 if (mode_lib->vba.OutputMultistreamId[k]
2211                                                 == k || mode_lib->vba.OutputMultistreamEn[k] == false) {
2212                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0Outputs = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0Outputs + 1;
2213                                 }
2214                         }
2215                 }
2216         }
2217
2218         mode_lib->vba.NumberOfOTGSupport = (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveOTG <= mode_lib->vba.MaxNumOTG);
2219         mode_lib->vba.NumberOfHDMIFRLSupport = (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveHDMIFRL <= mode_lib->vba.MaxNumHDMIFRLOutputs);
2220         mode_lib->vba.NumberOfDP2p0Support = (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0 <= mode_lib->vba.MaxNumDP2p0Streams
2221                         && v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalNumberOfActiveDP2p0Outputs <= mode_lib->vba.MaxNumDP2p0Outputs);
2222
2223         /* Display IO and DSC Support Check */
2224         mode_lib->vba.NonsupportedDSCInputBPC = false;
2225         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2226                 if (!(mode_lib->vba.DSCInputBitPerComponent[k] == 12.0
2227                                 || mode_lib->vba.DSCInputBitPerComponent[k] == 10.0
2228                                 || mode_lib->vba.DSCInputBitPerComponent[k] == 8.0
2229                                 || mode_lib->vba.DSCInputBitPerComponent[k] >
2230                                 mode_lib->vba.MaximumDSCBitsPerComponent)) {
2231                         mode_lib->vba.NonsupportedDSCInputBPC = true;
2232                 }
2233         }
2234
2235         for (i = 0; i < v->soc.num_states; ++i) {
2236                 mode_lib->vba.ExceededMultistreamSlots[i] = false;
2237                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2238                         if (mode_lib->vba.OutputMultistreamEn[k] == true && mode_lib->vba.OutputMultistreamId[k] == k) {
2239                                 TotalSlots = mode_lib->vba.RequiredSlots[i][k];
2240                                 for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) {
2241                                         if (mode_lib->vba.OutputMultistreamId[j] == k)
2242                                                 TotalSlots = TotalSlots + mode_lib->vba.RequiredSlots[i][j];
2243                                 }
2244                                 if (mode_lib->vba.Output[k] == dm_dp && TotalSlots > 63)
2245                                         mode_lib->vba.ExceededMultistreamSlots[i] = true;
2246                                 if (mode_lib->vba.Output[k] == dm_dp2p0 && TotalSlots > 64)
2247                                         mode_lib->vba.ExceededMultistreamSlots[i] = true;
2248                         }
2249                 }
2250                 mode_lib->vba.LinkCapacitySupport[i] = true;
2251                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2252                         if (mode_lib->vba.BlendingAndTiming[k] == k
2253                                         && (mode_lib->vba.Output[k] == dm_dp || mode_lib->vba.Output[k] == dm_dp2p0
2254                                                         || mode_lib->vba.Output[k] == dm_edp
2255                                                         || mode_lib->vba.Output[k] == dm_hdmi)
2256                                         && mode_lib->vba.OutputBppPerState[i][k] == 0) {
2257                                 mode_lib->vba.LinkCapacitySupport[i] = false;
2258                         }
2259                 }
2260         }
2261
2262         mode_lib->vba.P2IWith420 = false;
2263         mode_lib->vba.DSCOnlyIfNecessaryWithBPP = false;
2264         mode_lib->vba.DSC422NativeNotSupported = false;
2265         mode_lib->vba.LinkRateDoesNotMatchDPVersion = false;
2266         mode_lib->vba.LinkRateForMultistreamNotIndicated = false;
2267         mode_lib->vba.BPPForMultistreamNotIndicated = false;
2268         mode_lib->vba.MultistreamWithHDMIOreDP = false;
2269         mode_lib->vba.MSOOrODMSplitWithNonDPLink = false;
2270         mode_lib->vba.NotEnoughLanesForMSO = false;
2271
2272         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2273                 if (mode_lib->vba.BlendingAndTiming[k] == k
2274                                 && (mode_lib->vba.Output[k] == dm_dp || mode_lib->vba.Output[k] == dm_dp2p0
2275                                                 || mode_lib->vba.Output[k] == dm_edp
2276                                                 || mode_lib->vba.Output[k] == dm_hdmi)) {
2277                         if (mode_lib->vba.OutputFormat[k]
2278                                         == dm_420 && mode_lib->vba.Interlace[k] == 1 &&
2279                                         mode_lib->vba.ProgressiveToInterlaceUnitInOPP == true)
2280                                 mode_lib->vba.P2IWith420 = true;
2281
2282                         if (mode_lib->vba.DSCEnable[k] && mode_lib->vba.ForcedOutputLinkBPP[k] != 0)
2283                                 mode_lib->vba.DSCOnlyIfNecessaryWithBPP = true;
2284                         if ((mode_lib->vba.DSCEnable[k] || mode_lib->vba.DSCEnable[k])
2285                                         && mode_lib->vba.OutputFormat[k] == dm_n422
2286                                         && !mode_lib->vba.DSC422NativeSupport)
2287                                 mode_lib->vba.DSC422NativeNotSupported = true;
2288
2289                         if (((mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_hbr
2290                                         || mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_hbr2
2291                                         || mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_hbr3)
2292                                         && mode_lib->vba.Output[k] != dm_dp && mode_lib->vba.Output[k] != dm_edp)
2293                                         || ((mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_uhbr10
2294                                                         || mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_uhbr13p5
2295                                                         || mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_uhbr20)
2296                                                         && mode_lib->vba.Output[k] != dm_dp2p0))
2297                                 mode_lib->vba.LinkRateDoesNotMatchDPVersion = true;
2298
2299                         if (mode_lib->vba.OutputMultistreamEn[k] == true) {
2300                                 if (mode_lib->vba.OutputMultistreamId[k] == k
2301                                         && mode_lib->vba.OutputLinkDPRate[k] == dm_dp_rate_na)
2302                                         mode_lib->vba.LinkRateForMultistreamNotIndicated = true;
2303                                 if (mode_lib->vba.OutputMultistreamId[k] == k && mode_lib->vba.ForcedOutputLinkBPP[k] == 0)
2304                                         mode_lib->vba.BPPForMultistreamNotIndicated = true;
2305                                 for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) {
2306                                         if (mode_lib->vba.OutputMultistreamId[k] == j && mode_lib->vba.OutputMultistreamEn[k]
2307                                                 && mode_lib->vba.ForcedOutputLinkBPP[k] == 0)
2308                                                 mode_lib->vba.BPPForMultistreamNotIndicated = true;
2309                                 }
2310                         }
2311
2312                         if ((mode_lib->vba.Output[k] == dm_edp || mode_lib->vba.Output[k] == dm_hdmi)) {
2313                                 if (mode_lib->vba.OutputMultistreamId[k] == k && mode_lib->vba.OutputMultistreamEn[k])
2314                                         mode_lib->vba.MultistreamWithHDMIOreDP = true;
2315
2316                                 for (j = 0; j < mode_lib->vba.NumberOfActiveSurfaces; ++j) {
2317                                         if (mode_lib->vba.OutputMultistreamEn[k] == true && mode_lib->vba.OutputMultistreamId[k] == j)
2318                                                 mode_lib->vba.MultistreamWithHDMIOreDP = true;
2319                                 }
2320                         }
2321
2322                         if (mode_lib->vba.Output[k] != dm_dp
2323                                         && (mode_lib->vba.ODMUse[k] == dm_odm_split_policy_1to2
2324                                                         || mode_lib->vba.ODMUse[k] == dm_odm_mso_policy_1to2
2325                                                         || mode_lib->vba.ODMUse[k] == dm_odm_mso_policy_1to4))
2326                                 mode_lib->vba.MSOOrODMSplitWithNonDPLink = true;
2327
2328                         if ((mode_lib->vba.ODMUse[k] == dm_odm_mso_policy_1to2
2329                                         && mode_lib->vba.OutputLinkDPLanes[k] < 2)
2330                                         || (mode_lib->vba.ODMUse[k] == dm_odm_mso_policy_1to4
2331                                                         && mode_lib->vba.OutputLinkDPLanes[k] < 4))
2332                                 mode_lib->vba.NotEnoughLanesForMSO = true;
2333                 }
2334         }
2335
2336         for (i = 0; i < v->soc.num_states; ++i) {
2337                 mode_lib->vba.DTBCLKRequiredMoreThanSupported[i] = false;
2338                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2339                         if (mode_lib->vba.BlendingAndTiming[k] == k
2340                                         && dml32_RequiredDTBCLK(mode_lib->vba.RequiresDSC[i][k],
2341                                                         mode_lib->vba.PixelClockBackEnd[k],
2342                                                         mode_lib->vba.OutputFormat[k],
2343                                                         mode_lib->vba.OutputBppPerState[i][k],
2344                                                         mode_lib->vba.NumberOfDSCSlices[k], mode_lib->vba.HTotal[k],
2345                                                         mode_lib->vba.HActive[k], mode_lib->vba.AudioSampleRate[k],
2346                                                         mode_lib->vba.AudioSampleLayout[k])
2347                                                         > mode_lib->vba.DTBCLKPerState[i]) {
2348                                 mode_lib->vba.DTBCLKRequiredMoreThanSupported[i] = true;
2349                         }
2350                 }
2351         }
2352
2353         for (i = 0; i < v->soc.num_states; ++i) {
2354                 mode_lib->vba.ODMCombine2To1SupportCheckOK[i] = true;
2355                 mode_lib->vba.ODMCombine4To1SupportCheckOK[i] = true;
2356                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2357                         if (mode_lib->vba.BlendingAndTiming[k] == k
2358                                         && mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1
2359                                         && mode_lib->vba.Output[k] == dm_hdmi) {
2360                                 mode_lib->vba.ODMCombine2To1SupportCheckOK[i] = false;
2361                         }
2362                         if (mode_lib->vba.BlendingAndTiming[k] == k
2363                                         && mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1
2364                                         && (mode_lib->vba.Output[k] == dm_dp || mode_lib->vba.Output[k] == dm_edp
2365                                                         || mode_lib->vba.Output[k] == dm_hdmi)) {
2366                                 mode_lib->vba.ODMCombine4To1SupportCheckOK[i] = false;
2367                         }
2368                 }
2369         }
2370
2371         for (i = 0; i < v->soc.num_states; i++) {
2372                 mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] = false;
2373                 for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2374                         if (mode_lib->vba.BlendingAndTiming[k] == k) {
2375                                 if (mode_lib->vba.Output[k] == dm_dp || mode_lib->vba.Output[k] == dm_dp2p0
2376                                                 || mode_lib->vba.Output[k] == dm_edp) {
2377                                         if (mode_lib->vba.OutputFormat[k] == dm_420) {
2378                                                 mode_lib->vba.DSCFormatFactor = 2;
2379                                         } else if (mode_lib->vba.OutputFormat[k] == dm_444) {
2380                                                 mode_lib->vba.DSCFormatFactor = 1;
2381                                         } else if (mode_lib->vba.OutputFormat[k] == dm_n422) {
2382                                                 mode_lib->vba.DSCFormatFactor = 2;
2383                                         } else {
2384                                                 mode_lib->vba.DSCFormatFactor = 1;
2385                                         }
2386                                         if (mode_lib->vba.RequiresDSC[i][k] == true) {
2387                                                 if (mode_lib->vba.ODMCombineEnablePerState[i][k]
2388                                                                 == dm_odm_combine_mode_4to1) {
2389                                                         if (mode_lib->vba.PixelClockBackEnd[k] / 12.0 / mode_lib->vba.DSCFormatFactor > (1.0 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * mode_lib->vba.MaxDSCCLK[i])
2390                                                                 mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] = true;
2391                                                 } else if (mode_lib->vba.ODMCombineEnablePerState[i][k]
2392                                                                 == dm_odm_combine_mode_2to1) {
2393                                                         if (mode_lib->vba.PixelClockBackEnd[k] / 6.0 / mode_lib->vba.DSCFormatFactor > (1.0 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * mode_lib->vba.MaxDSCCLK[i])
2394                                                                 mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] = true;
2395                                                 } else {
2396                                                         if (mode_lib->vba.PixelClockBackEnd[k] / 3.0 / mode_lib->vba.DSCFormatFactor > (1.0 - mode_lib->vba.DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * mode_lib->vba.MaxDSCCLK[i])
2397                                                                 mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] = true;
2398                                                 }
2399                                         }
2400                                 }
2401                         }
2402                 }
2403         }
2404
2405         /* Check DSC Unit and Slices Support */
2406         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = 0;
2407
2408         for (i = 0; i < v->soc.num_states; ++i) {
2409                 mode_lib->vba.NotEnoughDSCUnits[i] = false;
2410                 mode_lib->vba.NotEnoughDSCSlices[i] = false;
2411                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = 0;
2412                 mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i] = true;
2413                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2414                         if (mode_lib->vba.RequiresDSC[i][k] == true) {
2415                                 if (mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1) {
2416                                         if (mode_lib->vba.HActive[k]
2417                                                         > 4 * mode_lib->vba.MaximumPixelsPerLinePerDSCUnit)
2418                                                 mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i] = false;
2419                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired + 4;
2420                                         if (mode_lib->vba.NumberOfDSCSlices[k] > 16)
2421                                                 mode_lib->vba.NotEnoughDSCSlices[i] = true;
2422                                 } else if (mode_lib->vba.ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) {
2423                                         if (mode_lib->vba.HActive[k]
2424                                                         > 2 * mode_lib->vba.MaximumPixelsPerLinePerDSCUnit)
2425                                                 mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i] = false;
2426                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired + 2;
2427                                         if (mode_lib->vba.NumberOfDSCSlices[k] > 8)
2428                                                 mode_lib->vba.NotEnoughDSCSlices[i] = true;
2429                                 } else {
2430                                         if (mode_lib->vba.HActive[k] > mode_lib->vba.MaximumPixelsPerLinePerDSCUnit)
2431                                                 mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i] = false;
2432                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired + 1;
2433                                         if (mode_lib->vba.NumberOfDSCSlices[k] > 4)
2434                                                 mode_lib->vba.NotEnoughDSCSlices[i] = true;
2435                                 }
2436                         }
2437                 }
2438                 if (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.TotalDSCUnitsRequired > mode_lib->vba.NumberOfDSC)
2439                         mode_lib->vba.NotEnoughDSCUnits[i] = true;
2440         }
2441
2442         /*DSC Delay per state*/
2443         for (i = 0; i < v->soc.num_states; ++i) {
2444                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2445                         mode_lib->vba.DSCDelayPerState[i][k] = dml32_DSCDelayRequirement(
2446                                         mode_lib->vba.RequiresDSC[i][k], mode_lib->vba.ODMCombineEnablePerState[i][k],
2447                                         mode_lib->vba.DSCInputBitPerComponent[k],
2448                                         mode_lib->vba.OutputBppPerState[i][k], mode_lib->vba.HActive[k],
2449                                         mode_lib->vba.HTotal[k], mode_lib->vba.NumberOfDSCSlices[k],
2450                                         mode_lib->vba.OutputFormat[k], mode_lib->vba.Output[k],
2451                                         mode_lib->vba.PixelClock[k], mode_lib->vba.PixelClockBackEnd[k]);
2452                 }
2453
2454                 m = 0;
2455
2456                 for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2457                         for (m = 0; m <= mode_lib->vba.NumberOfActiveSurfaces - 1; m++) {
2458                                 for (j = 0; j <= mode_lib->vba.NumberOfActiveSurfaces - 1; j++) {
2459                                         if (mode_lib->vba.BlendingAndTiming[k] == m &&
2460                                                         mode_lib->vba.RequiresDSC[i][m] == true) {
2461                                                 mode_lib->vba.DSCDelayPerState[i][k] =
2462                                                         mode_lib->vba.DSCDelayPerState[i][m];
2463                                         }
2464                                 }
2465                         }
2466                 }
2467         }
2468
2469         //Calculate Swath, DET Configuration, DCFCLKDeepSleep
2470         //
2471         for (i = 0; i < (int) v->soc.num_states; ++i) {
2472                 for (j = 0; j <= 1; ++j) {
2473                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2474                                 mode_lib->vba.RequiredDPPCLKThisState[k] = mode_lib->vba.RequiredDPPCLK[i][j][k];
2475                                 mode_lib->vba.NoOfDPPThisState[k] = mode_lib->vba.NoOfDPP[i][j][k];
2476                                 mode_lib->vba.ODMCombineEnableThisState[k] =
2477                                                 mode_lib->vba.ODMCombineEnablePerState[i][k];
2478                         }
2479
2480                         dml32_CalculateSwathAndDETConfiguration(
2481                                         &v->dummy_vars.dml32_CalculateSwathAndDETConfiguration,
2482                                         mode_lib->vba.DETSizeOverride,
2483                                         mode_lib->vba.UsesMALLForPStateChange,
2484                                         mode_lib->vba.ConfigReturnBufferSizeInKByte,
2485                                         mode_lib->vba.MaxTotalDETInKByte,
2486                                         mode_lib->vba.MinCompressedBufferSizeInKByte,
2487                                         false, /* ForceSingleDPP */
2488                                         mode_lib->vba.NumberOfActiveSurfaces,
2489                                         mode_lib->vba.nomDETInKByte,
2490                                         mode_lib->vba.UseUnboundedRequesting,
2491                                         mode_lib->vba.DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment,
2492                                         mode_lib->vba.ip.pixel_chunk_size_kbytes,
2493                                         mode_lib->vba.ip.rob_buffer_size_kbytes,
2494                                         mode_lib->vba.CompressedBufferSegmentSizeInkByteFinal,
2495                                         mode_lib->vba.Output,
2496                                         mode_lib->vba.ReadBandwidthLuma,
2497                                         mode_lib->vba.ReadBandwidthChroma,
2498                                         mode_lib->vba.MaximumSwathWidthLuma,
2499                                         mode_lib->vba.MaximumSwathWidthChroma,
2500                                         mode_lib->vba.SourceRotation,
2501                                         mode_lib->vba.ViewportStationary,
2502                                         mode_lib->vba.SourcePixelFormat,
2503                                         mode_lib->vba.SurfaceTiling,
2504                                         mode_lib->vba.ViewportWidth,
2505                                         mode_lib->vba.ViewportHeight,
2506                                         mode_lib->vba.ViewportXStartY,
2507                                         mode_lib->vba.ViewportYStartY,
2508                                         mode_lib->vba.ViewportXStartC,
2509                                         mode_lib->vba.ViewportYStartC,
2510                                         mode_lib->vba.SurfaceWidthY,
2511                                         mode_lib->vba.SurfaceWidthC,
2512                                         mode_lib->vba.SurfaceHeightY,
2513                                         mode_lib->vba.SurfaceHeightC,
2514                                         mode_lib->vba.Read256BlockHeightY,
2515                                         mode_lib->vba.Read256BlockHeightC,
2516                                         mode_lib->vba.Read256BlockWidthY,
2517                                         mode_lib->vba.Read256BlockWidthC,
2518                                         mode_lib->vba.ODMCombineEnableThisState,
2519                                         mode_lib->vba.BlendingAndTiming,
2520                                         mode_lib->vba.BytePerPixelY,
2521                                         mode_lib->vba.BytePerPixelC,
2522                                         mode_lib->vba.BytePerPixelInDETY,
2523                                         mode_lib->vba.BytePerPixelInDETC,
2524                                         mode_lib->vba.HActive,
2525                                         mode_lib->vba.HRatio,
2526                                         mode_lib->vba.HRatioChroma,
2527                                         mode_lib->vba.NoOfDPPThisState,
2528                                         /* Output */
2529                                         mode_lib->vba.swath_width_luma_ub_this_state,
2530                                         mode_lib->vba.swath_width_chroma_ub_this_state,
2531                                         mode_lib->vba.SwathWidthYThisState,
2532                                         mode_lib->vba.SwathWidthCThisState,
2533                                         mode_lib->vba.SwathHeightYThisState,
2534                                         mode_lib->vba.SwathHeightCThisState,
2535                                         mode_lib->vba.DETBufferSizeInKByteThisState,
2536                                         mode_lib->vba.DETBufferSizeYThisState,
2537                                         mode_lib->vba.DETBufferSizeCThisState,
2538                                         &mode_lib->vba.UnboundedRequestEnabledThisState,
2539                                         &mode_lib->vba.CompressedBufferSizeInkByteThisState,
2540                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer[0], /* Long CompBufReservedSpaceKBytes */
2541                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean[0], /* bool CompBufReservedSpaceNeedAdjustment */
2542                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[0],
2543                                         &mode_lib->vba.ViewportSizeSupport[i][j]);
2544
2545                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2546                                 mode_lib->vba.swath_width_luma_ub_all_states[i][j][k] =
2547                                                 mode_lib->vba.swath_width_luma_ub_this_state[k];
2548                                 mode_lib->vba.swath_width_chroma_ub_all_states[i][j][k] =
2549                                                 mode_lib->vba.swath_width_chroma_ub_this_state[k];
2550                                 mode_lib->vba.SwathWidthYAllStates[i][j][k] = mode_lib->vba.SwathWidthYThisState[k];
2551                                 mode_lib->vba.SwathWidthCAllStates[i][j][k] = mode_lib->vba.SwathWidthCThisState[k];
2552                                 mode_lib->vba.SwathHeightYAllStates[i][j][k] = mode_lib->vba.SwathHeightYThisState[k];
2553                                 mode_lib->vba.SwathHeightCAllStates[i][j][k] = mode_lib->vba.SwathHeightCThisState[k];
2554                                 mode_lib->vba.UnboundedRequestEnabledAllStates[i][j] =
2555                                                 mode_lib->vba.UnboundedRequestEnabledThisState;
2556                                 mode_lib->vba.CompressedBufferSizeInkByteAllStates[i][j] =
2557                                                 mode_lib->vba.CompressedBufferSizeInkByteThisState;
2558                                 mode_lib->vba.DETBufferSizeInKByteAllStates[i][j][k] =
2559                                                 mode_lib->vba.DETBufferSizeInKByteThisState[k];
2560                                 mode_lib->vba.DETBufferSizeYAllStates[i][j][k] =
2561                                                 mode_lib->vba.DETBufferSizeYThisState[k];
2562                                 mode_lib->vba.DETBufferSizeCAllStates[i][j][k] =
2563                                                 mode_lib->vba.DETBufferSizeCThisState[k];
2564                         }
2565                 }
2566         }
2567
2568         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2569                 mode_lib->vba.cursor_bw[k] = mode_lib->vba.NumberOfCursors[k] * mode_lib->vba.CursorWidth[k][0]
2570                                 * mode_lib->vba.CursorBPP[k][0] / 8.0
2571                                 / (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]) * mode_lib->vba.VRatio[k];
2572         }
2573
2574         dml32_CalculateSurfaceSizeInMall(
2575                         mode_lib->vba.NumberOfActiveSurfaces,
2576                         mode_lib->vba.MALLAllocatedForDCNFinal,
2577                         mode_lib->vba.UseMALLForStaticScreen,
2578                         mode_lib->vba.DCCEnable,
2579                         mode_lib->vba.ViewportStationary,
2580                         mode_lib->vba.ViewportXStartY,
2581                         mode_lib->vba.ViewportYStartY,
2582                         mode_lib->vba.ViewportXStartC,
2583                         mode_lib->vba.ViewportYStartC,
2584                         mode_lib->vba.ViewportWidth,
2585                         mode_lib->vba.ViewportHeight,
2586                         mode_lib->vba.BytePerPixelY,
2587                         mode_lib->vba.ViewportWidthChroma,
2588                         mode_lib->vba.ViewportHeightChroma,
2589                         mode_lib->vba.BytePerPixelC,
2590                         mode_lib->vba.SurfaceWidthY,
2591                         mode_lib->vba.SurfaceWidthC,
2592                         mode_lib->vba.SurfaceHeightY,
2593                         mode_lib->vba.SurfaceHeightC,
2594                         mode_lib->vba.Read256BlockWidthY,
2595                         mode_lib->vba.Read256BlockWidthC,
2596                         mode_lib->vba.Read256BlockHeightY,
2597                         mode_lib->vba.Read256BlockHeightC,
2598                         mode_lib->vba.MicroTileWidthY,
2599                         mode_lib->vba.MicroTileWidthC,
2600                         mode_lib->vba.MicroTileHeightY,
2601                         mode_lib->vba.MicroTileHeightC,
2602
2603                         /* Output */
2604                         mode_lib->vba.SurfaceSizeInMALL,
2605                         &mode_lib->vba.ExceededMALLSize);
2606
2607         for (i = 0; i < v->soc.num_states; i++) {
2608                 for (j = 0; j < 2; j++) {
2609                         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2610                                 mode_lib->vba.swath_width_luma_ub_this_state[k] =
2611                                                 mode_lib->vba.swath_width_luma_ub_all_states[i][j][k];
2612                                 mode_lib->vba.swath_width_chroma_ub_this_state[k] =
2613                                                 mode_lib->vba.swath_width_chroma_ub_all_states[i][j][k];
2614                                 mode_lib->vba.SwathWidthYThisState[k] = mode_lib->vba.SwathWidthYAllStates[i][j][k];
2615                                 mode_lib->vba.SwathWidthCThisState[k] = mode_lib->vba.SwathWidthCAllStates[i][j][k];
2616                                 mode_lib->vba.SwathHeightYThisState[k] = mode_lib->vba.SwathHeightYAllStates[i][j][k];
2617                                 mode_lib->vba.SwathHeightCThisState[k] = mode_lib->vba.SwathHeightCAllStates[i][j][k];
2618                                 mode_lib->vba.DETBufferSizeInKByteThisState[k] =
2619                                                 mode_lib->vba.DETBufferSizeInKByteAllStates[i][j][k];
2620                                 mode_lib->vba.DETBufferSizeYThisState[k] =
2621                                                 mode_lib->vba.DETBufferSizeYAllStates[i][j][k];
2622                                 mode_lib->vba.DETBufferSizeCThisState[k] =
2623                                                 mode_lib->vba.DETBufferSizeCAllStates[i][j][k];
2624                                 mode_lib->vba.RequiredDPPCLKThisState[k] = mode_lib->vba.RequiredDPPCLK[i][j][k];
2625                                 mode_lib->vba.NoOfDPPThisState[k] = mode_lib->vba.NoOfDPP[i][j][k];
2626                         }
2627
2628                         mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j] = 0;
2629                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2630                                 if (mode_lib->vba.DCCEnable[k] == true) {
2631                                         mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j] =
2632                                                         mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j]
2633                                                                         + mode_lib->vba.NoOfDPP[i][j][k];
2634                                 }
2635                         }
2636
2637
2638                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2639                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].PixelClock = mode_lib->vba.PixelClock[k];
2640                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].DPPPerSurface = mode_lib->vba.NoOfDPP[i][j][k];
2641                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SourceRotation = mode_lib->vba.SourceRotation[k];
2642                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportHeight = mode_lib->vba.ViewportHeight[k];
2643                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportHeightChroma = mode_lib->vba.ViewportHeightChroma[k];
2644                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockWidth256BytesY = mode_lib->vba.Read256BlockWidthY[k];
2645                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockHeight256BytesY = mode_lib->vba.Read256BlockHeightY[k];
2646                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockWidth256BytesC = mode_lib->vba.Read256BlockWidthC[k];
2647                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockHeight256BytesC = mode_lib->vba.Read256BlockHeightC[k];
2648                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockWidthY = mode_lib->vba.MicroTileWidthY[k];
2649                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockHeightY = mode_lib->vba.MicroTileHeightY[k];
2650                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockWidthC = mode_lib->vba.MicroTileWidthC[k];
2651                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BlockHeightC = mode_lib->vba.MicroTileHeightC[k];
2652                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].InterlaceEnable = mode_lib->vba.Interlace[k];
2653                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].HTotal = mode_lib->vba.HTotal[k];
2654                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].DCCEnable = mode_lib->vba.DCCEnable[k];
2655                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SourcePixelFormat = mode_lib->vba.SourcePixelFormat[k];
2656                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SurfaceTiling = mode_lib->vba.SurfaceTiling[k];
2657                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BytePerPixelY = mode_lib->vba.BytePerPixelY[k];
2658                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].BytePerPixelC = mode_lib->vba.BytePerPixelC[k];
2659                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ProgressiveToInterlaceUnitInOPP =
2660                                 mode_lib->vba.ProgressiveToInterlaceUnitInOPP;
2661                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].VRatio = mode_lib->vba.VRatio[k];
2662                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].VRatioChroma = mode_lib->vba.VRatioChroma[k];
2663                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].VTaps = mode_lib->vba.vtaps[k];
2664                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].VTapsChroma = mode_lib->vba.VTAPsChroma[k];
2665                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].PitchY = mode_lib->vba.PitchY[k];
2666                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].DCCMetaPitchY = mode_lib->vba.DCCMetaPitchY[k];
2667                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].PitchC = mode_lib->vba.PitchC[k];
2668                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].DCCMetaPitchC = mode_lib->vba.DCCMetaPitchC[k];
2669                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportStationary = mode_lib->vba.ViewportStationary[k];
2670                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportXStart = mode_lib->vba.ViewportXStartY[k];
2671                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportYStart = mode_lib->vba.ViewportYStartY[k];
2672                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportXStartC = mode_lib->vba.ViewportXStartC[k];
2673                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].ViewportYStartC = mode_lib->vba.ViewportYStartC[k];
2674                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].FORCE_ONE_ROW_FOR_FRAME = mode_lib->vba.ForceOneRowForFrame[k];
2675                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SwathHeightY = mode_lib->vba.SwathHeightYThisState[k];
2676                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters[k].SwathHeightC = mode_lib->vba.SwathHeightCThisState[k];
2677                         }
2678
2679                         {
2680                                 dml32_CalculateVMRowAndSwath(
2681                                                 &v->dummy_vars.dml32_CalculateVMRowAndSwath,
2682                                                 mode_lib->vba.NumberOfActiveSurfaces,
2683                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SurfParameters,
2684                                                 mode_lib->vba.SurfaceSizeInMALL,
2685                                                 mode_lib->vba.PTEBufferSizeInRequestsLuma,
2686                                                 mode_lib->vba.PTEBufferSizeInRequestsChroma,
2687                                                 mode_lib->vba.DCCMetaBufferSizeBytes,
2688                                                 mode_lib->vba.UseMALLForStaticScreen,
2689                                                 mode_lib->vba.UsesMALLForPStateChange,
2690                                                 mode_lib->vba.MALLAllocatedForDCNFinal,
2691                                                 mode_lib->vba.SwathWidthYThisState,
2692                                                 mode_lib->vba.SwathWidthCThisState,
2693                                                 mode_lib->vba.GPUVMEnable,
2694                                                 mode_lib->vba.HostVMEnable,
2695                                                 mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
2696                                                 mode_lib->vba.GPUVMMaxPageTableLevels,
2697                                                 mode_lib->vba.GPUVMMinPageSizeKBytes,
2698                                                 mode_lib->vba.HostVMMinPageSize,
2699
2700                                                 /* Output */
2701                                                 mode_lib->vba.PTEBufferSizeNotExceededPerState,
2702                                                 mode_lib->vba.DCCMetaBufferSizeNotExceededPerState,
2703                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[0],
2704                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[1],
2705                                                 mode_lib->vba.dpte_row_height,
2706                                                 mode_lib->vba.dpte_row_height_chroma,
2707                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[2],
2708                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[3],
2709                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[4],
2710                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[5],
2711                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[6],
2712                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[7],
2713                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[8],
2714                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[9],
2715                                                 mode_lib->vba.meta_row_height,
2716                                                 mode_lib->vba.meta_row_height_chroma,
2717                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[10],
2718                                                 mode_lib->vba.dpte_group_bytes,
2719                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[11],
2720                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[12],
2721                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[13],
2722                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[14],
2723                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[15],
2724                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[16],
2725                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[17],
2726                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[18],
2727                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[19],
2728                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[20],
2729                                                 mode_lib->vba.PrefetchLinesYThisState,
2730                                                 mode_lib->vba.PrefetchLinesCThisState,
2731                                                 mode_lib->vba.PrefillY,
2732                                                 mode_lib->vba.PrefillC,
2733                                                 mode_lib->vba.MaxNumSwY,
2734                                                 mode_lib->vba.MaxNumSwC,
2735                                                 mode_lib->vba.meta_row_bandwidth_this_state,
2736                                                 mode_lib->vba.dpte_row_bandwidth_this_state,
2737                                                 mode_lib->vba.DPTEBytesPerRowThisState,
2738                                                 mode_lib->vba.PDEAndMetaPTEBytesPerFrameThisState,
2739                                                 mode_lib->vba.MetaRowBytesThisState,
2740                                                 mode_lib->vba.use_one_row_for_frame_this_state,
2741                                                 mode_lib->vba.use_one_row_for_frame_flip_this_state,
2742                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[0], // Boolean UsesMALLForStaticScreen[]
2743                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_boolean_array[1], // Boolean PTE_BUFFER_MODE[]
2744                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer_array[21]); // Long BIGK_FRAGMENT_SIZE[]
2745                         }
2746
2747                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2748                                 mode_lib->vba.PrefetchLinesY[i][j][k] = mode_lib->vba.PrefetchLinesYThisState[k];
2749                                 mode_lib->vba.PrefetchLinesC[i][j][k] = mode_lib->vba.PrefetchLinesCThisState[k];
2750                                 mode_lib->vba.meta_row_bandwidth[i][j][k] =
2751                                                 mode_lib->vba.meta_row_bandwidth_this_state[k];
2752                                 mode_lib->vba.dpte_row_bandwidth[i][j][k] =
2753                                                 mode_lib->vba.dpte_row_bandwidth_this_state[k];
2754                                 mode_lib->vba.DPTEBytesPerRow[i][j][k] = mode_lib->vba.DPTEBytesPerRowThisState[k];
2755                                 mode_lib->vba.PDEAndMetaPTEBytesPerFrame[i][j][k] =
2756                                                 mode_lib->vba.PDEAndMetaPTEBytesPerFrameThisState[k];
2757                                 mode_lib->vba.MetaRowBytes[i][j][k] = mode_lib->vba.MetaRowBytesThisState[k];
2758                                 mode_lib->vba.use_one_row_for_frame[i][j][k] =
2759                                                 mode_lib->vba.use_one_row_for_frame_this_state[k];
2760                                 mode_lib->vba.use_one_row_for_frame_flip[i][j][k] =
2761                                                 mode_lib->vba.use_one_row_for_frame_flip_this_state[k];
2762                         }
2763
2764                         mode_lib->vba.PTEBufferSizeNotExceeded[i][j] = true;
2765                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2766                                 if (mode_lib->vba.PTEBufferSizeNotExceededPerState[k] == false)
2767                                         mode_lib->vba.PTEBufferSizeNotExceeded[i][j] = false;
2768                         }
2769
2770                         mode_lib->vba.DCCMetaBufferSizeNotExceeded[i][j] = true;
2771                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2772                                 if (mode_lib->vba.DCCMetaBufferSizeNotExceededPerState[k] == false)
2773                                         mode_lib->vba.DCCMetaBufferSizeNotExceeded[i][j] = false;
2774                         }
2775
2776                         mode_lib->vba.UrgLatency[i] = dml32_CalculateUrgentLatency(
2777                                         mode_lib->vba.UrgentLatencyPixelDataOnly,
2778                                         mode_lib->vba.UrgentLatencyPixelMixedWithVMData,
2779                                         mode_lib->vba.UrgentLatencyVMDataOnly, mode_lib->vba.DoUrgentLatencyAdjustment,
2780                                         mode_lib->vba.UrgentLatencyAdjustmentFabricClockComponent,
2781                                         mode_lib->vba.UrgentLatencyAdjustmentFabricClockReference,
2782                                         mode_lib->vba.FabricClockPerState[i]);
2783
2784                         //bool   NotUrgentLatencyHiding[DC__NUM_DPP__MAX];
2785                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2786                                 dml32_CalculateUrgentBurstFactor(
2787                                                 mode_lib->vba.UsesMALLForPStateChange[k],
2788                                                 mode_lib->vba.swath_width_luma_ub_this_state[k],
2789                                                 mode_lib->vba.swath_width_chroma_ub_this_state[k],
2790                                                 mode_lib->vba.SwathHeightYThisState[k],
2791                                                 mode_lib->vba.SwathHeightCThisState[k],
2792                                                 (double) mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
2793                                                 mode_lib->vba.UrgLatency[i],
2794                                                 mode_lib->vba.CursorBufferSize,
2795                                                 mode_lib->vba.CursorWidth[k][0],
2796                                                 mode_lib->vba.CursorBPP[k][0],
2797                                                 mode_lib->vba.VRatio[k],
2798                                                 mode_lib->vba.VRatioChroma[k],
2799                                                 mode_lib->vba.BytePerPixelInDETY[k],
2800                                                 mode_lib->vba.BytePerPixelInDETC[k],
2801                                                 mode_lib->vba.DETBufferSizeYThisState[k],
2802                                                 mode_lib->vba.DETBufferSizeCThisState[k],
2803                                                 /* Output */
2804                                                 &mode_lib->vba.UrgentBurstFactorCursor[k],
2805                                                 &mode_lib->vba.UrgentBurstFactorLuma[k],
2806                                                 &mode_lib->vba.UrgentBurstFactorChroma[k],
2807                                                 &mode_lib->vba.NoUrgentLatencyHiding[k]);
2808                         }
2809
2810                         dml32_CalculateDCFCLKDeepSleep(
2811                                         mode_lib->vba.NumberOfActiveSurfaces,
2812                                         mode_lib->vba.BytePerPixelY,
2813                                         mode_lib->vba.BytePerPixelC,
2814                                         mode_lib->vba.VRatio,
2815                                         mode_lib->vba.VRatioChroma,
2816                                         mode_lib->vba.SwathWidthYThisState,
2817                                         mode_lib->vba.SwathWidthCThisState,
2818                                         mode_lib->vba.NoOfDPPThisState,
2819                                         mode_lib->vba.HRatio,
2820                                         mode_lib->vba.HRatioChroma,
2821                                         mode_lib->vba.PixelClock,
2822                                         mode_lib->vba.PSCL_FACTOR,
2823                                         mode_lib->vba.PSCL_FACTOR_CHROMA,
2824                                         mode_lib->vba.RequiredDPPCLKThisState,
2825                                         mode_lib->vba.ReadBandwidthLuma,
2826                                         mode_lib->vba.ReadBandwidthChroma,
2827                                         mode_lib->vba.ReturnBusWidth,
2828
2829                                         /* Output */
2830                                         &mode_lib->vba.ProjectedDCFCLKDeepSleep[i][j]);
2831                 }
2832         }
2833
2834         m = 0;
2835
2836         //Calculate Return BW
2837         for (i = 0; i < (int) v->soc.num_states; ++i) {
2838                 for (j = 0; j <= 1; ++j) {
2839                         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2840                                 if (mode_lib->vba.BlendingAndTiming[k] == k) {
2841                                         if (mode_lib->vba.WritebackEnable[k] == true) {
2842                                                 mode_lib->vba.WritebackDelayTime[k] =
2843                                                         mode_lib->vba.WritebackLatency
2844                                                 + dml32_CalculateWriteBackDelay(
2845                                                         mode_lib->vba.WritebackPixelFormat[k],
2846                                                         mode_lib->vba.WritebackHRatio[k],
2847                                                         mode_lib->vba.WritebackVRatio[k],
2848                                                         mode_lib->vba.WritebackVTaps[k],
2849                                                         mode_lib->vba.WritebackDestinationWidth[k],
2850                                                         mode_lib->vba.WritebackDestinationHeight[k],
2851                                                         mode_lib->vba.WritebackSourceHeight[k],
2852                                                         mode_lib->vba.HTotal[k])
2853                                                         / mode_lib->vba.RequiredDISPCLK[i][j];
2854                                         } else {
2855                                                 mode_lib->vba.WritebackDelayTime[k] = 0.0;
2856                                         }
2857                                         for (m = 0; m <= mode_lib->vba.NumberOfActiveSurfaces - 1; m++) {
2858                                                 if (mode_lib->vba.BlendingAndTiming[m]
2859                                                                 == k && mode_lib->vba.WritebackEnable[m] == true) {
2860                                                         mode_lib->vba.WritebackDelayTime[k] =
2861                                                                 dml_max(mode_lib->vba.WritebackDelayTime[k],
2862                                                                         mode_lib->vba.WritebackLatency
2863                                                                 + dml32_CalculateWriteBackDelay(
2864                                                                         mode_lib->vba.WritebackPixelFormat[m],
2865                                                                         mode_lib->vba.WritebackHRatio[m],
2866                                                                         mode_lib->vba.WritebackVRatio[m],
2867                                                                         mode_lib->vba.WritebackVTaps[m],
2868                                                                         mode_lib->vba.WritebackDestinationWidth[m],
2869                                                                         mode_lib->vba.WritebackDestinationHeight[m],
2870                                                                         mode_lib->vba.WritebackSourceHeight[m],
2871                                                                         mode_lib->vba.HTotal[m]) /
2872                                                                         mode_lib->vba.RequiredDISPCLK[i][j]);
2873                                                 }
2874                                         }
2875                                 }
2876                         }
2877                         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2878                                 for (m = 0; m <= mode_lib->vba.NumberOfActiveSurfaces - 1; m++) {
2879                                         if (mode_lib->vba.BlendingAndTiming[k] == m) {
2880                                                 mode_lib->vba.WritebackDelayTime[k] =
2881                                                                 mode_lib->vba.WritebackDelayTime[m];
2882                                         }
2883                                 }
2884                         }
2885                         mode_lib->vba.MaxMaxVStartup[i][j] = 0;
2886                         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
2887                                 mode_lib->vba.MaximumVStartup[i][j][k] = ((mode_lib->vba.Interlace[k] &&
2888                                                                 !mode_lib->vba.ProgressiveToInterlaceUnitInOPP) ?
2889                                                                 dml_floor((mode_lib->vba.VTotal[k] -
2890                                                                         mode_lib->vba.VActive[k]) / 2.0, 1.0) :
2891                                                                 mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k])
2892                                                                 - dml_max(1.0, dml_ceil(1.0 *
2893                                                                         mode_lib->vba.WritebackDelayTime[k] /
2894                                                                         (mode_lib->vba.HTotal[k] /
2895                                                                         mode_lib->vba.PixelClock[k]), 1.0));
2896
2897                                 // Clamp to max OTG vstartup register limit
2898                                 if (mode_lib->vba.MaximumVStartup[i][j][k] > 1023)
2899                                         mode_lib->vba.MaximumVStartup[i][j][k] = 1023;
2900
2901                                 mode_lib->vba.MaxMaxVStartup[i][j] = dml_max(mode_lib->vba.MaxMaxVStartup[i][j],
2902                                                 mode_lib->vba.MaximumVStartup[i][j][k]);
2903                         }
2904                 }
2905         }
2906
2907         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ReorderingBytes = mode_lib->vba.NumberOfChannels
2908                         * dml_max3(mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelDataOnly,
2909                                         mode_lib->vba.UrgentOutOfOrderReturnPerChannelPixelMixedWithVMData,
2910                                         mode_lib->vba.UrgentOutOfOrderReturnPerChannelVMDataOnly);
2911
2912         dml32_CalculateMinAndMaxPrefetchMode(mode_lib->vba.AllowForPStateChangeOrStutterInVBlankFinal,
2913                         &mode_lib->vba.MinPrefetchMode,
2914                         &mode_lib->vba.MaxPrefetchMode);
2915
2916         for (i = 0; i < (int) v->soc.num_states; ++i) {
2917                 for (j = 0; j <= 1; ++j)
2918                         mode_lib->vba.DCFCLKState[i][j] = mode_lib->vba.DCFCLKPerState[i];
2919         }
2920
2921         /* Immediate Flip and MALL parameters */
2922         mode_lib->vba.ImmediateFlipRequiredFinal = false;
2923         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2924                 mode_lib->vba.ImmediateFlipRequiredFinal = mode_lib->vba.ImmediateFlipRequiredFinal
2925                                 || (mode_lib->vba.ImmediateFlipRequirement[k] == dm_immediate_flip_required);
2926         }
2927
2928         mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified = false;
2929         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2930                 mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified =
2931                                 mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified
2932                                                 || ((mode_lib->vba.ImmediateFlipRequirement[k]
2933                                                                 != dm_immediate_flip_required)
2934                                                                 && (mode_lib->vba.ImmediateFlipRequirement[k]
2935                                                                                 != dm_immediate_flip_not_required));
2936         }
2937         mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified =
2938                         mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified
2939                                         && mode_lib->vba.ImmediateFlipRequiredFinal;
2940
2941         mode_lib->vba.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe = false;
2942         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2943                 mode_lib->vba.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe =
2944                         mode_lib->vba.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe ||
2945                         ((mode_lib->vba.HostVMEnable == true || mode_lib->vba.ImmediateFlipRequirement[k] !=
2946                                         dm_immediate_flip_not_required) &&
2947                         (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_full_frame ||
2948                         mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe));
2949         }
2950
2951         mode_lib->vba.InvalidCombinationOfMALLUseForPStateAndStaticScreen = false;
2952         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2953                 mode_lib->vba.InvalidCombinationOfMALLUseForPStateAndStaticScreen =
2954                         mode_lib->vba.InvalidCombinationOfMALLUseForPStateAndStaticScreen
2955                         || ((mode_lib->vba.UseMALLForStaticScreen[k] == dm_use_mall_static_screen_enable
2956                         || mode_lib->vba.UseMALLForStaticScreen[k] == dm_use_mall_static_screen_optimize)
2957                         && (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe))
2958                         || ((mode_lib->vba.UseMALLForStaticScreen[k] == dm_use_mall_static_screen_disable
2959                         || mode_lib->vba.UseMALLForStaticScreen[k] == dm_use_mall_static_screen_optimize)
2960                         && (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_full_frame));
2961         }
2962
2963         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.FullFrameMALLPStateMethod = false;
2964         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SubViewportMALLPStateMethod = false;
2965         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.PhantomPipeMALLPStateMethod = false;
2966
2967         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
2968                 if (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_full_frame)
2969                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.FullFrameMALLPStateMethod = true;
2970                 if (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_sub_viewport)
2971                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SubViewportMALLPStateMethod = true;
2972                 if (mode_lib->vba.UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe)
2973                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.PhantomPipeMALLPStateMethod = true;
2974         }
2975         mode_lib->vba.InvalidCombinationOfMALLUseForPState = (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SubViewportMALLPStateMethod
2976                         != v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.PhantomPipeMALLPStateMethod) || (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.SubViewportMALLPStateMethod && v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.FullFrameMALLPStateMethod);
2977
2978         if (mode_lib->vba.UseMinimumRequiredDCFCLK == true) {
2979                 dml32_UseMinimumDCFCLK(
2980                                 mode_lib->vba.UsesMALLForPStateChange,
2981                                 mode_lib->vba.DRRDisplay,
2982                                 mode_lib->vba.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
2983                                 mode_lib->vba.MaxInterDCNTileRepeaters,
2984                                 mode_lib->vba.MaxPrefetchMode,
2985                                 mode_lib->vba.DRAMClockChangeLatency,
2986                                 mode_lib->vba.FCLKChangeLatency,
2987                                 mode_lib->vba.SREnterPlusExitTime,
2988                                 mode_lib->vba.ReturnBusWidth,
2989                                 mode_lib->vba.RoundTripPingLatencyCycles,
2990                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ReorderingBytes,
2991                                 mode_lib->vba.PixelChunkSizeInKByte,
2992                                 mode_lib->vba.MetaChunkSize,
2993                                 mode_lib->vba.GPUVMEnable,
2994                                 mode_lib->vba.GPUVMMaxPageTableLevels,
2995                                 mode_lib->vba.HostVMEnable,
2996                                 mode_lib->vba.NumberOfActiveSurfaces,
2997                                 mode_lib->vba.HostVMMinPageSize,
2998                                 mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
2999                                 mode_lib->vba.DynamicMetadataVMEnabled,
3000                                 mode_lib->vba.ImmediateFlipRequiredFinal,
3001                                 mode_lib->vba.ProgressiveToInterlaceUnitInOPP,
3002                                 mode_lib->vba.MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation,
3003                                 mode_lib->vba.PercentOfIdealFabricAndSDPPortBWReceivedAfterUrgLatency,
3004                                 mode_lib->vba.VTotal,
3005                                 mode_lib->vba.VActive,
3006                                 mode_lib->vba.DynamicMetadataTransmittedBytes,
3007                                 mode_lib->vba.DynamicMetadataLinesBeforeActiveRequired,
3008                                 mode_lib->vba.Interlace,
3009                                 mode_lib->vba.RequiredDPPCLK,
3010                                 mode_lib->vba.RequiredDISPCLK,
3011                                 mode_lib->vba.UrgLatency,
3012                                 mode_lib->vba.NoOfDPP,
3013                                 mode_lib->vba.ProjectedDCFCLKDeepSleep,
3014                                 mode_lib->vba.MaximumVStartup,
3015                                 mode_lib->vba.TotalNumberOfActiveDPP,
3016                                 mode_lib->vba.TotalNumberOfDCCActiveDPP,
3017                                 mode_lib->vba.dpte_group_bytes,
3018                                 mode_lib->vba.PrefetchLinesY,
3019                                 mode_lib->vba.PrefetchLinesC,
3020                                 mode_lib->vba.swath_width_luma_ub_all_states,
3021                                 mode_lib->vba.swath_width_chroma_ub_all_states,
3022                                 mode_lib->vba.BytePerPixelY,
3023                                 mode_lib->vba.BytePerPixelC,
3024                                 mode_lib->vba.HTotal,
3025                                 mode_lib->vba.PixelClock,
3026                                 mode_lib->vba.PDEAndMetaPTEBytesPerFrame,
3027                                 mode_lib->vba.DPTEBytesPerRow,
3028                                 mode_lib->vba.MetaRowBytes,
3029                                 mode_lib->vba.DynamicMetadataEnable,
3030                                 mode_lib->vba.ReadBandwidthLuma,
3031                                 mode_lib->vba.ReadBandwidthChroma,
3032                                 mode_lib->vba.DCFCLKPerState,
3033
3034                                 /* Output */
3035                                 mode_lib->vba.DCFCLKState);
3036         } // UseMinimumRequiredDCFCLK == true
3037
3038         for (i = 0; i < (int) v->soc.num_states; ++i) {
3039                 for (j = 0; j <= 1; ++j) {
3040                         mode_lib->vba.ReturnBWPerState[i][j] = dml32_get_return_bw_mbps(&mode_lib->vba.soc, i,
3041                                         mode_lib->vba.HostVMEnable, mode_lib->vba.DCFCLKState[i][j],
3042                                         mode_lib->vba.FabricClockPerState[i], mode_lib->vba.DRAMSpeedPerState[i]);
3043                 }
3044         }
3045
3046         //Re-ordering Buffer Support Check
3047         for (i = 0; i < (int) v->soc.num_states; ++i) {
3048                 for (j = 0; j <= 1; ++j) {
3049                         if ((mode_lib->vba.ROBBufferSizeInKByte - mode_lib->vba.PixelChunkSizeInKByte) * 1024
3050                                         / mode_lib->vba.ReturnBWPerState[i][j]
3051                                         > (mode_lib->vba.RoundTripPingLatencyCycles + 32)
3052                                                         / mode_lib->vba.DCFCLKState[i][j]
3053                                                         + v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ReorderingBytes / mode_lib->vba.ReturnBWPerState[i][j]) {
3054                                 mode_lib->vba.ROBSupport[i][j] = true;
3055                         } else {
3056                                 mode_lib->vba.ROBSupport[i][j] = false;
3057                         }
3058                 }
3059         }
3060
3061         //Vertical Active BW support check
3062         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaxTotalVActiveRDBandwidth = 0;
3063
3064         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3065                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaxTotalVActiveRDBandwidth += mode_lib->vba.ReadBandwidthLuma[k]
3066                                 + mode_lib->vba.ReadBandwidthChroma[k];
3067         }
3068
3069         for (i = 0; i < (int) v->soc.num_states; ++i) {
3070                 for (j = 0; j <= 1; ++j) {
3071                         mode_lib->vba.MaxTotalVerticalActiveAvailableBandwidth[i][j] =
3072                                 dml_min3(mode_lib->vba.ReturnBusWidth * mode_lib->vba.DCFCLKState[i][j]
3073                                         * mode_lib->vba.MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation / 100,
3074                                         mode_lib->vba.FabricClockPerState[i]
3075                                         * mode_lib->vba.FabricDatapathToDCNDataReturn
3076                                         * mode_lib->vba.MaxAveragePercentOfIdealFabricBWDisplayCanUseInNormalSystemOperation / 100,
3077                                         mode_lib->vba.DRAMSpeedPerState[i]
3078                                         * mode_lib->vba.NumberOfChannels
3079                                         * mode_lib->vba.DRAMChannelWidth
3080                                         * (i < 2 ? mode_lib->vba.MaxAveragePercentOfIdealDRAMBWDisplayCanUseInNormalSystemOperationSTROBE : mode_lib->vba.MaxAveragePercentOfIdealDRAMBWDisplayCanUseInNormalSystemOperation) / 100);
3081
3082                         if (v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.MaxTotalVActiveRDBandwidth
3083                                         <= mode_lib->vba.MaxTotalVerticalActiveAvailableBandwidth[i][j]) {
3084                                 mode_lib->vba.TotalVerticalActiveBandwidthSupport[i][j] = true;
3085                         } else {
3086                                 mode_lib->vba.TotalVerticalActiveBandwidthSupport[i][j] = false;
3087                         }
3088                 }
3089         }
3090
3091         /* Prefetch Check */
3092
3093         for (i = 0; i < (int) v->soc.num_states; ++i) {
3094                 for (j = 0; j <= 1; ++j) {
3095
3096                         mode_lib->vba.TimeCalc = 24 / mode_lib->vba.ProjectedDCFCLKDeepSleep[i][j];
3097
3098                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3099                                 mode_lib->vba.NoOfDPPThisState[k] = mode_lib->vba.NoOfDPP[i][j][k];
3100                                 mode_lib->vba.swath_width_luma_ub_this_state[k] =
3101                                                 mode_lib->vba.swath_width_luma_ub_all_states[i][j][k];
3102                                 mode_lib->vba.swath_width_chroma_ub_this_state[k] =
3103                                                 mode_lib->vba.swath_width_chroma_ub_all_states[i][j][k];
3104                                 mode_lib->vba.SwathWidthYThisState[k] = mode_lib->vba.SwathWidthYAllStates[i][j][k];
3105                                 mode_lib->vba.SwathWidthCThisState[k] = mode_lib->vba.SwathWidthCAllStates[i][j][k];
3106                                 mode_lib->vba.SwathHeightYThisState[k] = mode_lib->vba.SwathHeightYAllStates[i][j][k];
3107                                 mode_lib->vba.SwathHeightCThisState[k] = mode_lib->vba.SwathHeightCAllStates[i][j][k];
3108                                 mode_lib->vba.UnboundedRequestEnabledThisState =
3109                                                 mode_lib->vba.UnboundedRequestEnabledAllStates[i][j];
3110                                 mode_lib->vba.CompressedBufferSizeInkByteThisState =
3111                                                 mode_lib->vba.CompressedBufferSizeInkByteAllStates[i][j];
3112                                 mode_lib->vba.DETBufferSizeInKByteThisState[k] =
3113                                                 mode_lib->vba.DETBufferSizeInKByteAllStates[i][j][k];
3114                                 mode_lib->vba.DETBufferSizeYThisState[k] =
3115                                                 mode_lib->vba.DETBufferSizeYAllStates[i][j][k];
3116                                 mode_lib->vba.DETBufferSizeCThisState[k] =
3117                                                 mode_lib->vba.DETBufferSizeCAllStates[i][j][k];
3118                         }
3119
3120                         mode_lib->vba.VActiveBandwithSupport[i][j] = dml32_CalculateVActiveBandwithSupport(
3121                                         mode_lib->vba.NumberOfActiveSurfaces,
3122                                         mode_lib->vba.ReturnBWPerState[i][j],
3123                                         mode_lib->vba.NoUrgentLatencyHiding,
3124                                         mode_lib->vba.ReadBandwidthLuma,
3125                                         mode_lib->vba.ReadBandwidthChroma,
3126                                         mode_lib->vba.cursor_bw,
3127                                         mode_lib->vba.meta_row_bandwidth_this_state,
3128                                         mode_lib->vba.dpte_row_bandwidth_this_state,
3129                                         mode_lib->vba.NoOfDPPThisState,
3130                                         mode_lib->vba.UrgentBurstFactorLuma,
3131                                         mode_lib->vba.UrgentBurstFactorChroma,
3132                                         mode_lib->vba.UrgentBurstFactorCursor);
3133
3134                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.VMDataOnlyReturnBWPerState = dml32_get_return_bw_mbps_vm_only(&mode_lib->vba.soc, i,
3135                                         mode_lib->vba.DCFCLKState[i][j], mode_lib->vba.FabricClockPerState[i],
3136                                         mode_lib->vba.DRAMSpeedPerState[i]);
3137                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor = 1;
3138
3139                         if (mode_lib->vba.GPUVMEnable && mode_lib->vba.HostVMEnable)
3140                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor = mode_lib->vba.ReturnBWPerState[i][j]
3141                                                 / v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.VMDataOnlyReturnBWPerState;
3142
3143                         mode_lib->vba.ExtraLatency = dml32_CalculateExtraLatency(
3144                                         mode_lib->vba.RoundTripPingLatencyCycles, v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.ReorderingBytes,
3145                                         mode_lib->vba.DCFCLKState[i][j], mode_lib->vba.TotalNumberOfActiveDPP[i][j],
3146                                         mode_lib->vba.PixelChunkSizeInKByte,
3147                                         mode_lib->vba.TotalNumberOfDCCActiveDPP[i][j], mode_lib->vba.MetaChunkSize,
3148                                         mode_lib->vba.ReturnBWPerState[i][j], mode_lib->vba.GPUVMEnable,
3149                                         mode_lib->vba.HostVMEnable, mode_lib->vba.NumberOfActiveSurfaces,
3150                                         mode_lib->vba.NoOfDPPThisState, mode_lib->vba.dpte_group_bytes,
3151                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor, mode_lib->vba.HostVMMinPageSize,
3152                                         mode_lib->vba.HostVMMaxNonCachedPageTableLevels);
3153
3154                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState = mode_lib->vba.MinPrefetchMode;
3155
3156                         mode_lib->vba.NextMaxVStartup = mode_lib->vba.MaxMaxVStartup[i][j];
3157
3158                         do {
3159                                 mode_lib->vba.PrefetchModePerState[i][j] = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState;
3160                                 mode_lib->vba.MaxVStartup = mode_lib->vba.NextMaxVStartup;
3161
3162                                 for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3163                                         mode_lib->vba.TWait = dml32_CalculateTWait(
3164                                                         mode_lib->vba.PrefetchModePerState[i][j],
3165                                                         mode_lib->vba.UsesMALLForPStateChange[k],
3166                                                         mode_lib->vba.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
3167                                                         mode_lib->vba.DRRDisplay[k],
3168                                                         mode_lib->vba.DRAMClockChangeLatency,
3169                                                         mode_lib->vba.FCLKChangeLatency, mode_lib->vba.UrgLatency[i],
3170                                                         mode_lib->vba.SREnterPlusExitTime);
3171
3172                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.Dppclk = mode_lib->vba.RequiredDPPCLK[i][j][k];
3173                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.Dispclk = mode_lib->vba.RequiredDISPCLK[i][j];
3174                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.PixelClock = mode_lib->vba.PixelClock[k];
3175                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.DCFClkDeepSleep = mode_lib->vba.ProjectedDCFCLKDeepSleep[i][j];
3176                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.DPPPerSurface = mode_lib->vba.NoOfDPP[i][j][k];
3177                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.ScalerEnabled = mode_lib->vba.ScalerEnabled[k];
3178                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.SourceRotation = mode_lib->vba.SourceRotation[k];
3179                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BlockWidth256BytesY = mode_lib->vba.Read256BlockWidthY[k];
3180                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BlockHeight256BytesY = mode_lib->vba.Read256BlockHeightY[k];
3181                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BlockWidth256BytesC = mode_lib->vba.Read256BlockWidthC[k];
3182                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BlockHeight256BytesC = mode_lib->vba.Read256BlockHeightC[k];
3183                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.InterlaceEnable = mode_lib->vba.Interlace[k];
3184                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.NumberOfCursors = mode_lib->vba.NumberOfCursors[k];
3185                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.VBlank = mode_lib->vba.VTotal[k] - mode_lib->vba.VActive[k];
3186                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.HTotal = mode_lib->vba.HTotal[k];
3187                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.HActive = mode_lib->vba.HActive[k];
3188                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.DCCEnable = mode_lib->vba.DCCEnable[k];
3189                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.ODMMode = mode_lib->vba.ODMCombineEnablePerState[i][k];
3190                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.SourcePixelFormat = mode_lib->vba.SourcePixelFormat[k];
3191                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BytePerPixelY = mode_lib->vba.BytePerPixelY[k];
3192                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.BytePerPixelC = mode_lib->vba.BytePerPixelC[k];
3193                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe.ProgressiveToInterlaceUnitInOPP =
3194                                                         mode_lib->vba.ProgressiveToInterlaceUnitInOPP;
3195
3196                                         mode_lib->vba.NoTimeForPrefetch[i][j][k] =
3197                                                 dml32_CalculatePrefetchSchedule(
3198                                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor,
3199                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.myPipe,
3200                                                         mode_lib->vba.DSCDelayPerState[i][k],
3201                                                         mode_lib->vba.DPPCLKDelaySubtotal +
3202                                                                 mode_lib->vba.DPPCLKDelayCNVCFormater,
3203                                                         mode_lib->vba.DPPCLKDelaySCL,
3204                                                         mode_lib->vba.DPPCLKDelaySCLLBOnly,
3205                                                         mode_lib->vba.DPPCLKDelayCNVCCursor,
3206                                                         mode_lib->vba.DISPCLKDelaySubtotal,
3207                                                         mode_lib->vba.SwathWidthYThisState[k] /
3208                                                                 mode_lib->vba.HRatio[k],
3209                                                         mode_lib->vba.OutputFormat[k],
3210                                                         mode_lib->vba.MaxInterDCNTileRepeaters,
3211                                                         dml_min(mode_lib->vba.MaxVStartup,
3212                                                                         mode_lib->vba.MaximumVStartup[i][j][k]),
3213                                                         mode_lib->vba.MaximumVStartup[i][j][k],
3214                                                         mode_lib->vba.GPUVMMaxPageTableLevels,
3215                                                         mode_lib->vba.GPUVMEnable, mode_lib->vba.HostVMEnable,
3216                                                         mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
3217                                                         mode_lib->vba.HostVMMinPageSize,
3218                                                         mode_lib->vba.DynamicMetadataEnable[k],
3219                                                         mode_lib->vba.DynamicMetadataVMEnabled,
3220                                                         mode_lib->vba.DynamicMetadataLinesBeforeActiveRequired[k],
3221                                                         mode_lib->vba.DynamicMetadataTransmittedBytes[k],
3222                                                         mode_lib->vba.UrgLatency[i],
3223                                                         mode_lib->vba.ExtraLatency,
3224                                                         mode_lib->vba.TimeCalc,
3225                                                         mode_lib->vba.PDEAndMetaPTEBytesPerFrame[i][j][k],
3226                                                         mode_lib->vba.MetaRowBytes[i][j][k],
3227                                                         mode_lib->vba.DPTEBytesPerRow[i][j][k],
3228                                                         mode_lib->vba.PrefetchLinesY[i][j][k],
3229                                                         mode_lib->vba.SwathWidthYThisState[k],
3230                                                         mode_lib->vba.PrefillY[k],
3231                                                         mode_lib->vba.MaxNumSwY[k],
3232                                                         mode_lib->vba.PrefetchLinesC[i][j][k],
3233                                                         mode_lib->vba.SwathWidthCThisState[k],
3234                                                         mode_lib->vba.PrefillC[k],
3235                                                         mode_lib->vba.MaxNumSwC[k],
3236                                                         mode_lib->vba.swath_width_luma_ub_this_state[k],
3237                                                         mode_lib->vba.swath_width_chroma_ub_this_state[k],
3238                                                         mode_lib->vba.SwathHeightYThisState[k],
3239                                                         mode_lib->vba.SwathHeightCThisState[k], mode_lib->vba.TWait,
3240
3241                                                         /* Output */
3242                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.DSTXAfterScaler[k],
3243                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.DSTYAfterScaler[k],
3244                                                         &mode_lib->vba.LineTimesForPrefetch[k],
3245                                                         &mode_lib->vba.PrefetchBW[k],
3246                                                         &mode_lib->vba.LinesForMetaPTE[k],
3247                                                         &mode_lib->vba.LinesForMetaAndDPTERow[k],
3248                                                         &mode_lib->vba.VRatioPreY[i][j][k],
3249                                                         &mode_lib->vba.VRatioPreC[i][j][k],
3250                                                         &mode_lib->vba.RequiredPrefetchPixelDataBWLuma[0][0][k],
3251                                                         &mode_lib->vba.RequiredPrefetchPixelDataBWChroma[0][0][k],
3252                                                         &mode_lib->vba.NoTimeForDynamicMetadata[i][j][k],
3253                                                         &mode_lib->vba.Tno_bw[k],
3254                                                         &mode_lib->vba.prefetch_vmrow_bw[k],
3255                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[0],         // double *Tdmdl_vm
3256                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[1],         // double *Tdmdl
3257                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[2],         // double *TSetup
3258                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer[0],                                                                // unsigned int   *VUpdateOffsetPix
3259                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[3],         // unsigned int   *VUpdateWidthPix
3260                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[4]);        // unsigned int   *VReadyOffsetPix
3261                                 }
3262
3263                                 for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3264                                         dml32_CalculateUrgentBurstFactor(
3265                                                         mode_lib->vba.UsesMALLForPStateChange[k],
3266                                                         mode_lib->vba.swath_width_luma_ub_this_state[k],
3267                                                         mode_lib->vba.swath_width_chroma_ub_this_state[k],
3268                                                         mode_lib->vba.SwathHeightYThisState[k],
3269                                                         mode_lib->vba.SwathHeightCThisState[k],
3270                                                         mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k],
3271                                                         mode_lib->vba.UrgLatency[i], mode_lib->vba.CursorBufferSize,
3272                                                         mode_lib->vba.CursorWidth[k][0], mode_lib->vba.CursorBPP[k][0],
3273                                                         mode_lib->vba.VRatioPreY[i][j][k],
3274                                                         mode_lib->vba.VRatioPreC[i][j][k],
3275                                                         mode_lib->vba.BytePerPixelInDETY[k],
3276                                                         mode_lib->vba.BytePerPixelInDETC[k],
3277                                                         mode_lib->vba.DETBufferSizeYThisState[k],
3278                                                         mode_lib->vba.DETBufferSizeCThisState[k],
3279                                                         /* Output */
3280                                                         &mode_lib->vba.UrgentBurstFactorCursorPre[k],
3281                                                         &mode_lib->vba.UrgentBurstFactorLumaPre[k],
3282                                                         &mode_lib->vba.UrgentBurstFactorChroma[k],
3283                                                         &mode_lib->vba.NotUrgentLatencyHidingPre[k]);
3284                                 }
3285
3286                                 {
3287                                         dml32_CalculatePrefetchBandwithSupport(
3288                                                         mode_lib->vba.NumberOfActiveSurfaces,
3289                                                         mode_lib->vba.ReturnBWPerState[i][j],
3290                                                         mode_lib->vba.NotUrgentLatencyHidingPre,
3291                                                         mode_lib->vba.ReadBandwidthLuma,
3292                                                         mode_lib->vba.ReadBandwidthChroma,
3293                                                         mode_lib->vba.RequiredPrefetchPixelDataBWLuma[0][0],
3294                                                         mode_lib->vba.RequiredPrefetchPixelDataBWChroma[0][0],
3295                                                         mode_lib->vba.cursor_bw,
3296                                                         mode_lib->vba.meta_row_bandwidth_this_state,
3297                                                         mode_lib->vba.dpte_row_bandwidth_this_state,
3298                                                         mode_lib->vba.cursor_bw_pre,
3299                                                         mode_lib->vba.prefetch_vmrow_bw,
3300                                                         mode_lib->vba.NoOfDPPThisState,
3301                                                         mode_lib->vba.UrgentBurstFactorLuma,
3302                                                         mode_lib->vba.UrgentBurstFactorChroma,
3303                                                         mode_lib->vba.UrgentBurstFactorCursor,
3304                                                         mode_lib->vba.UrgentBurstFactorLumaPre,
3305                                                         mode_lib->vba.UrgentBurstFactorChromaPre,
3306                                                         mode_lib->vba.UrgentBurstFactorCursorPre,
3307
3308                                                         /* output */
3309                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[0],   // Single  *PrefetchBandwidth
3310                                                         &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[1],   // Single  *FractionOfUrgentBandwidth
3311                                                         &mode_lib->vba.PrefetchSupported[i][j]);
3312                                 }
3313
3314                                 for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3315                                         if (mode_lib->vba.LineTimesForPrefetch[k]
3316                                                         < 2.0 || mode_lib->vba.LinesForMetaPTE[k] >= 32.0
3317                                                         || mode_lib->vba.LinesForMetaAndDPTERow[k] >= 16.0
3318                                                         || mode_lib->vba.NoTimeForPrefetch[i][j][k] == true) {
3319                                                 mode_lib->vba.PrefetchSupported[i][j] = false;
3320                                         }
3321                                 }
3322
3323                                 mode_lib->vba.DynamicMetadataSupported[i][j] = true;
3324                                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3325                                         if (mode_lib->vba.NoTimeForDynamicMetadata[i][j][k] == true)
3326                                                 mode_lib->vba.DynamicMetadataSupported[i][j] = false;
3327                                 }
3328
3329                                 mode_lib->vba.VRatioInPrefetchSupported[i][j] = true;
3330                                 for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3331                                         if (mode_lib->vba.VRatioPreY[i][j][k] > __DML_MAX_VRATIO_PRE__
3332                                                         || mode_lib->vba.VRatioPreC[i][j][k] > __DML_MAX_VRATIO_PRE__
3333                                                         || mode_lib->vba.NoTimeForPrefetch[i][j][k] == true) {
3334                                                 mode_lib->vba.VRatioInPrefetchSupported[i][j] = false;
3335                                         }
3336                                 }
3337                                 mode_lib->vba.AnyLinesForVMOrRowTooLarge = false;
3338                                 for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3339                                         if (mode_lib->vba.LinesForMetaAndDPTERow[k] >= 16
3340                                                         || mode_lib->vba.LinesForMetaPTE[k] >= 32) {
3341                                                 mode_lib->vba.AnyLinesForVMOrRowTooLarge = true;
3342                                         }
3343                                 }
3344
3345                                 if (mode_lib->vba.PrefetchSupported[i][j] == true
3346                                                 && mode_lib->vba.VRatioInPrefetchSupported[i][j] == true) {
3347                                         mode_lib->vba.BandwidthAvailableForImmediateFlip =
3348                                                         dml32_CalculateBandwidthAvailableForImmediateFlip(
3349                                                         mode_lib->vba.NumberOfActiveSurfaces,
3350                                                         mode_lib->vba.ReturnBWPerState[i][j],
3351                                                         mode_lib->vba.ReadBandwidthLuma,
3352                                                         mode_lib->vba.ReadBandwidthChroma,
3353                                                         mode_lib->vba.RequiredPrefetchPixelDataBWLuma[0][0],
3354                                                         mode_lib->vba.RequiredPrefetchPixelDataBWChroma[0][0],
3355                                                         mode_lib->vba.cursor_bw,
3356                                                         mode_lib->vba.cursor_bw_pre,
3357                                                         mode_lib->vba.NoOfDPPThisState,
3358                                                         mode_lib->vba.UrgentBurstFactorLuma,
3359                                                         mode_lib->vba.UrgentBurstFactorChroma,
3360                                                         mode_lib->vba.UrgentBurstFactorCursor,
3361                                                         mode_lib->vba.UrgentBurstFactorLumaPre,
3362                                                         mode_lib->vba.UrgentBurstFactorChromaPre,
3363                                                         mode_lib->vba.UrgentBurstFactorCursorPre);
3364
3365                                         mode_lib->vba.TotImmediateFlipBytes = 0.0;
3366                                         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3367                                                 if (!(mode_lib->vba.ImmediateFlipRequirement[k] ==
3368                                                                 dm_immediate_flip_not_required)) {
3369                                                         mode_lib->vba.TotImmediateFlipBytes =
3370                                                                         mode_lib->vba.TotImmediateFlipBytes
3371                                                                 + mode_lib->vba.NoOfDPP[i][j][k]
3372                                                                 * mode_lib->vba.PDEAndMetaPTEBytesPerFrame[i][j][k]
3373                                                                 + mode_lib->vba.MetaRowBytes[i][j][k];
3374                                                         if (mode_lib->vba.use_one_row_for_frame_flip[i][j][k]) {
3375                                                                 mode_lib->vba.TotImmediateFlipBytes =
3376                                                                         mode_lib->vba.TotImmediateFlipBytes + 2
3377                                                                 * mode_lib->vba.DPTEBytesPerRow[i][j][k];
3378                                                         } else {
3379                                                                 mode_lib->vba.TotImmediateFlipBytes =
3380                                                                         mode_lib->vba.TotImmediateFlipBytes
3381                                                                 + mode_lib->vba.DPTEBytesPerRow[i][j][k];
3382                                                         }
3383                                                 }
3384                                         }
3385
3386                                         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3387                                                 dml32_CalculateFlipSchedule(v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.HostVMInefficiencyFactor,
3388                                                         mode_lib->vba.ExtraLatency,
3389                                                         mode_lib->vba.UrgLatency[i],
3390                                                         mode_lib->vba.GPUVMMaxPageTableLevels,
3391                                                         mode_lib->vba.HostVMEnable,
3392                                                         mode_lib->vba.HostVMMaxNonCachedPageTableLevels,
3393                                                         mode_lib->vba.GPUVMEnable,
3394                                                         mode_lib->vba.HostVMMinPageSize,
3395                                                         mode_lib->vba.PDEAndMetaPTEBytesPerFrame[i][j][k],
3396                                                         mode_lib->vba.MetaRowBytes[i][j][k],
3397                                                         mode_lib->vba.DPTEBytesPerRow[i][j][k],
3398                                                         mode_lib->vba.BandwidthAvailableForImmediateFlip,
3399                                                         mode_lib->vba.TotImmediateFlipBytes,
3400                                                         mode_lib->vba.SourcePixelFormat[k],
3401                                                         (mode_lib->vba.HTotal[k] / mode_lib->vba.PixelClock[k]),
3402                                                         mode_lib->vba.VRatio[k],
3403                                                         mode_lib->vba.VRatioChroma[k],
3404                                                         mode_lib->vba.Tno_bw[k],
3405                                                                 mode_lib->vba.DCCEnable[k],
3406                                                         mode_lib->vba.dpte_row_height[k],
3407                                                         mode_lib->vba.meta_row_height[k],
3408                                                         mode_lib->vba.dpte_row_height_chroma[k],
3409                                                         mode_lib->vba.meta_row_height_chroma[k],
3410                                                         mode_lib->vba.use_one_row_for_frame_flip[i][j][k], // 24
3411
3412                                                         /* Output */
3413                                                         &mode_lib->vba.DestinationLinesToRequestVMInImmediateFlip[k],
3414                                                         &mode_lib->vba.DestinationLinesToRequestRowInImmediateFlip[k],
3415                                                         &mode_lib->vba.final_flip_bw[k],
3416                                                         &mode_lib->vba.ImmediateFlipSupportedForPipe[k]);
3417                                         }
3418
3419                                         {
3420                                                 dml32_CalculateImmediateFlipBandwithSupport(mode_lib->vba.NumberOfActiveSurfaces,
3421                                                                 mode_lib->vba.ReturnBWPerState[i][j],
3422                                                                 mode_lib->vba.ImmediateFlipRequirement,
3423                                                                 mode_lib->vba.final_flip_bw,
3424                                                                 mode_lib->vba.ReadBandwidthLuma,
3425                                                                 mode_lib->vba.ReadBandwidthChroma,
3426                                                                 mode_lib->vba.RequiredPrefetchPixelDataBWLuma[0][0],
3427                                                                 mode_lib->vba.RequiredPrefetchPixelDataBWChroma[0][0],
3428                                                                 mode_lib->vba.cursor_bw,
3429                                                                 mode_lib->vba.meta_row_bandwidth_this_state,
3430                                                                 mode_lib->vba.dpte_row_bandwidth_this_state,
3431                                                                 mode_lib->vba.cursor_bw_pre,
3432                                                                 mode_lib->vba.prefetch_vmrow_bw,
3433                                                                 mode_lib->vba.DPPPerPlane,
3434                                                                 mode_lib->vba.UrgentBurstFactorLuma,
3435                                                                 mode_lib->vba.UrgentBurstFactorChroma,
3436                                                                 mode_lib->vba.UrgentBurstFactorCursor,
3437                                                                 mode_lib->vba.UrgentBurstFactorLumaPre,
3438                                                                 mode_lib->vba.UrgentBurstFactorChromaPre,
3439                                                                 mode_lib->vba.UrgentBurstFactorCursorPre,
3440
3441                                                                 /* output */
3442                                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[0], //  Single  *TotalBandwidth
3443                                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single[1], //  Single  *FractionOfUrgentBandwidth
3444                                                                 &mode_lib->vba.ImmediateFlipSupportedForState[i][j]); // Boolean *ImmediateFlipBandwidthSupport
3445                                         }
3446
3447                                         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3448                                                 if (!(mode_lib->vba.ImmediateFlipRequirement[k]
3449                                                                 == dm_immediate_flip_not_required)
3450                                                                 && (mode_lib->vba.ImmediateFlipSupportedForPipe[k]
3451                                                                                 == false))
3452                                                         mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false;
3453                                         }
3454                                 } else { // if prefetch not support, assume iflip not supported
3455                                         mode_lib->vba.ImmediateFlipSupportedForState[i][j] = false;
3456                                 }
3457
3458                                 if (mode_lib->vba.MaxVStartup <= __DML_VBA_MIN_VSTARTUP__
3459                                                 || mode_lib->vba.AnyLinesForVMOrRowTooLarge == false) {
3460                                         mode_lib->vba.NextMaxVStartup = mode_lib->vba.MaxMaxVStartup[i][j];
3461                                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState = v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState + 1;
3462                                 } else {
3463                                         mode_lib->vba.NextMaxVStartup = mode_lib->vba.NextMaxVStartup - 1;
3464                                 }
3465                         } while (!((mode_lib->vba.PrefetchSupported[i][j] == true
3466                                         && mode_lib->vba.DynamicMetadataSupported[i][j] == true
3467                                         && mode_lib->vba.VRatioInPrefetchSupported[i][j] == true &&
3468                                         // consider flip support is okay if when there is no hostvm and the
3469                                         // user does't require a iflip OR the flip bw is ok
3470                                         // If there is hostvm, DCN needs to support iflip for invalidation
3471                                         ((mode_lib->vba.HostVMEnable == false
3472                                                         && !mode_lib->vba.ImmediateFlipRequiredFinal)
3473                                                         || mode_lib->vba.ImmediateFlipSupportedForState[i][j] == true))
3474                                         || (mode_lib->vba.NextMaxVStartup == mode_lib->vba.MaxMaxVStartup[i][j]
3475                                                         && v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.NextPrefetchModeState > mode_lib->vba.MaxPrefetchMode)));
3476
3477                         for (k = 0; k < mode_lib->vba.NumberOfActiveSurfaces; ++k) {
3478                                 mode_lib->vba.use_one_row_for_frame_this_state[k] =
3479                                                 mode_lib->vba.use_one_row_for_frame[i][j][k];
3480                         }
3481
3482
3483                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.UrgentLatency = mode_lib->vba.UrgLatency[i];
3484                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.ExtraLatency = mode_lib->vba.ExtraLatency;
3485                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.WritebackLatency = mode_lib->vba.WritebackLatency;
3486                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.DRAMClockChangeLatency = mode_lib->vba.DRAMClockChangeLatency;
3487                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.FCLKChangeLatency = mode_lib->vba.FCLKChangeLatency;
3488                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SRExitTime = mode_lib->vba.SRExitTime;
3489                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SREnterPlusExitTime = mode_lib->vba.SREnterPlusExitTime;
3490                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SRExitZ8Time = mode_lib->vba.SRExitZ8Time;
3491                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SREnterPlusExitZ8Time = mode_lib->vba.SREnterPlusExitZ8Time;
3492                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.USRRetrainingLatency = mode_lib->vba.USRRetrainingLatency;
3493                         v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters.SMNLatency = mode_lib->vba.SMNLatency;
3494
3495                         {
3496                                 dml32_CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(
3497                                                 &v->dummy_vars.dml32_CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport,
3498                                                 mode_lib->vba.USRRetrainingRequiredFinal,
3499                                                 mode_lib->vba.UsesMALLForPStateChange,
3500                                                 mode_lib->vba.PrefetchModePerState[i][j],
3501                                                 mode_lib->vba.NumberOfActiveSurfaces,
3502                                                 mode_lib->vba.MaxLineBufferLines,
3503                                                 mode_lib->vba.LineBufferSizeFinal,
3504                                                 mode_lib->vba.WritebackInterfaceBufferSize,
3505                                                 mode_lib->vba.DCFCLKState[i][j],
3506                                                 mode_lib->vba.ReturnBWPerState[i][j],
3507                                                 mode_lib->vba.SynchronizeTimingsFinal,
3508                                                 mode_lib->vba.SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
3509                                                 mode_lib->vba.DRRDisplay,
3510                                                 mode_lib->vba.dpte_group_bytes,
3511                                                 mode_lib->vba.meta_row_height,
3512                                                 mode_lib->vba.meta_row_height_chroma,
3513                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.mSOCParameters,
3514                                                 mode_lib->vba.WritebackChunkSize,
3515                                                 mode_lib->vba.SOCCLKPerState[i],
3516                                                 mode_lib->vba.ProjectedDCFCLKDeepSleep[i][j],
3517                                                 mode_lib->vba.DETBufferSizeYThisState,
3518                                                 mode_lib->vba.DETBufferSizeCThisState,
3519                                                 mode_lib->vba.SwathHeightYThisState,
3520                                                 mode_lib->vba.SwathHeightCThisState,
3521                                                 mode_lib->vba.LBBitPerPixel,
3522                                                 mode_lib->vba.SwathWidthYThisState, // 24
3523                                                 mode_lib->vba.SwathWidthCThisState,
3524                                                 mode_lib->vba.HRatio,
3525                                                 mode_lib->vba.HRatioChroma,
3526                                                 mode_lib->vba.vtaps,
3527                                                 mode_lib->vba.VTAPsChroma,
3528                                                 mode_lib->vba.VRatio,
3529                                                 mode_lib->vba.VRatioChroma,
3530                                                 mode_lib->vba.HTotal,
3531                                                 mode_lib->vba.VTotal,
3532                                                 mode_lib->vba.VActive,
3533                                                 mode_lib->vba.PixelClock,
3534                                                 mode_lib->vba.BlendingAndTiming,
3535                                                 mode_lib->vba.NoOfDPPThisState,
3536                                                 mode_lib->vba.BytePerPixelInDETY,
3537                                                 mode_lib->vba.BytePerPixelInDETC,
3538                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.DSTXAfterScaler,
3539                                                 v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.DSTYAfterScaler,
3540                                                 mode_lib->vba.WritebackEnable,
3541                                                 mode_lib->vba.WritebackPixelFormat,
3542                                                 mode_lib->vba.WritebackDestinationWidth,
3543                                                 mode_lib->vba.WritebackDestinationHeight,
3544                                                 mode_lib->vba.WritebackSourceHeight,
3545                                                 mode_lib->vba.UnboundedRequestEnabledThisState,
3546                                                 mode_lib->vba.CompressedBufferSizeInkByteThisState,
3547
3548                                                 /* Output */
3549                                                 &mode_lib->vba.Watermark, // Store the values in vba
3550                                                 &mode_lib->vba.DRAMClockChangeSupport[i][j],
3551                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single2[0], // double *MaxActiveDRAMClockChangeLatencySupported
3552                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_integer[0], // Long SubViewportLinesNeededInMALL[]
3553                                                 &mode_lib->vba.FCLKChangeSupport[i][j],
3554                                                 &v->dummy_vars.dml32_ModeSupportAndSystemConfigurationFull.dummy_single2[1], // double *MinActiveFCLKChangeLatencySupported
3555                                                 &mode_lib->vba.USRRetrainingSupport[i][j],
3556                                                 mode_lib->vba.ActiveDRAMClockChangeLatencyMargin);
3557                         }
3558                 }
3559         } // End of Prefetch Check
3560
3561         /*Cursor Support Check*/
3562         mode_lib->vba.CursorSupport = true;
3563         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3564                 if (mode_lib->vba.CursorWidth[k][0] > 0.0) {
3565                         if (mode_lib->vba.CursorBPP[k][0] == 64 && mode_lib->vba.Cursor64BppSupport == false)
3566                                 mode_lib->vba.CursorSupport = false;
3567                 }
3568         }
3569
3570         /*Valid Pitch Check*/
3571         mode_lib->vba.PitchSupport = true;
3572         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3573                 mode_lib->vba.AlignedYPitch[k] = dml_ceil(
3574                                 dml_max(mode_lib->vba.PitchY[k], mode_lib->vba.SurfaceWidthY[k]),
3575                                 mode_lib->vba.MacroTileWidthY[k]);
3576                 if (mode_lib->vba.DCCEnable[k] == true) {
3577                         mode_lib->vba.AlignedDCCMetaPitchY[k] = dml_ceil(
3578                                         dml_max(mode_lib->vba.DCCMetaPitchY[k], mode_lib->vba.SurfaceWidthY[k]),
3579                                         64.0 * mode_lib->vba.Read256BlockWidthY[k]);
3580                 } else {
3581                         mode_lib->vba.AlignedDCCMetaPitchY[k] = mode_lib->vba.DCCMetaPitchY[k];
3582                 }
3583                 if (mode_lib->vba.SourcePixelFormat[k] != dm_444_64 && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
3584                                 && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
3585                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_16
3586                                 && mode_lib->vba.SourcePixelFormat[k] != dm_rgbe
3587                                 && mode_lib->vba.SourcePixelFormat[k] != dm_mono_8) {
3588                         mode_lib->vba.AlignedCPitch[k] = dml_ceil(
3589                                         dml_max(mode_lib->vba.PitchC[k], mode_lib->vba.SurfaceWidthC[k]),
3590                                         mode_lib->vba.MacroTileWidthC[k]);
3591                         if (mode_lib->vba.DCCEnable[k] == true) {
3592                                 mode_lib->vba.AlignedDCCMetaPitchC[k] = dml_ceil(
3593                                                 dml_max(mode_lib->vba.DCCMetaPitchC[k],
3594                                                                 mode_lib->vba.SurfaceWidthC[k]),
3595                                                 64.0 * mode_lib->vba.Read256BlockWidthC[k]);
3596                         } else {
3597                                 mode_lib->vba.AlignedDCCMetaPitchC[k] = mode_lib->vba.DCCMetaPitchC[k];
3598                         }
3599                 } else {
3600                         mode_lib->vba.AlignedCPitch[k] = mode_lib->vba.PitchC[k];
3601                         mode_lib->vba.AlignedDCCMetaPitchC[k] = mode_lib->vba.DCCMetaPitchC[k];
3602                 }
3603                 if (mode_lib->vba.AlignedYPitch[k] > mode_lib->vba.PitchY[k]
3604                                 || mode_lib->vba.AlignedCPitch[k] > mode_lib->vba.PitchC[k]
3605                                 || mode_lib->vba.AlignedDCCMetaPitchY[k] > mode_lib->vba.DCCMetaPitchY[k]
3606                                 || mode_lib->vba.AlignedDCCMetaPitchC[k] > mode_lib->vba.DCCMetaPitchC[k]) {
3607                         mode_lib->vba.PitchSupport = false;
3608                 }
3609         }
3610
3611         mode_lib->vba.ViewportExceedsSurface = false;
3612         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3613                 if (mode_lib->vba.ViewportWidth[k] > mode_lib->vba.SurfaceWidthY[k]
3614                                 || mode_lib->vba.ViewportHeight[k] > mode_lib->vba.SurfaceHeightY[k]) {
3615                         mode_lib->vba.ViewportExceedsSurface = true;
3616                         if (mode_lib->vba.SourcePixelFormat[k] != dm_444_64
3617                                         && mode_lib->vba.SourcePixelFormat[k] != dm_444_32
3618                                         && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
3619                                         && mode_lib->vba.SourcePixelFormat[k] != dm_444_16
3620                                         && mode_lib->vba.SourcePixelFormat[k] != dm_444_8
3621                                         && mode_lib->vba.SourcePixelFormat[k] != dm_rgbe) {
3622                                 if (mode_lib->vba.ViewportWidthChroma[k] > mode_lib->vba.SurfaceWidthC[k]
3623                                                 || mode_lib->vba.ViewportHeightChroma[k]
3624                                                                 > mode_lib->vba.SurfaceHeightC[k]) {
3625                                         mode_lib->vba.ViewportExceedsSurface = true;
3626                                 }
3627                         }
3628                 }
3629         }
3630
3631         /*Mode Support, Voltage State and SOC Configuration*/
3632         for (i = v->soc.num_states - 1; i >= 0; i--) {
3633                 for (j = 0; j < 2; j++) {
3634                         if (mode_lib->vba.ScaleRatioAndTapsSupport == true
3635                                 && mode_lib->vba.SourceFormatPixelAndScanSupport == true
3636                                 && mode_lib->vba.ViewportSizeSupport[i][j] == true
3637                                 && !mode_lib->vba.LinkRateDoesNotMatchDPVersion
3638                                 && !mode_lib->vba.LinkRateForMultistreamNotIndicated
3639                                 && !mode_lib->vba.BPPForMultistreamNotIndicated
3640                                 && !mode_lib->vba.MultistreamWithHDMIOreDP
3641                                 && !mode_lib->vba.ExceededMultistreamSlots[i]
3642                                 && !mode_lib->vba.MSOOrODMSplitWithNonDPLink
3643                                 && !mode_lib->vba.NotEnoughLanesForMSO
3644                                 && mode_lib->vba.LinkCapacitySupport[i] == true && !mode_lib->vba.P2IWith420
3645                                 && !mode_lib->vba.DSCOnlyIfNecessaryWithBPP
3646                                 && !mode_lib->vba.DSC422NativeNotSupported
3647                                 && !mode_lib->vba.MPCCombineMethodIncompatible
3648                                 && mode_lib->vba.ODMCombine2To1SupportCheckOK[i] == true
3649                                 && mode_lib->vba.ODMCombine4To1SupportCheckOK[i] == true
3650                                 && mode_lib->vba.NotEnoughDSCUnits[i] == false
3651                                 && !mode_lib->vba.NotEnoughDSCSlices[i]
3652                                 && !mode_lib->vba.ImmediateFlipOrHostVMAndPStateWithMALLFullFrameOrPhantomPipe
3653                                 && !mode_lib->vba.InvalidCombinationOfMALLUseForPStateAndStaticScreen
3654                                 && mode_lib->vba.DSCCLKRequiredMoreThanSupported[i] == false
3655                                 && mode_lib->vba.PixelsPerLinePerDSCUnitSupport[i]
3656                                 && mode_lib->vba.DTBCLKRequiredMoreThanSupported[i] == false
3657                                 && !mode_lib->vba.InvalidCombinationOfMALLUseForPState
3658                                 && !mode_lib->vba.ImmediateFlipRequiredButTheRequirementForEachSurfaceIsNotSpecified
3659                                 && mode_lib->vba.ROBSupport[i][j] == true
3660                                 && mode_lib->vba.DISPCLK_DPPCLK_Support[i][j] == true
3661                                 && mode_lib->vba.TotalAvailablePipesSupport[i][j] == true
3662                                 && mode_lib->vba.NumberOfOTGSupport == true
3663                                 && mode_lib->vba.NumberOfHDMIFRLSupport == true
3664                                 && mode_lib->vba.EnoughWritebackUnits == true
3665                                 && mode_lib->vba.WritebackLatencySupport == true
3666                                 && mode_lib->vba.WritebackScaleRatioAndTapsSupport == true
3667                                 && mode_lib->vba.CursorSupport == true && mode_lib->vba.PitchSupport == true
3668                                 && mode_lib->vba.ViewportExceedsSurface == false
3669                                 && mode_lib->vba.PrefetchSupported[i][j] == true
3670                                 && mode_lib->vba.VActiveBandwithSupport[i][j] == true
3671                                 && mode_lib->vba.DynamicMetadataSupported[i][j] == true
3672                                 && mode_lib->vba.TotalVerticalActiveBandwidthSupport[i][j] == true
3673                                 && mode_lib->vba.VRatioInPrefetchSupported[i][j] == true
3674                                 && mode_lib->vba.PTEBufferSizeNotExceeded[i][j] == true
3675                                 && mode_lib->vba.DCCMetaBufferSizeNotExceeded[i][j] == true
3676                                 && mode_lib->vba.NonsupportedDSCInputBPC == false
3677                                 && !mode_lib->vba.ExceededMALLSize
3678                                 && ((mode_lib->vba.HostVMEnable == false
3679                                 && !mode_lib->vba.ImmediateFlipRequiredFinal)
3680                                 || mode_lib->vba.ImmediateFlipSupportedForState[i][j])
3681                                 && (!mode_lib->vba.DRAMClockChangeRequirementFinal
3682                                 || i == v->soc.num_states - 1
3683                                 || mode_lib->vba.DRAMClockChangeSupport[i][j] != dm_dram_clock_change_unsupported)
3684                                 && (!mode_lib->vba.FCLKChangeRequirementFinal || i == v->soc.num_states - 1
3685                                 || mode_lib->vba.FCLKChangeSupport[i][j] != dm_fclock_change_unsupported)
3686                                 && (!mode_lib->vba.USRRetrainingRequiredFinal
3687                                 || mode_lib->vba.USRRetrainingSupport[i][j])) {
3688                                 mode_lib->vba.ModeSupport[i][j] = true;
3689                         } else {
3690                                 mode_lib->vba.ModeSupport[i][j] = false;
3691                         }
3692                 }
3693         }
3694
3695         MaximumMPCCombine = 0;
3696
3697         for (i = v->soc.num_states; i >= 0; i--) {
3698                 if (i == v->soc.num_states || mode_lib->vba.ModeSupport[i][0] == true ||
3699                                 mode_lib->vba.ModeSupport[i][1] == true) {
3700                         mode_lib->vba.VoltageLevel = i;
3701                         mode_lib->vba.ModeIsSupported = mode_lib->vba.ModeSupport[i][0] == true
3702                                         || mode_lib->vba.ModeSupport[i][1] == true;
3703
3704                         if (mode_lib->vba.ModeSupport[i][0] == true) {
3705                                 MaximumMPCCombine = 0;
3706                         } else {
3707                                 MaximumMPCCombine = 1;
3708                         }
3709                 }
3710         }
3711
3712         mode_lib->vba.ImmediateFlipSupport =
3713                         mode_lib->vba.ImmediateFlipSupportedForState[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3714         mode_lib->vba.UnboundedRequestEnabled =
3715                         mode_lib->vba.UnboundedRequestEnabledAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3716         mode_lib->vba.CompressedBufferSizeInkByte =
3717                         mode_lib->vba.CompressedBufferSizeInkByteAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine]; // Not used, informational
3718
3719         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3720                 mode_lib->vba.MPCCombineEnable[k] =
3721                                 mode_lib->vba.MPCCombine[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3722                 mode_lib->vba.DPPPerPlane[k] = mode_lib->vba.NoOfDPP[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3723                 mode_lib->vba.SwathHeightY[k] =
3724                                 mode_lib->vba.SwathHeightYAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3725                 mode_lib->vba.SwathHeightC[k] =
3726                                 mode_lib->vba.SwathHeightCAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3727                 mode_lib->vba.DETBufferSizeInKByte[k] =
3728                         mode_lib->vba.DETBufferSizeInKByteAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3729                 mode_lib->vba.DETBufferSizeY[k] =
3730                                 mode_lib->vba.DETBufferSizeYAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3731                 mode_lib->vba.DETBufferSizeC[k] =
3732                                 mode_lib->vba.DETBufferSizeCAllStates[mode_lib->vba.VoltageLevel][MaximumMPCCombine][k];
3733                 mode_lib->vba.OutputType[k] = mode_lib->vba.OutputTypePerState[mode_lib->vba.VoltageLevel][k];
3734                 mode_lib->vba.OutputRate[k] = mode_lib->vba.OutputRatePerState[mode_lib->vba.VoltageLevel][k];
3735         }
3736
3737         mode_lib->vba.DCFCLK = mode_lib->vba.DCFCLKState[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3738         mode_lib->vba.DRAMSpeed = mode_lib->vba.DRAMSpeedPerState[mode_lib->vba.VoltageLevel];
3739         mode_lib->vba.FabricClock = mode_lib->vba.FabricClockPerState[mode_lib->vba.VoltageLevel];
3740         mode_lib->vba.SOCCLK = mode_lib->vba.SOCCLKPerState[mode_lib->vba.VoltageLevel];
3741         mode_lib->vba.ReturnBW = mode_lib->vba.ReturnBWPerState[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3742         mode_lib->vba.DISPCLK = mode_lib->vba.RequiredDISPCLK[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3743         mode_lib->vba.maxMpcComb = MaximumMPCCombine;
3744
3745         for (k = 0; k <= mode_lib->vba.NumberOfActiveSurfaces - 1; k++) {
3746                 if (mode_lib->vba.BlendingAndTiming[k] == k) {
3747                         mode_lib->vba.ODMCombineEnabled[k] =
3748                                         mode_lib->vba.ODMCombineEnablePerState[mode_lib->vba.VoltageLevel][k];
3749                 } else {
3750                         mode_lib->vba.ODMCombineEnabled[k] = dm_odm_combine_mode_disabled;
3751                 }
3752
3753                 mode_lib->vba.DSCEnabled[k] = mode_lib->vba.RequiresDSC[mode_lib->vba.VoltageLevel][k];
3754                 mode_lib->vba.FECEnable[k] = mode_lib->vba.RequiresFEC[mode_lib->vba.VoltageLevel][k];
3755                 mode_lib->vba.OutputBpp[k] = mode_lib->vba.OutputBppPerState[mode_lib->vba.VoltageLevel][k];
3756         }
3757
3758         mode_lib->vba.UrgentWatermark = mode_lib->vba.Watermark.UrgentWatermark;
3759         mode_lib->vba.StutterEnterPlusExitWatermark = mode_lib->vba.Watermark.StutterEnterPlusExitWatermark;
3760         mode_lib->vba.StutterExitWatermark = mode_lib->vba.Watermark.StutterExitWatermark;
3761         mode_lib->vba.WritebackDRAMClockChangeWatermark = mode_lib->vba.Watermark.WritebackDRAMClockChangeWatermark;
3762         mode_lib->vba.DRAMClockChangeWatermark = mode_lib->vba.Watermark.DRAMClockChangeWatermark;
3763         mode_lib->vba.UrgentLatency = mode_lib->vba.UrgLatency[mode_lib->vba.VoltageLevel];
3764         mode_lib->vba.DCFCLKDeepSleep = mode_lib->vba.ProjectedDCFCLKDeepSleep[mode_lib->vba.VoltageLevel][MaximumMPCCombine];
3765
3766         /* VBA has Error type to Error Msg output here, but not necessary for DML-C */
3767 } // ModeSupportAndSystemConfigurationFull