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