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