1dda4fb85SAurabindo Pillai /*
2dda4fb85SAurabindo Pillai * Copyright 2022 Advanced Micro Devices, Inc.
3dda4fb85SAurabindo Pillai *
4dda4fb85SAurabindo Pillai * Permission is hereby granted, free of charge, to any person obtaining a
5dda4fb85SAurabindo Pillai * copy of this software and associated documentation files (the "Software"),
6dda4fb85SAurabindo Pillai * to deal in the Software without restriction, including without limitation
7dda4fb85SAurabindo Pillai * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8dda4fb85SAurabindo Pillai * and/or sell copies of the Software, and to permit persons to whom the
9dda4fb85SAurabindo Pillai * Software is furnished to do so, subject to the following conditions:
10dda4fb85SAurabindo Pillai *
11dda4fb85SAurabindo Pillai * The above copyright notice and this permission notice shall be included in
12dda4fb85SAurabindo Pillai * all copies or substantial portions of the Software.
13dda4fb85SAurabindo Pillai *
14dda4fb85SAurabindo Pillai * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15dda4fb85SAurabindo Pillai * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16dda4fb85SAurabindo Pillai * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17dda4fb85SAurabindo Pillai * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18dda4fb85SAurabindo Pillai * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19dda4fb85SAurabindo Pillai * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20dda4fb85SAurabindo Pillai * OTHER DEALINGS IN THE SOFTWARE.
21dda4fb85SAurabindo Pillai *
22dda4fb85SAurabindo Pillai * Authors: AMD
23dda4fb85SAurabindo Pillai *
24dda4fb85SAurabindo Pillai */
25dda4fb85SAurabindo Pillai #include "display_mode_vba_util_32.h"
26dda4fb85SAurabindo Pillai #include "../dml_inline_defs.h"
27dda4fb85SAurabindo Pillai #include "display_mode_vba_32.h"
28dda4fb85SAurabindo Pillai #include "../display_mode_lib.h"
29dda4fb85SAurabindo Pillai
3016e5859dSChris Park #define DCN32_MAX_FMT_420_BUFFER_WIDTH 4096
3116e5859dSChris Park
dml32_dscceComputeDelay(unsigned int bpc,double BPP,unsigned int sliceWidth,unsigned int numSlices,enum output_format_class pixelFormat,enum output_encoder_class Output)32dda4fb85SAurabindo Pillai unsigned int dml32_dscceComputeDelay(
33dda4fb85SAurabindo Pillai unsigned int bpc,
34dda4fb85SAurabindo Pillai double BPP,
35dda4fb85SAurabindo Pillai unsigned int sliceWidth,
36dda4fb85SAurabindo Pillai unsigned int numSlices,
37dda4fb85SAurabindo Pillai enum output_format_class pixelFormat,
38dda4fb85SAurabindo Pillai enum output_encoder_class Output)
39dda4fb85SAurabindo Pillai {
40dda4fb85SAurabindo Pillai // valid bpc = source bits per component in the set of {8, 10, 12}
41dda4fb85SAurabindo Pillai // valid bpp = increments of 1/16 of a bit
42dda4fb85SAurabindo Pillai // min = 6/7/8 in N420/N422/444, respectively
43dda4fb85SAurabindo Pillai // max = such that compression is 1:1
44dda4fb85SAurabindo Pillai //valid sliceWidth = number of pixels per slice line,
45dda4fb85SAurabindo Pillai // must be less than or equal to 5184/numSlices (or 4096/numSlices in 420 mode)
46dda4fb85SAurabindo Pillai //valid numSlices = number of slices in the horiziontal direction per DSC engine in the set of {1, 2, 3, 4}
47dda4fb85SAurabindo Pillai //valid pixelFormat = pixel/color format in the set of {:N444_RGB, :S422, :N422, :N420}
48dda4fb85SAurabindo Pillai
49dda4fb85SAurabindo Pillai // fixed value
50dda4fb85SAurabindo Pillai unsigned int rcModelSize = 8192;
51dda4fb85SAurabindo Pillai
52dda4fb85SAurabindo Pillai // N422/N420 operate at 2 pixels per clock
53dda4fb85SAurabindo Pillai unsigned int pixelsPerClock, lstall, D, initalXmitDelay, w, s, ix, wx, p, l0, a, ax, L,
54dda4fb85SAurabindo Pillai Delay, pixels;
55dda4fb85SAurabindo Pillai
56dda4fb85SAurabindo Pillai if (pixelFormat == dm_420)
57dda4fb85SAurabindo Pillai pixelsPerClock = 2;
58dda4fb85SAurabindo Pillai else if (pixelFormat == dm_n422)
59dda4fb85SAurabindo Pillai pixelsPerClock = 2;
60dda4fb85SAurabindo Pillai // #all other modes operate at 1 pixel per clock
61dda4fb85SAurabindo Pillai else
62dda4fb85SAurabindo Pillai pixelsPerClock = 1;
63dda4fb85SAurabindo Pillai
64dda4fb85SAurabindo Pillai //initial transmit delay as per PPS
65dda4fb85SAurabindo Pillai initalXmitDelay = dml_round(rcModelSize / 2.0 / BPP / pixelsPerClock);
66dda4fb85SAurabindo Pillai
67dda4fb85SAurabindo Pillai //compute ssm delay
68dda4fb85SAurabindo Pillai if (bpc == 8)
69dda4fb85SAurabindo Pillai D = 81;
70dda4fb85SAurabindo Pillai else if (bpc == 10)
71dda4fb85SAurabindo Pillai D = 89;
72dda4fb85SAurabindo Pillai else
73dda4fb85SAurabindo Pillai D = 113;
74dda4fb85SAurabindo Pillai
75dda4fb85SAurabindo Pillai //divide by pixel per cycle to compute slice width as seen by DSC
76dda4fb85SAurabindo Pillai w = sliceWidth / pixelsPerClock;
77dda4fb85SAurabindo Pillai
78dda4fb85SAurabindo Pillai //422 mode has an additional cycle of delay
79dda4fb85SAurabindo Pillai if (pixelFormat == dm_420 || pixelFormat == dm_444 || pixelFormat == dm_n422)
80dda4fb85SAurabindo Pillai s = 0;
81dda4fb85SAurabindo Pillai else
82dda4fb85SAurabindo Pillai s = 1;
83dda4fb85SAurabindo Pillai
84dda4fb85SAurabindo Pillai //main calculation for the dscce
85dda4fb85SAurabindo Pillai ix = initalXmitDelay + 45;
86dda4fb85SAurabindo Pillai wx = (w + 2) / 3;
87dda4fb85SAurabindo Pillai p = 3 * wx - w;
88dda4fb85SAurabindo Pillai l0 = ix / w;
89dda4fb85SAurabindo Pillai a = ix + p * l0;
90dda4fb85SAurabindo Pillai ax = (a + 2) / 3 + D + 6 + 1;
91dda4fb85SAurabindo Pillai L = (ax + wx - 1) / wx;
92dda4fb85SAurabindo Pillai if ((ix % w) == 0 && p != 0)
93dda4fb85SAurabindo Pillai lstall = 1;
94dda4fb85SAurabindo Pillai else
95dda4fb85SAurabindo Pillai lstall = 0;
96dda4fb85SAurabindo Pillai Delay = L * wx * (numSlices - 1) + ax + s + lstall + 22;
97dda4fb85SAurabindo Pillai
98dda4fb85SAurabindo Pillai //dsc processes 3 pixel containers per cycle and a container can contain 1 or 2 pixels
99dda4fb85SAurabindo Pillai pixels = Delay * 3 * pixelsPerClock;
100dda4fb85SAurabindo Pillai
101dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
102dda4fb85SAurabindo Pillai dml_print("DML::%s: bpc: %d\n", __func__, bpc);
103dda4fb85SAurabindo Pillai dml_print("DML::%s: BPP: %f\n", __func__, BPP);
104dda4fb85SAurabindo Pillai dml_print("DML::%s: sliceWidth: %d\n", __func__, sliceWidth);
105dda4fb85SAurabindo Pillai dml_print("DML::%s: numSlices: %d\n", __func__, numSlices);
106dda4fb85SAurabindo Pillai dml_print("DML::%s: pixelFormat: %d\n", __func__, pixelFormat);
107dda4fb85SAurabindo Pillai dml_print("DML::%s: Output: %d\n", __func__, Output);
108dda4fb85SAurabindo Pillai dml_print("DML::%s: pixels: %d\n", __func__, pixels);
109dda4fb85SAurabindo Pillai #endif
110dda4fb85SAurabindo Pillai
111dda4fb85SAurabindo Pillai return pixels;
112dda4fb85SAurabindo Pillai }
113dda4fb85SAurabindo Pillai
dml32_dscComputeDelay(enum output_format_class pixelFormat,enum output_encoder_class Output)114dda4fb85SAurabindo Pillai unsigned int dml32_dscComputeDelay(enum output_format_class pixelFormat, enum output_encoder_class Output)
115dda4fb85SAurabindo Pillai {
116dda4fb85SAurabindo Pillai unsigned int Delay = 0;
117dda4fb85SAurabindo Pillai
118dda4fb85SAurabindo Pillai if (pixelFormat == dm_420) {
119dda4fb85SAurabindo Pillai // sfr
120dda4fb85SAurabindo Pillai Delay = Delay + 2;
121dda4fb85SAurabindo Pillai // dsccif
122dda4fb85SAurabindo Pillai Delay = Delay + 0;
123dda4fb85SAurabindo Pillai // dscc - input deserializer
124dda4fb85SAurabindo Pillai Delay = Delay + 3;
125dda4fb85SAurabindo Pillai // dscc gets pixels every other cycle
126dda4fb85SAurabindo Pillai Delay = Delay + 2;
127dda4fb85SAurabindo Pillai // dscc - input cdc fifo
128dda4fb85SAurabindo Pillai Delay = Delay + 12;
129dda4fb85SAurabindo Pillai // dscc gets pixels every other cycle
130dda4fb85SAurabindo Pillai Delay = Delay + 13;
131dda4fb85SAurabindo Pillai // dscc - cdc uncertainty
132dda4fb85SAurabindo Pillai Delay = Delay + 2;
133dda4fb85SAurabindo Pillai // dscc - output cdc fifo
134dda4fb85SAurabindo Pillai Delay = Delay + 7;
135dda4fb85SAurabindo Pillai // dscc gets pixels every other cycle
136dda4fb85SAurabindo Pillai Delay = Delay + 3;
137dda4fb85SAurabindo Pillai // dscc - cdc uncertainty
138dda4fb85SAurabindo Pillai Delay = Delay + 2;
139dda4fb85SAurabindo Pillai // dscc - output serializer
140dda4fb85SAurabindo Pillai Delay = Delay + 1;
141dda4fb85SAurabindo Pillai // sft
142dda4fb85SAurabindo Pillai Delay = Delay + 1;
143dda4fb85SAurabindo Pillai } else if (pixelFormat == dm_n422 || (pixelFormat != dm_444)) {
144dda4fb85SAurabindo Pillai // sfr
145dda4fb85SAurabindo Pillai Delay = Delay + 2;
146dda4fb85SAurabindo Pillai // dsccif
147dda4fb85SAurabindo Pillai Delay = Delay + 1;
148dda4fb85SAurabindo Pillai // dscc - input deserializer
149dda4fb85SAurabindo Pillai Delay = Delay + 5;
150dda4fb85SAurabindo Pillai // dscc - input cdc fifo
151dda4fb85SAurabindo Pillai Delay = Delay + 25;
152dda4fb85SAurabindo Pillai // dscc - cdc uncertainty
153dda4fb85SAurabindo Pillai Delay = Delay + 2;
154dda4fb85SAurabindo Pillai // dscc - output cdc fifo
155dda4fb85SAurabindo Pillai Delay = Delay + 10;
156dda4fb85SAurabindo Pillai // dscc - cdc uncertainty
157dda4fb85SAurabindo Pillai Delay = Delay + 2;
158dda4fb85SAurabindo Pillai // dscc - output serializer
159dda4fb85SAurabindo Pillai Delay = Delay + 1;
160dda4fb85SAurabindo Pillai // sft
161dda4fb85SAurabindo Pillai Delay = Delay + 1;
162dda4fb85SAurabindo Pillai } else {
163dda4fb85SAurabindo Pillai // sfr
164dda4fb85SAurabindo Pillai Delay = Delay + 2;
165dda4fb85SAurabindo Pillai // dsccif
166dda4fb85SAurabindo Pillai Delay = Delay + 0;
167dda4fb85SAurabindo Pillai // dscc - input deserializer
168dda4fb85SAurabindo Pillai Delay = Delay + 3;
169dda4fb85SAurabindo Pillai // dscc - input cdc fifo
170dda4fb85SAurabindo Pillai Delay = Delay + 12;
171dda4fb85SAurabindo Pillai // dscc - cdc uncertainty
172dda4fb85SAurabindo Pillai Delay = Delay + 2;
173dda4fb85SAurabindo Pillai // dscc - output cdc fifo
174dda4fb85SAurabindo Pillai Delay = Delay + 7;
175dda4fb85SAurabindo Pillai // dscc - output serializer
176dda4fb85SAurabindo Pillai Delay = Delay + 1;
177dda4fb85SAurabindo Pillai // dscc - cdc uncertainty
178dda4fb85SAurabindo Pillai Delay = Delay + 2;
179dda4fb85SAurabindo Pillai // sft
180dda4fb85SAurabindo Pillai Delay = Delay + 1;
181dda4fb85SAurabindo Pillai }
182dda4fb85SAurabindo Pillai
183dda4fb85SAurabindo Pillai return Delay;
184dda4fb85SAurabindo Pillai }
185dda4fb85SAurabindo Pillai
186dda4fb85SAurabindo Pillai
IsVertical(enum dm_rotation_angle Scan)187dda4fb85SAurabindo Pillai bool IsVertical(enum dm_rotation_angle Scan)
188dda4fb85SAurabindo Pillai {
189dda4fb85SAurabindo Pillai bool is_vert = false;
190dda4fb85SAurabindo Pillai
191dda4fb85SAurabindo Pillai if (Scan == dm_rotation_90 || Scan == dm_rotation_90m || Scan == dm_rotation_270 || Scan == dm_rotation_270m)
192dda4fb85SAurabindo Pillai is_vert = true;
193dda4fb85SAurabindo Pillai else
194dda4fb85SAurabindo Pillai is_vert = false;
195dda4fb85SAurabindo Pillai return is_vert;
196dda4fb85SAurabindo Pillai }
197dda4fb85SAurabindo Pillai
dml32_CalculateSinglePipeDPPCLKAndSCLThroughput(double HRatio,double HRatioChroma,double VRatio,double VRatioChroma,double MaxDCHUBToPSCLThroughput,double MaxPSCLToLBThroughput,double PixelClock,enum source_format_class SourcePixelFormat,unsigned int HTaps,unsigned int HTapsChroma,unsigned int VTaps,unsigned int VTapsChroma,double * PSCL_THROUGHPUT,double * PSCL_THROUGHPUT_CHROMA,double * DPPCLKUsingSingleDPP)198dda4fb85SAurabindo Pillai void dml32_CalculateSinglePipeDPPCLKAndSCLThroughput(
199dda4fb85SAurabindo Pillai double HRatio,
200dda4fb85SAurabindo Pillai double HRatioChroma,
201dda4fb85SAurabindo Pillai double VRatio,
202dda4fb85SAurabindo Pillai double VRatioChroma,
203dda4fb85SAurabindo Pillai double MaxDCHUBToPSCLThroughput,
204dda4fb85SAurabindo Pillai double MaxPSCLToLBThroughput,
205dda4fb85SAurabindo Pillai double PixelClock,
206dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat,
207dda4fb85SAurabindo Pillai unsigned int HTaps,
208dda4fb85SAurabindo Pillai unsigned int HTapsChroma,
209dda4fb85SAurabindo Pillai unsigned int VTaps,
210dda4fb85SAurabindo Pillai unsigned int VTapsChroma,
211dda4fb85SAurabindo Pillai
212dda4fb85SAurabindo Pillai /* output */
213dda4fb85SAurabindo Pillai double *PSCL_THROUGHPUT,
214dda4fb85SAurabindo Pillai double *PSCL_THROUGHPUT_CHROMA,
215dda4fb85SAurabindo Pillai double *DPPCLKUsingSingleDPP)
216dda4fb85SAurabindo Pillai {
217dda4fb85SAurabindo Pillai double DPPCLKUsingSingleDPPLuma;
218dda4fb85SAurabindo Pillai double DPPCLKUsingSingleDPPChroma;
219dda4fb85SAurabindo Pillai
220dda4fb85SAurabindo Pillai if (HRatio > 1) {
221dda4fb85SAurabindo Pillai *PSCL_THROUGHPUT = dml_min(MaxDCHUBToPSCLThroughput, MaxPSCLToLBThroughput * HRatio /
222dda4fb85SAurabindo Pillai dml_ceil((double) HTaps / 6.0, 1.0));
223dda4fb85SAurabindo Pillai } else {
224dda4fb85SAurabindo Pillai *PSCL_THROUGHPUT = dml_min(MaxDCHUBToPSCLThroughput, MaxPSCLToLBThroughput);
225dda4fb85SAurabindo Pillai }
226dda4fb85SAurabindo Pillai
227dda4fb85SAurabindo Pillai DPPCLKUsingSingleDPPLuma = PixelClock * dml_max3(VTaps / 6 * dml_min(1, HRatio), HRatio * VRatio /
228dda4fb85SAurabindo Pillai *PSCL_THROUGHPUT, 1);
229dda4fb85SAurabindo Pillai
230dda4fb85SAurabindo Pillai if ((HTaps > 6 || VTaps > 6) && DPPCLKUsingSingleDPPLuma < 2 * PixelClock)
231dda4fb85SAurabindo Pillai DPPCLKUsingSingleDPPLuma = 2 * PixelClock;
232dda4fb85SAurabindo Pillai
233dda4fb85SAurabindo Pillai if ((SourcePixelFormat != dm_420_8 && SourcePixelFormat != dm_420_10 && SourcePixelFormat != dm_420_12 &&
234dda4fb85SAurabindo Pillai SourcePixelFormat != dm_rgbe_alpha)) {
235dda4fb85SAurabindo Pillai *PSCL_THROUGHPUT_CHROMA = 0;
236dda4fb85SAurabindo Pillai *DPPCLKUsingSingleDPP = DPPCLKUsingSingleDPPLuma;
237dda4fb85SAurabindo Pillai } else {
238dda4fb85SAurabindo Pillai if (HRatioChroma > 1) {
239dda4fb85SAurabindo Pillai *PSCL_THROUGHPUT_CHROMA = dml_min(MaxDCHUBToPSCLThroughput, MaxPSCLToLBThroughput *
240dda4fb85SAurabindo Pillai HRatioChroma / dml_ceil((double) HTapsChroma / 6.0, 1.0));
241dda4fb85SAurabindo Pillai } else {
242dda4fb85SAurabindo Pillai *PSCL_THROUGHPUT_CHROMA = dml_min(MaxDCHUBToPSCLThroughput, MaxPSCLToLBThroughput);
243dda4fb85SAurabindo Pillai }
244dda4fb85SAurabindo Pillai DPPCLKUsingSingleDPPChroma = PixelClock * dml_max3(VTapsChroma / 6 * dml_min(1, HRatioChroma),
245dda4fb85SAurabindo Pillai HRatioChroma * VRatioChroma / *PSCL_THROUGHPUT_CHROMA, 1);
246dda4fb85SAurabindo Pillai if ((HTapsChroma > 6 || VTapsChroma > 6) && DPPCLKUsingSingleDPPChroma < 2 * PixelClock)
247dda4fb85SAurabindo Pillai DPPCLKUsingSingleDPPChroma = 2 * PixelClock;
248dda4fb85SAurabindo Pillai *DPPCLKUsingSingleDPP = dml_max(DPPCLKUsingSingleDPPLuma, DPPCLKUsingSingleDPPChroma);
249dda4fb85SAurabindo Pillai }
250dda4fb85SAurabindo Pillai }
251dda4fb85SAurabindo Pillai
dml32_CalculateBytePerPixelAndBlockSizes(enum source_format_class SourcePixelFormat,enum dm_swizzle_mode SurfaceTiling,unsigned int * BytePerPixelY,unsigned int * BytePerPixelC,double * BytePerPixelDETY,double * BytePerPixelDETC,unsigned int * BlockHeight256BytesY,unsigned int * BlockHeight256BytesC,unsigned int * BlockWidth256BytesY,unsigned int * BlockWidth256BytesC,unsigned int * MacroTileHeightY,unsigned int * MacroTileHeightC,unsigned int * MacroTileWidthY,unsigned int * MacroTileWidthC)252dda4fb85SAurabindo Pillai void dml32_CalculateBytePerPixelAndBlockSizes(
253dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat,
254dda4fb85SAurabindo Pillai enum dm_swizzle_mode SurfaceTiling,
255dda4fb85SAurabindo Pillai
256dda4fb85SAurabindo Pillai /* Output */
257dda4fb85SAurabindo Pillai unsigned int *BytePerPixelY,
258dda4fb85SAurabindo Pillai unsigned int *BytePerPixelC,
259dda4fb85SAurabindo Pillai double *BytePerPixelDETY,
260dda4fb85SAurabindo Pillai double *BytePerPixelDETC,
261dda4fb85SAurabindo Pillai unsigned int *BlockHeight256BytesY,
262dda4fb85SAurabindo Pillai unsigned int *BlockHeight256BytesC,
263dda4fb85SAurabindo Pillai unsigned int *BlockWidth256BytesY,
264dda4fb85SAurabindo Pillai unsigned int *BlockWidth256BytesC,
265dda4fb85SAurabindo Pillai unsigned int *MacroTileHeightY,
266dda4fb85SAurabindo Pillai unsigned int *MacroTileHeightC,
267dda4fb85SAurabindo Pillai unsigned int *MacroTileWidthY,
268dda4fb85SAurabindo Pillai unsigned int *MacroTileWidthC)
269dda4fb85SAurabindo Pillai {
270dda4fb85SAurabindo Pillai if (SourcePixelFormat == dm_444_64) {
271dda4fb85SAurabindo Pillai *BytePerPixelDETY = 8;
272dda4fb85SAurabindo Pillai *BytePerPixelDETC = 0;
273dda4fb85SAurabindo Pillai *BytePerPixelY = 8;
274dda4fb85SAurabindo Pillai *BytePerPixelC = 0;
275dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_444_32 || SourcePixelFormat == dm_rgbe) {
276dda4fb85SAurabindo Pillai *BytePerPixelDETY = 4;
277dda4fb85SAurabindo Pillai *BytePerPixelDETC = 0;
278dda4fb85SAurabindo Pillai *BytePerPixelY = 4;
279dda4fb85SAurabindo Pillai *BytePerPixelC = 0;
28034ce1a6aSZhongjun Tan } else if (SourcePixelFormat == dm_444_16) {
281dda4fb85SAurabindo Pillai *BytePerPixelDETY = 2;
282dda4fb85SAurabindo Pillai *BytePerPixelDETC = 0;
283dda4fb85SAurabindo Pillai *BytePerPixelY = 2;
284dda4fb85SAurabindo Pillai *BytePerPixelC = 0;
285dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_444_8) {
286dda4fb85SAurabindo Pillai *BytePerPixelDETY = 1;
287dda4fb85SAurabindo Pillai *BytePerPixelDETC = 0;
288dda4fb85SAurabindo Pillai *BytePerPixelY = 1;
289dda4fb85SAurabindo Pillai *BytePerPixelC = 0;
290dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_rgbe_alpha) {
291dda4fb85SAurabindo Pillai *BytePerPixelDETY = 4;
292dda4fb85SAurabindo Pillai *BytePerPixelDETC = 1;
293dda4fb85SAurabindo Pillai *BytePerPixelY = 4;
294dda4fb85SAurabindo Pillai *BytePerPixelC = 1;
295dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_420_8) {
296dda4fb85SAurabindo Pillai *BytePerPixelDETY = 1;
297dda4fb85SAurabindo Pillai *BytePerPixelDETC = 2;
298dda4fb85SAurabindo Pillai *BytePerPixelY = 1;
299dda4fb85SAurabindo Pillai *BytePerPixelC = 2;
300dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_420_12) {
301dda4fb85SAurabindo Pillai *BytePerPixelDETY = 2;
302dda4fb85SAurabindo Pillai *BytePerPixelDETC = 4;
303dda4fb85SAurabindo Pillai *BytePerPixelY = 2;
304dda4fb85SAurabindo Pillai *BytePerPixelC = 4;
305dda4fb85SAurabindo Pillai } else {
306dda4fb85SAurabindo Pillai *BytePerPixelDETY = 4.0 / 3;
307dda4fb85SAurabindo Pillai *BytePerPixelDETC = 8.0 / 3;
308dda4fb85SAurabindo Pillai *BytePerPixelY = 2;
309dda4fb85SAurabindo Pillai *BytePerPixelC = 4;
310dda4fb85SAurabindo Pillai }
311dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
312dda4fb85SAurabindo Pillai dml_print("DML::%s: SourcePixelFormat = %d\n", __func__, SourcePixelFormat);
313dda4fb85SAurabindo Pillai dml_print("DML::%s: BytePerPixelDETY = %f\n", __func__, *BytePerPixelDETY);
314dda4fb85SAurabindo Pillai dml_print("DML::%s: BytePerPixelDETC = %f\n", __func__, *BytePerPixelDETC);
315dda4fb85SAurabindo Pillai dml_print("DML::%s: BytePerPixelY = %d\n", __func__, *BytePerPixelY);
316dda4fb85SAurabindo Pillai dml_print("DML::%s: BytePerPixelC = %d\n", __func__, *BytePerPixelC);
317dda4fb85SAurabindo Pillai #endif
318dda4fb85SAurabindo Pillai if ((SourcePixelFormat == dm_444_64 || SourcePixelFormat == dm_444_32
319dda4fb85SAurabindo Pillai || SourcePixelFormat == dm_444_16
320dda4fb85SAurabindo Pillai || SourcePixelFormat == dm_444_8
321dda4fb85SAurabindo Pillai || SourcePixelFormat == dm_mono_16
322dda4fb85SAurabindo Pillai || SourcePixelFormat == dm_mono_8
323dda4fb85SAurabindo Pillai || SourcePixelFormat == dm_rgbe)) {
324dda4fb85SAurabindo Pillai if (SurfaceTiling == dm_sw_linear)
325dda4fb85SAurabindo Pillai *BlockHeight256BytesY = 1;
326dda4fb85SAurabindo Pillai else if (SourcePixelFormat == dm_444_64)
327dda4fb85SAurabindo Pillai *BlockHeight256BytesY = 4;
328dda4fb85SAurabindo Pillai else if (SourcePixelFormat == dm_444_8)
329dda4fb85SAurabindo Pillai *BlockHeight256BytesY = 16;
330dda4fb85SAurabindo Pillai else
331dda4fb85SAurabindo Pillai *BlockHeight256BytesY = 8;
332dda4fb85SAurabindo Pillai
333dda4fb85SAurabindo Pillai *BlockWidth256BytesY = 256U / *BytePerPixelY / *BlockHeight256BytesY;
334dda4fb85SAurabindo Pillai *BlockHeight256BytesC = 0;
335dda4fb85SAurabindo Pillai *BlockWidth256BytesC = 0;
336dda4fb85SAurabindo Pillai } else {
337dda4fb85SAurabindo Pillai if (SurfaceTiling == dm_sw_linear) {
338dda4fb85SAurabindo Pillai *BlockHeight256BytesY = 1;
339dda4fb85SAurabindo Pillai *BlockHeight256BytesC = 1;
340dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_rgbe_alpha) {
341dda4fb85SAurabindo Pillai *BlockHeight256BytesY = 8;
342dda4fb85SAurabindo Pillai *BlockHeight256BytesC = 16;
343dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_420_8) {
344dda4fb85SAurabindo Pillai *BlockHeight256BytesY = 16;
345dda4fb85SAurabindo Pillai *BlockHeight256BytesC = 8;
346dda4fb85SAurabindo Pillai } else {
347dda4fb85SAurabindo Pillai *BlockHeight256BytesY = 8;
348dda4fb85SAurabindo Pillai *BlockHeight256BytesC = 8;
349dda4fb85SAurabindo Pillai }
350dda4fb85SAurabindo Pillai *BlockWidth256BytesY = 256U / *BytePerPixelY / *BlockHeight256BytesY;
351dda4fb85SAurabindo Pillai *BlockWidth256BytesC = 256U / *BytePerPixelC / *BlockHeight256BytesC;
352dda4fb85SAurabindo Pillai }
353dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
354dda4fb85SAurabindo Pillai dml_print("DML::%s: BlockWidth256BytesY = %d\n", __func__, *BlockWidth256BytesY);
355dda4fb85SAurabindo Pillai dml_print("DML::%s: BlockHeight256BytesY = %d\n", __func__, *BlockHeight256BytesY);
356dda4fb85SAurabindo Pillai dml_print("DML::%s: BlockWidth256BytesC = %d\n", __func__, *BlockWidth256BytesC);
357dda4fb85SAurabindo Pillai dml_print("DML::%s: BlockHeight256BytesC = %d\n", __func__, *BlockHeight256BytesC);
358dda4fb85SAurabindo Pillai #endif
359dda4fb85SAurabindo Pillai
360dda4fb85SAurabindo Pillai if (SurfaceTiling == dm_sw_linear) {
361dda4fb85SAurabindo Pillai *MacroTileHeightY = *BlockHeight256BytesY;
362dda4fb85SAurabindo Pillai *MacroTileWidthY = 256 / *BytePerPixelY / *MacroTileHeightY;
363dda4fb85SAurabindo Pillai *MacroTileHeightC = *BlockHeight256BytesC;
364dda4fb85SAurabindo Pillai if (*MacroTileHeightC == 0)
365dda4fb85SAurabindo Pillai *MacroTileWidthC = 0;
366dda4fb85SAurabindo Pillai else
367dda4fb85SAurabindo Pillai *MacroTileWidthC = 256 / *BytePerPixelC / *MacroTileHeightC;
368dda4fb85SAurabindo Pillai } else if (SurfaceTiling == dm_sw_64kb_d || SurfaceTiling == dm_sw_64kb_d_t ||
369dda4fb85SAurabindo Pillai SurfaceTiling == dm_sw_64kb_d_x || SurfaceTiling == dm_sw_64kb_r_x) {
370dda4fb85SAurabindo Pillai *MacroTileHeightY = 16 * *BlockHeight256BytesY;
371dda4fb85SAurabindo Pillai *MacroTileWidthY = 65536 / *BytePerPixelY / *MacroTileHeightY;
372dda4fb85SAurabindo Pillai *MacroTileHeightC = 16 * *BlockHeight256BytesC;
373dda4fb85SAurabindo Pillai if (*MacroTileHeightC == 0)
374dda4fb85SAurabindo Pillai *MacroTileWidthC = 0;
375dda4fb85SAurabindo Pillai else
376dda4fb85SAurabindo Pillai *MacroTileWidthC = 65536 / *BytePerPixelC / *MacroTileHeightC;
377dda4fb85SAurabindo Pillai } else {
378dda4fb85SAurabindo Pillai *MacroTileHeightY = 32 * *BlockHeight256BytesY;
379dda4fb85SAurabindo Pillai *MacroTileWidthY = 65536 * 4 / *BytePerPixelY / *MacroTileHeightY;
380dda4fb85SAurabindo Pillai *MacroTileHeightC = 32 * *BlockHeight256BytesC;
381dda4fb85SAurabindo Pillai if (*MacroTileHeightC == 0)
382dda4fb85SAurabindo Pillai *MacroTileWidthC = 0;
383dda4fb85SAurabindo Pillai else
384dda4fb85SAurabindo Pillai *MacroTileWidthC = 65536 * 4 / *BytePerPixelC / *MacroTileHeightC;
385dda4fb85SAurabindo Pillai }
386dda4fb85SAurabindo Pillai
387dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
388dda4fb85SAurabindo Pillai dml_print("DML::%s: MacroTileWidthY = %d\n", __func__, *MacroTileWidthY);
389dda4fb85SAurabindo Pillai dml_print("DML::%s: MacroTileHeightY = %d\n", __func__, *MacroTileHeightY);
390dda4fb85SAurabindo Pillai dml_print("DML::%s: MacroTileWidthC = %d\n", __func__, *MacroTileWidthC);
391dda4fb85SAurabindo Pillai dml_print("DML::%s: MacroTileHeightC = %d\n", __func__, *MacroTileHeightC);
392dda4fb85SAurabindo Pillai #endif
393dda4fb85SAurabindo Pillai } // CalculateBytePerPixelAndBlockSizes
394dda4fb85SAurabindo Pillai
dml32_CalculateSwathAndDETConfiguration(unsigned int DETSizeOverride[],enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange[],unsigned int ConfigReturnBufferSizeInKByte,unsigned int MaxTotalDETInKByte,unsigned int MinCompressedBufferSizeInKByte,double ForceSingleDPP,unsigned int NumberOfActiveSurfaces,unsigned int nomDETInKByte,enum unbounded_requesting_policy UseUnboundedRequestingFinal,bool DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment,unsigned int PixelChunkSizeKBytes,unsigned int ROBSizeKBytes,unsigned int CompressedBufferSegmentSizeInkByteFinal,enum output_encoder_class Output[],double ReadBandwidthLuma[],double ReadBandwidthChroma[],double MaximumSwathWidthLuma[],double MaximumSwathWidthChroma[],enum dm_rotation_angle SourceRotation[],bool ViewportStationary[],enum source_format_class SourcePixelFormat[],enum dm_swizzle_mode SurfaceTiling[],unsigned int ViewportWidth[],unsigned int ViewportHeight[],unsigned int ViewportXStart[],unsigned int ViewportYStart[],unsigned int ViewportXStartC[],unsigned int ViewportYStartC[],unsigned int SurfaceWidthY[],unsigned int SurfaceWidthC[],unsigned int SurfaceHeightY[],unsigned int SurfaceHeightC[],unsigned int Read256BytesBlockHeightY[],unsigned int Read256BytesBlockHeightC[],unsigned int Read256BytesBlockWidthY[],unsigned int Read256BytesBlockWidthC[],enum odm_combine_mode ODMMode[],unsigned int BlendingAndTiming[],unsigned int BytePerPixY[],unsigned int BytePerPixC[],double BytePerPixDETY[],double BytePerPixDETC[],unsigned int HActive[],double HRatio[],double HRatioChroma[],unsigned int DPPPerSurface[],unsigned int swath_width_luma_ub[],unsigned int swath_width_chroma_ub[],double SwathWidth[],double SwathWidthChroma[],unsigned int SwathHeightY[],unsigned int SwathHeightC[],unsigned int DETBufferSizeInKByte[],unsigned int DETBufferSizeY[],unsigned int DETBufferSizeC[],bool * UnboundedRequestEnabled,unsigned int * CompressedBufferSizeInkByte,unsigned int * CompBufReservedSpaceKBytes,bool * CompBufReservedSpaceNeedAdjustment,bool ViewportSizeSupportPerSurface[],bool * ViewportSizeSupport)395dda4fb85SAurabindo Pillai void dml32_CalculateSwathAndDETConfiguration(
396dda4fb85SAurabindo Pillai unsigned int DETSizeOverride[],
397dda4fb85SAurabindo Pillai enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange[],
398dda4fb85SAurabindo Pillai unsigned int ConfigReturnBufferSizeInKByte,
399dda4fb85SAurabindo Pillai unsigned int MaxTotalDETInKByte,
400dda4fb85SAurabindo Pillai unsigned int MinCompressedBufferSizeInKByte,
401dda4fb85SAurabindo Pillai double ForceSingleDPP,
402dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces,
403dda4fb85SAurabindo Pillai unsigned int nomDETInKByte,
404dda4fb85SAurabindo Pillai enum unbounded_requesting_policy UseUnboundedRequestingFinal,
405f4b4e41aSJun Lei bool DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment,
406f4b4e41aSJun Lei unsigned int PixelChunkSizeKBytes,
407f4b4e41aSJun Lei unsigned int ROBSizeKBytes,
408dda4fb85SAurabindo Pillai unsigned int CompressedBufferSegmentSizeInkByteFinal,
409dda4fb85SAurabindo Pillai enum output_encoder_class Output[],
410dda4fb85SAurabindo Pillai double ReadBandwidthLuma[],
411dda4fb85SAurabindo Pillai double ReadBandwidthChroma[],
412dda4fb85SAurabindo Pillai double MaximumSwathWidthLuma[],
413dda4fb85SAurabindo Pillai double MaximumSwathWidthChroma[],
414dda4fb85SAurabindo Pillai enum dm_rotation_angle SourceRotation[],
415dda4fb85SAurabindo Pillai bool ViewportStationary[],
416dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat[],
417dda4fb85SAurabindo Pillai enum dm_swizzle_mode SurfaceTiling[],
418dda4fb85SAurabindo Pillai unsigned int ViewportWidth[],
419dda4fb85SAurabindo Pillai unsigned int ViewportHeight[],
420dda4fb85SAurabindo Pillai unsigned int ViewportXStart[],
421dda4fb85SAurabindo Pillai unsigned int ViewportYStart[],
422dda4fb85SAurabindo Pillai unsigned int ViewportXStartC[],
423dda4fb85SAurabindo Pillai unsigned int ViewportYStartC[],
424dda4fb85SAurabindo Pillai unsigned int SurfaceWidthY[],
425dda4fb85SAurabindo Pillai unsigned int SurfaceWidthC[],
426dda4fb85SAurabindo Pillai unsigned int SurfaceHeightY[],
427dda4fb85SAurabindo Pillai unsigned int SurfaceHeightC[],
428dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockHeightY[],
429dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockHeightC[],
430dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockWidthY[],
431dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockWidthC[],
432dda4fb85SAurabindo Pillai enum odm_combine_mode ODMMode[],
433dda4fb85SAurabindo Pillai unsigned int BlendingAndTiming[],
434dda4fb85SAurabindo Pillai unsigned int BytePerPixY[],
435dda4fb85SAurabindo Pillai unsigned int BytePerPixC[],
436dda4fb85SAurabindo Pillai double BytePerPixDETY[],
437dda4fb85SAurabindo Pillai double BytePerPixDETC[],
438dda4fb85SAurabindo Pillai unsigned int HActive[],
439dda4fb85SAurabindo Pillai double HRatio[],
440dda4fb85SAurabindo Pillai double HRatioChroma[],
441dda4fb85SAurabindo Pillai unsigned int DPPPerSurface[],
442dda4fb85SAurabindo Pillai
443dda4fb85SAurabindo Pillai /* Output */
444dda4fb85SAurabindo Pillai unsigned int swath_width_luma_ub[],
445dda4fb85SAurabindo Pillai unsigned int swath_width_chroma_ub[],
446dda4fb85SAurabindo Pillai double SwathWidth[],
447dda4fb85SAurabindo Pillai double SwathWidthChroma[],
448dda4fb85SAurabindo Pillai unsigned int SwathHeightY[],
449dda4fb85SAurabindo Pillai unsigned int SwathHeightC[],
450dda4fb85SAurabindo Pillai unsigned int DETBufferSizeInKByte[],
451dda4fb85SAurabindo Pillai unsigned int DETBufferSizeY[],
452dda4fb85SAurabindo Pillai unsigned int DETBufferSizeC[],
453dda4fb85SAurabindo Pillai bool *UnboundedRequestEnabled,
454dda4fb85SAurabindo Pillai unsigned int *CompressedBufferSizeInkByte,
455f4b4e41aSJun Lei unsigned int *CompBufReservedSpaceKBytes,
456f4b4e41aSJun Lei bool *CompBufReservedSpaceNeedAdjustment,
457dda4fb85SAurabindo Pillai bool ViewportSizeSupportPerSurface[],
458dda4fb85SAurabindo Pillai bool *ViewportSizeSupport)
459dda4fb85SAurabindo Pillai {
4605822b8acSRodrigo Siqueira unsigned int MaximumSwathHeightY[DC__NUM_DPP__MAX];
4615822b8acSRodrigo Siqueira unsigned int MaximumSwathHeightC[DC__NUM_DPP__MAX];
4625822b8acSRodrigo Siqueira unsigned int RoundedUpMaxSwathSizeBytesY[DC__NUM_DPP__MAX];
4635822b8acSRodrigo Siqueira unsigned int RoundedUpMaxSwathSizeBytesC[DC__NUM_DPP__MAX];
4645822b8acSRodrigo Siqueira unsigned int RoundedUpSwathSizeBytesY;
4655822b8acSRodrigo Siqueira unsigned int RoundedUpSwathSizeBytesC;
4665822b8acSRodrigo Siqueira double SwathWidthdoubleDPP[DC__NUM_DPP__MAX];
4675822b8acSRodrigo Siqueira double SwathWidthdoubleDPPChroma[DC__NUM_DPP__MAX];
468dda4fb85SAurabindo Pillai unsigned int k;
4695822b8acSRodrigo Siqueira unsigned int TotalActiveDPP = 0;
4705822b8acSRodrigo Siqueira bool NoChromaSurfaces = true;
4715822b8acSRodrigo Siqueira unsigned int DETBufferSizeInKByteForSwathCalculation;
472dda4fb85SAurabindo Pillai
473dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
474dda4fb85SAurabindo Pillai dml_print("DML::%s: ForceSingleDPP = %d\n", __func__, ForceSingleDPP);
475f4b4e41aSJun Lei dml_print("DML::%s: ROBSizeKBytes = %d\n", __func__, ROBSizeKBytes);
476f4b4e41aSJun Lei dml_print("DML::%s: PixelChunkSizeKBytes = %d\n", __func__, PixelChunkSizeKBytes);
477dda4fb85SAurabindo Pillai #endif
478dda4fb85SAurabindo Pillai dml32_CalculateSwathWidth(ForceSingleDPP,
479dda4fb85SAurabindo Pillai NumberOfActiveSurfaces,
480dda4fb85SAurabindo Pillai SourcePixelFormat,
481dda4fb85SAurabindo Pillai SourceRotation,
482dda4fb85SAurabindo Pillai ViewportStationary,
483dda4fb85SAurabindo Pillai ViewportWidth,
484dda4fb85SAurabindo Pillai ViewportHeight,
485dda4fb85SAurabindo Pillai ViewportXStart,
486dda4fb85SAurabindo Pillai ViewportYStart,
487dda4fb85SAurabindo Pillai ViewportXStartC,
488dda4fb85SAurabindo Pillai ViewportYStartC,
489dda4fb85SAurabindo Pillai SurfaceWidthY,
490dda4fb85SAurabindo Pillai SurfaceWidthC,
491dda4fb85SAurabindo Pillai SurfaceHeightY,
492dda4fb85SAurabindo Pillai SurfaceHeightC,
493dda4fb85SAurabindo Pillai ODMMode,
494dda4fb85SAurabindo Pillai BytePerPixY,
495dda4fb85SAurabindo Pillai BytePerPixC,
496dda4fb85SAurabindo Pillai Read256BytesBlockHeightY,
497dda4fb85SAurabindo Pillai Read256BytesBlockHeightC,
498dda4fb85SAurabindo Pillai Read256BytesBlockWidthY,
499dda4fb85SAurabindo Pillai Read256BytesBlockWidthC,
500dda4fb85SAurabindo Pillai BlendingAndTiming,
501dda4fb85SAurabindo Pillai HActive,
502dda4fb85SAurabindo Pillai HRatio,
503dda4fb85SAurabindo Pillai DPPPerSurface,
504dda4fb85SAurabindo Pillai
505dda4fb85SAurabindo Pillai /* Output */
5065822b8acSRodrigo Siqueira SwathWidthdoubleDPP,
5075822b8acSRodrigo Siqueira SwathWidthdoubleDPPChroma,
508dda4fb85SAurabindo Pillai SwathWidth,
509dda4fb85SAurabindo Pillai SwathWidthChroma,
5105822b8acSRodrigo Siqueira MaximumSwathHeightY,
5115822b8acSRodrigo Siqueira MaximumSwathHeightC,
512dda4fb85SAurabindo Pillai swath_width_luma_ub,
513dda4fb85SAurabindo Pillai swath_width_chroma_ub);
514dda4fb85SAurabindo Pillai
515dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
5165822b8acSRodrigo Siqueira RoundedUpMaxSwathSizeBytesY[k] = swath_width_luma_ub[k] * BytePerPixDETY[k] * MaximumSwathHeightY[k];
5175822b8acSRodrigo Siqueira RoundedUpMaxSwathSizeBytesC[k] = swath_width_chroma_ub[k] * BytePerPixDETC[k] * MaximumSwathHeightC[k];
518dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
519dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d DPPPerSurface = %d\n", __func__, k, DPPPerSurface[k]);
520dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d swath_width_luma_ub = %d\n", __func__, k, swath_width_luma_ub[k]);
521dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d BytePerPixDETY = %f\n", __func__, k, BytePerPixDETY[k]);
5225822b8acSRodrigo Siqueira dml_print("DML::%s: k=%0d MaximumSwathHeightY = %d\n", __func__, k, MaximumSwathHeightY[k]);
523dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d RoundedUpMaxSwathSizeBytesY = %d\n", __func__, k,
5245822b8acSRodrigo Siqueira RoundedUpMaxSwathSizeBytesY[k]);
525dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d swath_width_chroma_ub = %d\n", __func__, k, swath_width_chroma_ub[k]);
526dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d BytePerPixDETC = %f\n", __func__, k, BytePerPixDETC[k]);
5275822b8acSRodrigo Siqueira dml_print("DML::%s: k=%0d MaximumSwathHeightC = %d\n", __func__, k, MaximumSwathHeightC[k]);
528dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d RoundedUpMaxSwathSizeBytesC = %d\n", __func__, k,
5295822b8acSRodrigo Siqueira RoundedUpMaxSwathSizeBytesC[k]);
530dda4fb85SAurabindo Pillai #endif
531dda4fb85SAurabindo Pillai
532dda4fb85SAurabindo Pillai if (SourcePixelFormat[k] == dm_420_10) {
5335822b8acSRodrigo Siqueira RoundedUpMaxSwathSizeBytesY[k] = dml_ceil((unsigned int) RoundedUpMaxSwathSizeBytesY[k], 256);
5345822b8acSRodrigo Siqueira RoundedUpMaxSwathSizeBytesC[k] = dml_ceil((unsigned int) RoundedUpMaxSwathSizeBytesC[k], 256);
535dda4fb85SAurabindo Pillai }
536dda4fb85SAurabindo Pillai }
537dda4fb85SAurabindo Pillai
538dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
5395822b8acSRodrigo Siqueira TotalActiveDPP = TotalActiveDPP + (ForceSingleDPP ? 1 : DPPPerSurface[k]);
540dda4fb85SAurabindo Pillai if (SourcePixelFormat[k] == dm_420_8 || SourcePixelFormat[k] == dm_420_10 ||
541dda4fb85SAurabindo Pillai SourcePixelFormat[k] == dm_420_12 || SourcePixelFormat[k] == dm_rgbe_alpha) {
5425822b8acSRodrigo Siqueira NoChromaSurfaces = false;
543dda4fb85SAurabindo Pillai }
544dda4fb85SAurabindo Pillai }
545dda4fb85SAurabindo Pillai
546f4b4e41aSJun Lei // By default, just set the reserved space to 2 pixel chunks size
547f4b4e41aSJun Lei *CompBufReservedSpaceKBytes = PixelChunkSizeKBytes * 2;
548f4b4e41aSJun Lei
549f4b4e41aSJun Lei // if unbounded req is enabled, program reserved space such that the ROB will not hold more than 8 swaths worth of data
550f4b4e41aSJun Lei // - assume worst-case compression rate of 4. [ROB size - 8 * swath_size / max_compression ratio]
551f4b4e41aSJun Lei // - assume for "narrow" vp case in which the ROB can fit 8 swaths, the DET should be big enough to do full size req
5525822b8acSRodrigo Siqueira *CompBufReservedSpaceNeedAdjustment = ((int) ROBSizeKBytes - (int) *CompBufReservedSpaceKBytes) > (int) (RoundedUpMaxSwathSizeBytesY[0]/512);
553f4b4e41aSJun Lei
554f4b4e41aSJun Lei if (*CompBufReservedSpaceNeedAdjustment == 1) {
5555822b8acSRodrigo Siqueira *CompBufReservedSpaceKBytes = ROBSizeKBytes - RoundedUpMaxSwathSizeBytesY[0]/512;
556f4b4e41aSJun Lei }
557f4b4e41aSJun Lei
558f4b4e41aSJun Lei #ifdef __DML_VBA_DEBUG__
559f4b4e41aSJun Lei dml_print("DML::%s: CompBufReservedSpaceKBytes = %d\n", __func__, *CompBufReservedSpaceKBytes);
560f4b4e41aSJun Lei dml_print("DML::%s: CompBufReservedSpaceNeedAdjustment = %d\n", __func__, *CompBufReservedSpaceNeedAdjustment);
561f4b4e41aSJun Lei #endif
562f4b4e41aSJun Lei
5635822b8acSRodrigo Siqueira *UnboundedRequestEnabled = dml32_UnboundedRequest(UseUnboundedRequestingFinal, TotalActiveDPP, NoChromaSurfaces, Output[0], SurfaceTiling[0], *CompBufReservedSpaceNeedAdjustment, DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment);
564dda4fb85SAurabindo Pillai
565dda4fb85SAurabindo Pillai dml32_CalculateDETBufferSize(DETSizeOverride,
566dda4fb85SAurabindo Pillai UseMALLForPStateChange,
567dda4fb85SAurabindo Pillai ForceSingleDPP,
568dda4fb85SAurabindo Pillai NumberOfActiveSurfaces,
569dda4fb85SAurabindo Pillai *UnboundedRequestEnabled,
570dda4fb85SAurabindo Pillai nomDETInKByte,
571dda4fb85SAurabindo Pillai MaxTotalDETInKByte,
572dda4fb85SAurabindo Pillai ConfigReturnBufferSizeInKByte,
573dda4fb85SAurabindo Pillai MinCompressedBufferSizeInKByte,
574dda4fb85SAurabindo Pillai CompressedBufferSegmentSizeInkByteFinal,
575dda4fb85SAurabindo Pillai SourcePixelFormat,
576dda4fb85SAurabindo Pillai ReadBandwidthLuma,
577dda4fb85SAurabindo Pillai ReadBandwidthChroma,
5785822b8acSRodrigo Siqueira RoundedUpMaxSwathSizeBytesY,
5795822b8acSRodrigo Siqueira RoundedUpMaxSwathSizeBytesC,
580dda4fb85SAurabindo Pillai DPPPerSurface,
581dda4fb85SAurabindo Pillai
582dda4fb85SAurabindo Pillai /* Output */
583dda4fb85SAurabindo Pillai DETBufferSizeInKByte, // per hubp pipe
584dda4fb85SAurabindo Pillai CompressedBufferSizeInkByte);
585dda4fb85SAurabindo Pillai
586dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5875822b8acSRodrigo Siqueira dml_print("DML::%s: TotalActiveDPP = %d\n", __func__, TotalActiveDPP);
588dda4fb85SAurabindo Pillai dml_print("DML::%s: nomDETInKByte = %d\n", __func__, nomDETInKByte);
589dda4fb85SAurabindo Pillai dml_print("DML::%s: ConfigReturnBufferSizeInKByte = %d\n", __func__, ConfigReturnBufferSizeInKByte);
590dda4fb85SAurabindo Pillai dml_print("DML::%s: UseUnboundedRequestingFinal = %d\n", __func__, UseUnboundedRequestingFinal);
591dda4fb85SAurabindo Pillai dml_print("DML::%s: UnboundedRequestEnabled = %d\n", __func__, *UnboundedRequestEnabled);
592dda4fb85SAurabindo Pillai dml_print("DML::%s: CompressedBufferSizeInkByte = %d\n", __func__, *CompressedBufferSizeInkByte);
593dda4fb85SAurabindo Pillai #endif
594dda4fb85SAurabindo Pillai
595dda4fb85SAurabindo Pillai *ViewportSizeSupport = true;
596dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
597dda4fb85SAurabindo Pillai
5985822b8acSRodrigo Siqueira DETBufferSizeInKByteForSwathCalculation = (UseMALLForPStateChange[k] ==
599dda4fb85SAurabindo Pillai dm_use_mall_pstate_change_phantom_pipe ? 1024 : DETBufferSizeInKByte[k]);
600dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
601dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d DETBufferSizeInKByteForSwathCalculation = %d\n", __func__, k,
6025822b8acSRodrigo Siqueira DETBufferSizeInKByteForSwathCalculation);
603dda4fb85SAurabindo Pillai #endif
604dda4fb85SAurabindo Pillai
6055822b8acSRodrigo Siqueira if (RoundedUpMaxSwathSizeBytesY[k] + RoundedUpMaxSwathSizeBytesC[k] <=
6065822b8acSRodrigo Siqueira DETBufferSizeInKByteForSwathCalculation * 1024 / 2) {
6075822b8acSRodrigo Siqueira SwathHeightY[k] = MaximumSwathHeightY[k];
6085822b8acSRodrigo Siqueira SwathHeightC[k] = MaximumSwathHeightC[k];
6095822b8acSRodrigo Siqueira RoundedUpSwathSizeBytesY = RoundedUpMaxSwathSizeBytesY[k];
6105822b8acSRodrigo Siqueira RoundedUpSwathSizeBytesC = RoundedUpMaxSwathSizeBytesC[k];
6115822b8acSRodrigo Siqueira } else if (RoundedUpMaxSwathSizeBytesY[k] >= 1.5 * RoundedUpMaxSwathSizeBytesC[k] &&
6125822b8acSRodrigo Siqueira RoundedUpMaxSwathSizeBytesY[k] / 2 + RoundedUpMaxSwathSizeBytesC[k] <=
6135822b8acSRodrigo Siqueira DETBufferSizeInKByteForSwathCalculation * 1024 / 2) {
6145822b8acSRodrigo Siqueira SwathHeightY[k] = MaximumSwathHeightY[k] / 2;
6155822b8acSRodrigo Siqueira SwathHeightC[k] = MaximumSwathHeightC[k];
6165822b8acSRodrigo Siqueira RoundedUpSwathSizeBytesY = RoundedUpMaxSwathSizeBytesY[k] / 2;
6175822b8acSRodrigo Siqueira RoundedUpSwathSizeBytesC = RoundedUpMaxSwathSizeBytesC[k];
6185822b8acSRodrigo Siqueira } else if (RoundedUpMaxSwathSizeBytesY[k] < 1.5 * RoundedUpMaxSwathSizeBytesC[k] &&
6195822b8acSRodrigo Siqueira RoundedUpMaxSwathSizeBytesY[k] + RoundedUpMaxSwathSizeBytesC[k] / 2 <=
6205822b8acSRodrigo Siqueira DETBufferSizeInKByteForSwathCalculation * 1024 / 2) {
6215822b8acSRodrigo Siqueira SwathHeightY[k] = MaximumSwathHeightY[k];
6225822b8acSRodrigo Siqueira SwathHeightC[k] = MaximumSwathHeightC[k] / 2;
6235822b8acSRodrigo Siqueira RoundedUpSwathSizeBytesY = RoundedUpMaxSwathSizeBytesY[k];
6245822b8acSRodrigo Siqueira RoundedUpSwathSizeBytesC = RoundedUpMaxSwathSizeBytesC[k] / 2;
625dda4fb85SAurabindo Pillai } else {
6265822b8acSRodrigo Siqueira SwathHeightY[k] = MaximumSwathHeightY[k] / 2;
6275822b8acSRodrigo Siqueira SwathHeightC[k] = MaximumSwathHeightC[k] / 2;
6285822b8acSRodrigo Siqueira RoundedUpSwathSizeBytesY = RoundedUpMaxSwathSizeBytesY[k] / 2;
6295822b8acSRodrigo Siqueira RoundedUpSwathSizeBytesC = RoundedUpMaxSwathSizeBytesC[k] / 2;
630dda4fb85SAurabindo Pillai }
631dda4fb85SAurabindo Pillai
6325822b8acSRodrigo Siqueira if ((RoundedUpMaxSwathSizeBytesY[k] / 2 + RoundedUpMaxSwathSizeBytesC[k] / 2 >
6335822b8acSRodrigo Siqueira DETBufferSizeInKByteForSwathCalculation * 1024 / 2)
634dda4fb85SAurabindo Pillai || SwathWidth[k] > MaximumSwathWidthLuma[k] || (SwathHeightC[k] > 0 &&
635dda4fb85SAurabindo Pillai SwathWidthChroma[k] > MaximumSwathWidthChroma[k])) {
636dda4fb85SAurabindo Pillai *ViewportSizeSupport = false;
637dda4fb85SAurabindo Pillai ViewportSizeSupportPerSurface[k] = false;
638dda4fb85SAurabindo Pillai } else {
639dda4fb85SAurabindo Pillai ViewportSizeSupportPerSurface[k] = true;
640dda4fb85SAurabindo Pillai }
641dda4fb85SAurabindo Pillai
642dda4fb85SAurabindo Pillai if (SwathHeightC[k] == 0) {
643dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
644dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d All DET for plane0\n", __func__, k);
645dda4fb85SAurabindo Pillai #endif
646dda4fb85SAurabindo Pillai DETBufferSizeY[k] = DETBufferSizeInKByte[k] * 1024;
647dda4fb85SAurabindo Pillai DETBufferSizeC[k] = 0;
6485822b8acSRodrigo Siqueira } else if (RoundedUpSwathSizeBytesY <= 1.5 * RoundedUpSwathSizeBytesC) {
649dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
650dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d Half DET for plane0, half for plane1\n", __func__, k);
651dda4fb85SAurabindo Pillai #endif
652dda4fb85SAurabindo Pillai DETBufferSizeY[k] = DETBufferSizeInKByte[k] * 1024 / 2;
653dda4fb85SAurabindo Pillai DETBufferSizeC[k] = DETBufferSizeInKByte[k] * 1024 / 2;
654dda4fb85SAurabindo Pillai } else {
655dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
656dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d 2/3 DET for plane0, 1/3 for plane1\n", __func__, k);
657dda4fb85SAurabindo Pillai #endif
658dda4fb85SAurabindo Pillai DETBufferSizeY[k] = dml_floor(DETBufferSizeInKByte[k] * 1024 * 2 / 3, 1024);
659dda4fb85SAurabindo Pillai DETBufferSizeC[k] = DETBufferSizeInKByte[k] * 1024 - DETBufferSizeY[k];
660dda4fb85SAurabindo Pillai }
661dda4fb85SAurabindo Pillai
662dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
663dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d SwathHeightY = %d\n", __func__, k, SwathHeightY[k]);
664dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d SwathHeightC = %d\n", __func__, k, SwathHeightC[k]);
665dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d RoundedUpMaxSwathSizeBytesY = %d\n", __func__,
6665822b8acSRodrigo Siqueira k, RoundedUpMaxSwathSizeBytesY[k]);
667dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d RoundedUpMaxSwathSizeBytesC = %d\n", __func__,
6685822b8acSRodrigo Siqueira k, RoundedUpMaxSwathSizeBytesC[k]);
6695822b8acSRodrigo Siqueira dml_print("DML::%s: k=%0d RoundedUpSwathSizeBytesY = %d\n", __func__, k, RoundedUpSwathSizeBytesY);
6705822b8acSRodrigo Siqueira dml_print("DML::%s: k=%0d RoundedUpSwathSizeBytesC = %d\n", __func__, k, RoundedUpSwathSizeBytesC);
671dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d DETBufferSizeInKByte = %d\n", __func__, k, DETBufferSizeInKByte[k]);
672dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d DETBufferSizeY = %d\n", __func__, k, DETBufferSizeY[k]);
673dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d DETBufferSizeC = %d\n", __func__, k, DETBufferSizeC[k]);
674dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d ViewportSizeSupportPerSurface = %d\n", __func__, k,
675dda4fb85SAurabindo Pillai ViewportSizeSupportPerSurface[k]);
676dda4fb85SAurabindo Pillai #endif
677dda4fb85SAurabindo Pillai
678dda4fb85SAurabindo Pillai }
679dda4fb85SAurabindo Pillai } // CalculateSwathAndDETConfiguration
680dda4fb85SAurabindo Pillai
dml32_CalculateSwathWidth(bool ForceSingleDPP,unsigned int NumberOfActiveSurfaces,enum source_format_class SourcePixelFormat[],enum dm_rotation_angle SourceRotation[],bool ViewportStationary[],unsigned int ViewportWidth[],unsigned int ViewportHeight[],unsigned int ViewportXStart[],unsigned int ViewportYStart[],unsigned int ViewportXStartC[],unsigned int ViewportYStartC[],unsigned int SurfaceWidthY[],unsigned int SurfaceWidthC[],unsigned int SurfaceHeightY[],unsigned int SurfaceHeightC[],enum odm_combine_mode ODMMode[],unsigned int BytePerPixY[],unsigned int BytePerPixC[],unsigned int Read256BytesBlockHeightY[],unsigned int Read256BytesBlockHeightC[],unsigned int Read256BytesBlockWidthY[],unsigned int Read256BytesBlockWidthC[],unsigned int BlendingAndTiming[],unsigned int HActive[],double HRatio[],unsigned int DPPPerSurface[],double SwathWidthdoubleDPPY[],double SwathWidthdoubleDPPC[],double SwathWidthY[],double SwathWidthC[],unsigned int MaximumSwathHeightY[],unsigned int MaximumSwathHeightC[],unsigned int swath_width_luma_ub[],unsigned int swath_width_chroma_ub[])681dda4fb85SAurabindo Pillai void dml32_CalculateSwathWidth(
682dda4fb85SAurabindo Pillai bool ForceSingleDPP,
683dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces,
684dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat[],
685dda4fb85SAurabindo Pillai enum dm_rotation_angle SourceRotation[],
686dda4fb85SAurabindo Pillai bool ViewportStationary[],
687dda4fb85SAurabindo Pillai unsigned int ViewportWidth[],
688dda4fb85SAurabindo Pillai unsigned int ViewportHeight[],
689dda4fb85SAurabindo Pillai unsigned int ViewportXStart[],
690dda4fb85SAurabindo Pillai unsigned int ViewportYStart[],
691dda4fb85SAurabindo Pillai unsigned int ViewportXStartC[],
692dda4fb85SAurabindo Pillai unsigned int ViewportYStartC[],
693dda4fb85SAurabindo Pillai unsigned int SurfaceWidthY[],
694dda4fb85SAurabindo Pillai unsigned int SurfaceWidthC[],
695dda4fb85SAurabindo Pillai unsigned int SurfaceHeightY[],
696dda4fb85SAurabindo Pillai unsigned int SurfaceHeightC[],
697dda4fb85SAurabindo Pillai enum odm_combine_mode ODMMode[],
698dda4fb85SAurabindo Pillai unsigned int BytePerPixY[],
699dda4fb85SAurabindo Pillai unsigned int BytePerPixC[],
700dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockHeightY[],
701dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockHeightC[],
702dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockWidthY[],
703dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockWidthC[],
704dda4fb85SAurabindo Pillai unsigned int BlendingAndTiming[],
705dda4fb85SAurabindo Pillai unsigned int HActive[],
706dda4fb85SAurabindo Pillai double HRatio[],
707dda4fb85SAurabindo Pillai unsigned int DPPPerSurface[],
708dda4fb85SAurabindo Pillai
709dda4fb85SAurabindo Pillai /* Output */
710dda4fb85SAurabindo Pillai double SwathWidthdoubleDPPY[],
711dda4fb85SAurabindo Pillai double SwathWidthdoubleDPPC[],
712dda4fb85SAurabindo Pillai double SwathWidthY[], // per-pipe
713dda4fb85SAurabindo Pillai double SwathWidthC[], // per-pipe
714dda4fb85SAurabindo Pillai unsigned int MaximumSwathHeightY[],
715dda4fb85SAurabindo Pillai unsigned int MaximumSwathHeightC[],
716dda4fb85SAurabindo Pillai unsigned int swath_width_luma_ub[], // per-pipe
717dda4fb85SAurabindo Pillai unsigned int swath_width_chroma_ub[]) // per-pipe
718dda4fb85SAurabindo Pillai {
719dda4fb85SAurabindo Pillai unsigned int k, j;
720dda4fb85SAurabindo Pillai enum odm_combine_mode MainSurfaceODMMode;
721dda4fb85SAurabindo Pillai
722dda4fb85SAurabindo Pillai unsigned int surface_width_ub_l;
723dda4fb85SAurabindo Pillai unsigned int surface_height_ub_l;
72417529ea2SAric Cyr unsigned int surface_width_ub_c = 0;
72517529ea2SAric Cyr unsigned int surface_height_ub_c = 0;
726dda4fb85SAurabindo Pillai
727dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
728dda4fb85SAurabindo Pillai dml_print("DML::%s: ForceSingleDPP = %d\n", __func__, ForceSingleDPP);
729dda4fb85SAurabindo Pillai dml_print("DML::%s: NumberOfActiveSurfaces = %d\n", __func__, NumberOfActiveSurfaces);
730dda4fb85SAurabindo Pillai #endif
731dda4fb85SAurabindo Pillai
732dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
733dda4fb85SAurabindo Pillai if (!IsVertical(SourceRotation[k]))
734dda4fb85SAurabindo Pillai SwathWidthdoubleDPPY[k] = ViewportWidth[k];
735dda4fb85SAurabindo Pillai else
736dda4fb85SAurabindo Pillai SwathWidthdoubleDPPY[k] = ViewportHeight[k];
737dda4fb85SAurabindo Pillai
738dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
739dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d ViewportWidth=%d\n", __func__, k, ViewportWidth[k]);
740dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d ViewportHeight=%d\n", __func__, k, ViewportHeight[k]);
741dda4fb85SAurabindo Pillai #endif
742dda4fb85SAurabindo Pillai
743dda4fb85SAurabindo Pillai MainSurfaceODMMode = ODMMode[k];
744dda4fb85SAurabindo Pillai for (j = 0; j < NumberOfActiveSurfaces; ++j) {
745dda4fb85SAurabindo Pillai if (BlendingAndTiming[k] == j)
746dda4fb85SAurabindo Pillai MainSurfaceODMMode = ODMMode[j];
747dda4fb85SAurabindo Pillai }
748dda4fb85SAurabindo Pillai
749dda4fb85SAurabindo Pillai if (ForceSingleDPP) {
750dda4fb85SAurabindo Pillai SwathWidthY[k] = SwathWidthdoubleDPPY[k];
751dda4fb85SAurabindo Pillai } else {
752dda4fb85SAurabindo Pillai if (MainSurfaceODMMode == dm_odm_combine_mode_4to1) {
753dda4fb85SAurabindo Pillai SwathWidthY[k] = dml_min(SwathWidthdoubleDPPY[k],
754dda4fb85SAurabindo Pillai dml_round(HActive[k] / 4.0 * HRatio[k]));
755dda4fb85SAurabindo Pillai } else if (MainSurfaceODMMode == dm_odm_combine_mode_2to1) {
756dda4fb85SAurabindo Pillai SwathWidthY[k] = dml_min(SwathWidthdoubleDPPY[k],
757dda4fb85SAurabindo Pillai dml_round(HActive[k] / 2.0 * HRatio[k]));
758dda4fb85SAurabindo Pillai } else if (DPPPerSurface[k] == 2) {
759dda4fb85SAurabindo Pillai SwathWidthY[k] = SwathWidthdoubleDPPY[k] / 2;
760dda4fb85SAurabindo Pillai } else {
761dda4fb85SAurabindo Pillai SwathWidthY[k] = SwathWidthdoubleDPPY[k];
762dda4fb85SAurabindo Pillai }
763dda4fb85SAurabindo Pillai }
764dda4fb85SAurabindo Pillai
765dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
766dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d HActive=%d\n", __func__, k, HActive[k]);
767dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d HRatio=%f\n", __func__, k, HRatio[k]);
768dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d MainSurfaceODMMode=%d\n", __func__, k, MainSurfaceODMMode);
769dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d SwathWidthdoubleDPPY=%d\n", __func__, k, SwathWidthdoubleDPPY[k]);
770dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d SwathWidthY=%d\n", __func__, k, SwathWidthY[k]);
771dda4fb85SAurabindo Pillai #endif
772dda4fb85SAurabindo Pillai
773dda4fb85SAurabindo Pillai if (SourcePixelFormat[k] == dm_420_8 || SourcePixelFormat[k] == dm_420_10 ||
774dda4fb85SAurabindo Pillai SourcePixelFormat[k] == dm_420_12) {
775dda4fb85SAurabindo Pillai SwathWidthC[k] = SwathWidthY[k] / 2;
776dda4fb85SAurabindo Pillai SwathWidthdoubleDPPC[k] = SwathWidthdoubleDPPY[k] / 2;
777dda4fb85SAurabindo Pillai } else {
778dda4fb85SAurabindo Pillai SwathWidthC[k] = SwathWidthY[k];
779dda4fb85SAurabindo Pillai SwathWidthdoubleDPPC[k] = SwathWidthdoubleDPPY[k];
780dda4fb85SAurabindo Pillai }
781dda4fb85SAurabindo Pillai
782dda4fb85SAurabindo Pillai if (ForceSingleDPP == true) {
783dda4fb85SAurabindo Pillai SwathWidthY[k] = SwathWidthdoubleDPPY[k];
784dda4fb85SAurabindo Pillai SwathWidthC[k] = SwathWidthdoubleDPPC[k];
785dda4fb85SAurabindo Pillai }
786dda4fb85SAurabindo Pillai
787dda4fb85SAurabindo Pillai surface_width_ub_l = dml_ceil(SurfaceWidthY[k], Read256BytesBlockWidthY[k]);
788dda4fb85SAurabindo Pillai surface_height_ub_l = dml_ceil(SurfaceHeightY[k], Read256BytesBlockHeightY[k]);
789dda4fb85SAurabindo Pillai
790dda4fb85SAurabindo Pillai if (!IsVertical(SourceRotation[k])) {
791dda4fb85SAurabindo Pillai MaximumSwathHeightY[k] = Read256BytesBlockHeightY[k];
792dda4fb85SAurabindo Pillai MaximumSwathHeightC[k] = Read256BytesBlockHeightC[k];
793dda4fb85SAurabindo Pillai if (ViewportStationary[k] && DPPPerSurface[k] == 1) {
794dda4fb85SAurabindo Pillai swath_width_luma_ub[k] = dml_min(surface_width_ub_l,
795dda4fb85SAurabindo Pillai dml_floor(ViewportXStart[k] +
796dda4fb85SAurabindo Pillai SwathWidthY[k] +
797dda4fb85SAurabindo Pillai Read256BytesBlockWidthY[k] - 1,
798dda4fb85SAurabindo Pillai Read256BytesBlockWidthY[k]) -
799dda4fb85SAurabindo Pillai dml_floor(ViewportXStart[k],
800dda4fb85SAurabindo Pillai Read256BytesBlockWidthY[k]));
801dda4fb85SAurabindo Pillai } else {
802dda4fb85SAurabindo Pillai swath_width_luma_ub[k] = dml_min(surface_width_ub_l,
803dda4fb85SAurabindo Pillai dml_ceil(SwathWidthY[k] - 1,
804dda4fb85SAurabindo Pillai Read256BytesBlockWidthY[k]) +
805dda4fb85SAurabindo Pillai Read256BytesBlockWidthY[k]);
806dda4fb85SAurabindo Pillai }
807dda4fb85SAurabindo Pillai if (BytePerPixC[k] > 0) {
80817529ea2SAric Cyr surface_width_ub_c = dml_ceil(SurfaceWidthC[k], Read256BytesBlockWidthC[k]);
809dda4fb85SAurabindo Pillai if (ViewportStationary[k] && DPPPerSurface[k] == 1) {
810dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] = dml_min(surface_width_ub_c,
811dda4fb85SAurabindo Pillai dml_floor(ViewportXStartC[k] + SwathWidthC[k] +
812dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k] - 1,
813dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k]) -
814dda4fb85SAurabindo Pillai dml_floor(ViewportXStartC[k],
815dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k]));
816dda4fb85SAurabindo Pillai } else {
817dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] = dml_min(surface_width_ub_c,
818dda4fb85SAurabindo Pillai dml_ceil(SwathWidthC[k] - 1,
819dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k]) +
820dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k]);
821dda4fb85SAurabindo Pillai }
822dda4fb85SAurabindo Pillai } else {
823dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] = 0;
824dda4fb85SAurabindo Pillai }
825dda4fb85SAurabindo Pillai } else {
826dda4fb85SAurabindo Pillai MaximumSwathHeightY[k] = Read256BytesBlockWidthY[k];
827dda4fb85SAurabindo Pillai MaximumSwathHeightC[k] = Read256BytesBlockWidthC[k];
828dda4fb85SAurabindo Pillai
829dda4fb85SAurabindo Pillai if (ViewportStationary[k] && DPPPerSurface[k] == 1) {
830dda4fb85SAurabindo Pillai swath_width_luma_ub[k] = dml_min(surface_height_ub_l, dml_floor(ViewportYStart[k] +
831dda4fb85SAurabindo Pillai SwathWidthY[k] + Read256BytesBlockHeightY[k] - 1,
832dda4fb85SAurabindo Pillai Read256BytesBlockHeightY[k]) -
833dda4fb85SAurabindo Pillai dml_floor(ViewportYStart[k], Read256BytesBlockHeightY[k]));
834dda4fb85SAurabindo Pillai } else {
835dda4fb85SAurabindo Pillai swath_width_luma_ub[k] = dml_min(surface_height_ub_l, dml_ceil(SwathWidthY[k] - 1,
836dda4fb85SAurabindo Pillai Read256BytesBlockHeightY[k]) + Read256BytesBlockHeightY[k]);
837dda4fb85SAurabindo Pillai }
838dda4fb85SAurabindo Pillai if (BytePerPixC[k] > 0) {
83917529ea2SAric Cyr surface_height_ub_c = dml_ceil(SurfaceHeightC[k], Read256BytesBlockHeightC[k]);
840dda4fb85SAurabindo Pillai if (ViewportStationary[k] && DPPPerSurface[k] == 1) {
841dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] = dml_min(surface_height_ub_c,
842dda4fb85SAurabindo Pillai dml_floor(ViewportYStartC[k] + SwathWidthC[k] +
843dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k] - 1,
844dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k]) -
845dda4fb85SAurabindo Pillai dml_floor(ViewportYStartC[k],
846dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k]));
847dda4fb85SAurabindo Pillai } else {
848dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] = dml_min(surface_height_ub_c,
849dda4fb85SAurabindo Pillai dml_ceil(SwathWidthC[k] - 1, Read256BytesBlockHeightC[k]) +
850dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k]);
851dda4fb85SAurabindo Pillai }
852dda4fb85SAurabindo Pillai } else {
853dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] = 0;
854dda4fb85SAurabindo Pillai }
855dda4fb85SAurabindo Pillai }
856dda4fb85SAurabindo Pillai
857dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
85817529ea2SAric Cyr dml_print("DML::%s: k=%d surface_width_ub_l=%0d\n", __func__, k, surface_width_ub_l);
85917529ea2SAric Cyr dml_print("DML::%s: k=%d surface_height_ub_l=%0d\n", __func__, k, surface_height_ub_l);
86017529ea2SAric Cyr dml_print("DML::%s: k=%d surface_width_ub_c=%0d\n", __func__, k, surface_width_ub_c);
86117529ea2SAric Cyr dml_print("DML::%s: k=%d surface_height_ub_c=%0d\n", __func__, k, surface_height_ub_c);
86217529ea2SAric Cyr dml_print("DML::%s: k=%d Read256BytesBlockWidthY=%0d\n", __func__, k, Read256BytesBlockWidthY[k]);
86317529ea2SAric Cyr dml_print("DML::%s: k=%d Read256BytesBlockHeightY=%0d\n", __func__, k, Read256BytesBlockHeightY[k]);
86417529ea2SAric Cyr dml_print("DML::%s: k=%d Read256BytesBlockWidthC=%0d\n", __func__, k, Read256BytesBlockWidthC[k]);
86517529ea2SAric Cyr dml_print("DML::%s: k=%d Read256BytesBlockHeightC=%0d\n", __func__, k, Read256BytesBlockHeightC[k]);
86617529ea2SAric Cyr dml_print("DML::%s: k=%d ViewportStationary=%0d\n", __func__, k, ViewportStationary[k]);
86717529ea2SAric Cyr dml_print("DML::%s: k=%d DPPPerSurface=%0d\n", __func__, k, DPPPerSurface[k]);
868dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d swath_width_luma_ub=%0d\n", __func__, k, swath_width_luma_ub[k]);
869dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d swath_width_chroma_ub=%0d\n", __func__, k, swath_width_chroma_ub[k]);
870dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d MaximumSwathHeightY=%0d\n", __func__, k, MaximumSwathHeightY[k]);
871dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d MaximumSwathHeightC=%0d\n", __func__, k, MaximumSwathHeightC[k]);
872dda4fb85SAurabindo Pillai #endif
873dda4fb85SAurabindo Pillai
874dda4fb85SAurabindo Pillai }
875dda4fb85SAurabindo Pillai } // CalculateSwathWidth
876dda4fb85SAurabindo Pillai
dml32_UnboundedRequest(enum unbounded_requesting_policy UseUnboundedRequestingFinal,unsigned int TotalNumberOfActiveDPP,bool NoChroma,enum output_encoder_class Output,enum dm_swizzle_mode SurfaceTiling,bool CompBufReservedSpaceNeedAdjustment,bool DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment)877dda4fb85SAurabindo Pillai bool dml32_UnboundedRequest(enum unbounded_requesting_policy UseUnboundedRequestingFinal,
878dda4fb85SAurabindo Pillai unsigned int TotalNumberOfActiveDPP,
879dda4fb85SAurabindo Pillai bool NoChroma,
880f4b4e41aSJun Lei enum output_encoder_class Output,
881f4b4e41aSJun Lei enum dm_swizzle_mode SurfaceTiling,
882f4b4e41aSJun Lei bool CompBufReservedSpaceNeedAdjustment,
883f4b4e41aSJun Lei bool DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment)
884dda4fb85SAurabindo Pillai {
885dda4fb85SAurabindo Pillai bool ret_val = false;
886dda4fb85SAurabindo Pillai
887dda4fb85SAurabindo Pillai ret_val = (UseUnboundedRequestingFinal != dm_unbounded_requesting_disable &&
888dda4fb85SAurabindo Pillai TotalNumberOfActiveDPP == 1 && NoChroma);
889dda4fb85SAurabindo Pillai if (UseUnboundedRequestingFinal == dm_unbounded_requesting_edp_only && Output != dm_edp)
890dda4fb85SAurabindo Pillai ret_val = false;
891f4b4e41aSJun Lei
892f4b4e41aSJun Lei if (SurfaceTiling == dm_sw_linear)
893f4b4e41aSJun Lei ret_val = false;
894f4b4e41aSJun Lei
895f4b4e41aSJun Lei if (CompBufReservedSpaceNeedAdjustment == 1 && DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment)
896f4b4e41aSJun Lei ret_val = false;
897f4b4e41aSJun Lei
898f4b4e41aSJun Lei #ifdef __DML_VBA_DEBUG__
899f4b4e41aSJun Lei dml_print("DML::%s: CompBufReservedSpaceNeedAdjustment = %d\n", __func__, CompBufReservedSpaceNeedAdjustment);
900f4b4e41aSJun Lei dml_print("DML::%s: DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment = %d\n", __func__, DisableUnboundRequestIfCompBufReservedSpaceNeedAdjustment);
901f4b4e41aSJun Lei dml_print("DML::%s: ret_val = %d\n", __func__, ret_val);
902f4b4e41aSJun Lei #endif
903f4b4e41aSJun Lei
904f4b4e41aSJun Lei return (ret_val);
905dda4fb85SAurabindo Pillai }
906dda4fb85SAurabindo Pillai
dml32_CalculateDETBufferSize(unsigned int DETSizeOverride[],enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange[],bool ForceSingleDPP,unsigned int NumberOfActiveSurfaces,bool UnboundedRequestEnabled,unsigned int nomDETInKByte,unsigned int MaxTotalDETInKByte,unsigned int ConfigReturnBufferSizeInKByte,unsigned int MinCompressedBufferSizeInKByte,unsigned int CompressedBufferSegmentSizeInkByteFinal,enum source_format_class SourcePixelFormat[],double ReadBandwidthLuma[],double ReadBandwidthChroma[],unsigned int RoundedUpMaxSwathSizeBytesY[],unsigned int RoundedUpMaxSwathSizeBytesC[],unsigned int DPPPerSurface[],unsigned int DETBufferSizeInKByte[],unsigned int * CompressedBufferSizeInkByte)907dda4fb85SAurabindo Pillai void dml32_CalculateDETBufferSize(
908dda4fb85SAurabindo Pillai unsigned int DETSizeOverride[],
909dda4fb85SAurabindo Pillai enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange[],
910dda4fb85SAurabindo Pillai bool ForceSingleDPP,
911dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces,
912dda4fb85SAurabindo Pillai bool UnboundedRequestEnabled,
913dda4fb85SAurabindo Pillai unsigned int nomDETInKByte,
914dda4fb85SAurabindo Pillai unsigned int MaxTotalDETInKByte,
915dda4fb85SAurabindo Pillai unsigned int ConfigReturnBufferSizeInKByte,
916dda4fb85SAurabindo Pillai unsigned int MinCompressedBufferSizeInKByte,
917dda4fb85SAurabindo Pillai unsigned int CompressedBufferSegmentSizeInkByteFinal,
918dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat[],
919dda4fb85SAurabindo Pillai double ReadBandwidthLuma[],
920dda4fb85SAurabindo Pillai double ReadBandwidthChroma[],
921dda4fb85SAurabindo Pillai unsigned int RoundedUpMaxSwathSizeBytesY[],
922dda4fb85SAurabindo Pillai unsigned int RoundedUpMaxSwathSizeBytesC[],
923dda4fb85SAurabindo Pillai unsigned int DPPPerSurface[],
924dda4fb85SAurabindo Pillai /* Output */
925dda4fb85SAurabindo Pillai unsigned int DETBufferSizeInKByte[],
926dda4fb85SAurabindo Pillai unsigned int *CompressedBufferSizeInkByte)
927dda4fb85SAurabindo Pillai {
928dda4fb85SAurabindo Pillai unsigned int DETBufferSizePoolInKByte;
929dda4fb85SAurabindo Pillai unsigned int NextDETBufferPieceInKByte;
930dda4fb85SAurabindo Pillai bool DETPieceAssignedToThisSurfaceAlready[DC__NUM_DPP__MAX];
931dda4fb85SAurabindo Pillai bool NextPotentialSurfaceToAssignDETPieceFound;
932dda4fb85SAurabindo Pillai unsigned int NextSurfaceToAssignDETPiece;
933dda4fb85SAurabindo Pillai double TotalBandwidth;
934dda4fb85SAurabindo Pillai double BandwidthOfSurfacesNotAssignedDETPiece;
935dda4fb85SAurabindo Pillai unsigned int max_minDET;
936dda4fb85SAurabindo Pillai unsigned int minDET;
937dda4fb85SAurabindo Pillai unsigned int minDET_pipe;
938dda4fb85SAurabindo Pillai unsigned int j, k;
939dda4fb85SAurabindo Pillai
940dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
941dda4fb85SAurabindo Pillai dml_print("DML::%s: ForceSingleDPP = %d\n", __func__, ForceSingleDPP);
942dda4fb85SAurabindo Pillai dml_print("DML::%s: nomDETInKByte = %d\n", __func__, nomDETInKByte);
943dda4fb85SAurabindo Pillai dml_print("DML::%s: NumberOfActiveSurfaces = %d\n", __func__, NumberOfActiveSurfaces);
944dda4fb85SAurabindo Pillai dml_print("DML::%s: UnboundedRequestEnabled = %d\n", __func__, UnboundedRequestEnabled);
945dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxTotalDETInKByte = %d\n", __func__, MaxTotalDETInKByte);
946dda4fb85SAurabindo Pillai dml_print("DML::%s: ConfigReturnBufferSizeInKByte = %d\n", __func__, ConfigReturnBufferSizeInKByte);
947dda4fb85SAurabindo Pillai dml_print("DML::%s: MinCompressedBufferSizeInKByte = %d\n", __func__, MinCompressedBufferSizeInKByte);
948dda4fb85SAurabindo Pillai dml_print("DML::%s: CompressedBufferSegmentSizeInkByteFinal = %d\n", __func__,
949dda4fb85SAurabindo Pillai CompressedBufferSegmentSizeInkByteFinal);
950dda4fb85SAurabindo Pillai #endif
951dda4fb85SAurabindo Pillai
952dda4fb85SAurabindo Pillai // Note: Will use default det size if that fits 2 swaths
953dda4fb85SAurabindo Pillai if (UnboundedRequestEnabled) {
954dda4fb85SAurabindo Pillai if (DETSizeOverride[0] > 0) {
955dda4fb85SAurabindo Pillai DETBufferSizeInKByte[0] = DETSizeOverride[0];
956dda4fb85SAurabindo Pillai } else {
957dda4fb85SAurabindo Pillai DETBufferSizeInKByte[0] = dml_max(nomDETInKByte, dml_ceil(2.0 *
958dda4fb85SAurabindo Pillai ((double) RoundedUpMaxSwathSizeBytesY[0] +
959dda4fb85SAurabindo Pillai (double) RoundedUpMaxSwathSizeBytesC[0]) / 1024.0, 64.0));
960dda4fb85SAurabindo Pillai }
961dda4fb85SAurabindo Pillai *CompressedBufferSizeInkByte = ConfigReturnBufferSizeInKByte - DETBufferSizeInKByte[0];
962dda4fb85SAurabindo Pillai } else {
963dda4fb85SAurabindo Pillai DETBufferSizePoolInKByte = MaxTotalDETInKByte;
964dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
965dda4fb85SAurabindo Pillai DETBufferSizeInKByte[k] = nomDETInKByte;
966dda4fb85SAurabindo Pillai if (SourcePixelFormat[k] == dm_420_8 || SourcePixelFormat[k] == dm_420_10 ||
967dda4fb85SAurabindo Pillai SourcePixelFormat[k] == dm_420_12) {
968dda4fb85SAurabindo Pillai max_minDET = nomDETInKByte - 64;
969dda4fb85SAurabindo Pillai } else {
970dda4fb85SAurabindo Pillai max_minDET = nomDETInKByte;
971dda4fb85SAurabindo Pillai }
972dda4fb85SAurabindo Pillai minDET = 128;
973dda4fb85SAurabindo Pillai minDET_pipe = 0;
974dda4fb85SAurabindo Pillai
975dda4fb85SAurabindo Pillai // add DET resource until can hold 2 full swaths
976dda4fb85SAurabindo Pillai while (minDET <= max_minDET && minDET_pipe == 0) {
977dda4fb85SAurabindo Pillai if (2.0 * ((double) RoundedUpMaxSwathSizeBytesY[k] +
978dda4fb85SAurabindo Pillai (double) RoundedUpMaxSwathSizeBytesC[k]) / 1024.0 <= minDET)
979dda4fb85SAurabindo Pillai minDET_pipe = minDET;
980dda4fb85SAurabindo Pillai minDET = minDET + 64;
981dda4fb85SAurabindo Pillai }
982dda4fb85SAurabindo Pillai
983dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
984dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d minDET = %d\n", __func__, k, minDET);
985dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d max_minDET = %d\n", __func__, k, max_minDET);
986dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d minDET_pipe = %d\n", __func__, k, minDET_pipe);
987dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d RoundedUpMaxSwathSizeBytesY = %d\n", __func__, k,
988dda4fb85SAurabindo Pillai RoundedUpMaxSwathSizeBytesY[k]);
989dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d RoundedUpMaxSwathSizeBytesC = %d\n", __func__, k,
990dda4fb85SAurabindo Pillai RoundedUpMaxSwathSizeBytesC[k]);
991dda4fb85SAurabindo Pillai #endif
992dda4fb85SAurabindo Pillai
993dda4fb85SAurabindo Pillai if (minDET_pipe == 0) {
994dda4fb85SAurabindo Pillai minDET_pipe = dml_max(128, dml_ceil(((double)RoundedUpMaxSwathSizeBytesY[k] +
995dda4fb85SAurabindo Pillai (double)RoundedUpMaxSwathSizeBytesC[k]) / 1024.0, 64));
996dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
997dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d minDET_pipe = %d (assume each plane take half DET)\n",
998dda4fb85SAurabindo Pillai __func__, k, minDET_pipe);
999dda4fb85SAurabindo Pillai #endif
1000dda4fb85SAurabindo Pillai }
1001dda4fb85SAurabindo Pillai
1002dda4fb85SAurabindo Pillai if (UseMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe) {
1003dda4fb85SAurabindo Pillai DETBufferSizeInKByte[k] = 0;
1004dda4fb85SAurabindo Pillai } else if (DETSizeOverride[k] > 0) {
1005dda4fb85SAurabindo Pillai DETBufferSizeInKByte[k] = DETSizeOverride[k];
1006dda4fb85SAurabindo Pillai DETBufferSizePoolInKByte = DETBufferSizePoolInKByte -
1007dda4fb85SAurabindo Pillai (ForceSingleDPP ? 1 : DPPPerSurface[k]) * DETSizeOverride[k];
1008dda4fb85SAurabindo Pillai } else if ((ForceSingleDPP ? 1 : DPPPerSurface[k]) * minDET_pipe <= DETBufferSizePoolInKByte) {
1009dda4fb85SAurabindo Pillai DETBufferSizeInKByte[k] = minDET_pipe;
1010dda4fb85SAurabindo Pillai DETBufferSizePoolInKByte = DETBufferSizePoolInKByte -
1011dda4fb85SAurabindo Pillai (ForceSingleDPP ? 1 : DPPPerSurface[k]) * minDET_pipe;
1012dda4fb85SAurabindo Pillai }
1013dda4fb85SAurabindo Pillai
1014dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
1015dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d DPPPerSurface = %d\n", __func__, k, DPPPerSurface[k]);
1016dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d DETSizeOverride = %d\n", __func__, k, DETSizeOverride[k]);
1017dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d DETBufferSizeInKByte = %d\n", __func__, k, DETBufferSizeInKByte[k]);
1018dda4fb85SAurabindo Pillai dml_print("DML::%s: DETBufferSizePoolInKByte = %d\n", __func__, DETBufferSizePoolInKByte);
1019dda4fb85SAurabindo Pillai #endif
1020dda4fb85SAurabindo Pillai }
1021dda4fb85SAurabindo Pillai
1022dda4fb85SAurabindo Pillai TotalBandwidth = 0;
1023dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
1024dda4fb85SAurabindo Pillai if (UseMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe)
1025dda4fb85SAurabindo Pillai TotalBandwidth = TotalBandwidth + ReadBandwidthLuma[k] + ReadBandwidthChroma[k];
1026dda4fb85SAurabindo Pillai }
1027dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
1028dda4fb85SAurabindo Pillai dml_print("DML::%s: --- Before bandwidth adjustment ---\n", __func__);
1029dda4fb85SAurabindo Pillai for (uint k = 0; k < NumberOfActiveSurfaces; ++k)
1030dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d DETBufferSizeInKByte = %d\n", __func__, k, DETBufferSizeInKByte[k]);
1031dda4fb85SAurabindo Pillai dml_print("DML::%s: --- DET allocation with bandwidth ---\n", __func__);
1032dda4fb85SAurabindo Pillai dml_print("DML::%s: TotalBandwidth = %f\n", __func__, TotalBandwidth);
1033dda4fb85SAurabindo Pillai #endif
1034dda4fb85SAurabindo Pillai BandwidthOfSurfacesNotAssignedDETPiece = TotalBandwidth;
1035dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
1036dda4fb85SAurabindo Pillai
1037dda4fb85SAurabindo Pillai if (UseMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe) {
1038dda4fb85SAurabindo Pillai DETPieceAssignedToThisSurfaceAlready[k] = true;
1039dda4fb85SAurabindo Pillai } else if (DETSizeOverride[k] > 0 || (((double) (ForceSingleDPP ? 1 : DPPPerSurface[k]) *
1040dda4fb85SAurabindo Pillai (double) DETBufferSizeInKByte[k] / (double) MaxTotalDETInKByte) >=
1041dda4fb85SAurabindo Pillai ((ReadBandwidthLuma[k] + ReadBandwidthChroma[k]) / TotalBandwidth))) {
1042dda4fb85SAurabindo Pillai DETPieceAssignedToThisSurfaceAlready[k] = true;
1043dda4fb85SAurabindo Pillai BandwidthOfSurfacesNotAssignedDETPiece = BandwidthOfSurfacesNotAssignedDETPiece -
1044dda4fb85SAurabindo Pillai ReadBandwidthLuma[k] - ReadBandwidthChroma[k];
1045dda4fb85SAurabindo Pillai } else {
1046dda4fb85SAurabindo Pillai DETPieceAssignedToThisSurfaceAlready[k] = false;
1047dda4fb85SAurabindo Pillai }
1048dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
1049dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d DETPieceAssignedToThisSurfaceAlready = %d\n", __func__, k,
1050dda4fb85SAurabindo Pillai DETPieceAssignedToThisSurfaceAlready[k]);
1051dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d BandwidthOfSurfacesNotAssignedDETPiece = %f\n", __func__, k,
1052dda4fb85SAurabindo Pillai BandwidthOfSurfacesNotAssignedDETPiece);
1053dda4fb85SAurabindo Pillai #endif
1054dda4fb85SAurabindo Pillai }
1055dda4fb85SAurabindo Pillai
1056dda4fb85SAurabindo Pillai for (j = 0; j < NumberOfActiveSurfaces; ++j) {
1057dda4fb85SAurabindo Pillai NextPotentialSurfaceToAssignDETPieceFound = false;
1058dda4fb85SAurabindo Pillai NextSurfaceToAssignDETPiece = 0;
1059dda4fb85SAurabindo Pillai
1060dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
1061dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
1062dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%d k=%d, ReadBandwidthLuma[k] = %f\n", __func__, j, k,
1063dda4fb85SAurabindo Pillai ReadBandwidthLuma[k]);
1064dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%d k=%d, ReadBandwidthChroma[k] = %f\n", __func__, j, k,
1065dda4fb85SAurabindo Pillai ReadBandwidthChroma[k]);
1066dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%d k=%d, ReadBandwidthLuma[Next] = %f\n", __func__, j, k,
1067dda4fb85SAurabindo Pillai ReadBandwidthLuma[NextSurfaceToAssignDETPiece]);
1068dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%d k=%d, ReadBandwidthChroma[Next] = %f\n", __func__, j, k,
1069dda4fb85SAurabindo Pillai ReadBandwidthChroma[NextSurfaceToAssignDETPiece]);
1070dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%d k=%d, NextSurfaceToAssignDETPiece = %d\n", __func__, j, k,
1071dda4fb85SAurabindo Pillai NextSurfaceToAssignDETPiece);
1072dda4fb85SAurabindo Pillai #endif
1073dda4fb85SAurabindo Pillai if (!DETPieceAssignedToThisSurfaceAlready[k] &&
1074dda4fb85SAurabindo Pillai (!NextPotentialSurfaceToAssignDETPieceFound ||
1075dda4fb85SAurabindo Pillai ReadBandwidthLuma[k] + ReadBandwidthChroma[k] <
1076dda4fb85SAurabindo Pillai ReadBandwidthLuma[NextSurfaceToAssignDETPiece] +
1077dda4fb85SAurabindo Pillai ReadBandwidthChroma[NextSurfaceToAssignDETPiece])) {
1078dda4fb85SAurabindo Pillai NextSurfaceToAssignDETPiece = k;
1079dda4fb85SAurabindo Pillai NextPotentialSurfaceToAssignDETPieceFound = true;
1080dda4fb85SAurabindo Pillai }
1081dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
1082dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%d k=%d, DETPieceAssignedToThisSurfaceAlready = %d\n",
1083dda4fb85SAurabindo Pillai __func__, j, k, DETPieceAssignedToThisSurfaceAlready[k]);
1084dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%d k=%d, NextPotentialSurfaceToAssignDETPieceFound = %d\n",
1085dda4fb85SAurabindo Pillai __func__, j, k, NextPotentialSurfaceToAssignDETPieceFound);
1086dda4fb85SAurabindo Pillai #endif
1087dda4fb85SAurabindo Pillai }
1088dda4fb85SAurabindo Pillai
1089dda4fb85SAurabindo Pillai if (NextPotentialSurfaceToAssignDETPieceFound) {
1090dda4fb85SAurabindo Pillai // Note: To show the banker's rounding behavior in VBA and also the fact
1091dda4fb85SAurabindo Pillai // that the DET buffer size varies due to precision issue
1092dda4fb85SAurabindo Pillai //
1093dda4fb85SAurabindo Pillai //double tmp1 = ((double) DETBufferSizePoolInKByte *
1094dda4fb85SAurabindo Pillai // (ReadBandwidthLuma[NextSurfaceToAssignDETPiece] +
1095dda4fb85SAurabindo Pillai // ReadBandwidthChroma[NextSurfaceToAssignDETPiece]) /
1096dda4fb85SAurabindo Pillai // BandwidthOfSurfacesNotAssignedDETPiece /
1097dda4fb85SAurabindo Pillai // ((ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]) * 64.0));
1098dda4fb85SAurabindo Pillai //double tmp2 = dml_round((double) DETBufferSizePoolInKByte *
1099dda4fb85SAurabindo Pillai // (ReadBandwidthLuma[NextSurfaceToAssignDETPiece] +
1100dda4fb85SAurabindo Pillai // ReadBandwidthChroma[NextSurfaceToAssignDETPiece]) /
1101dda4fb85SAurabindo Pillai //BandwidthOfSurfacesNotAssignedDETPiece /
1102dda4fb85SAurabindo Pillai // ((ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]) * 64.0));
1103dda4fb85SAurabindo Pillai //
1104dda4fb85SAurabindo Pillai //dml_print("DML::%s: j=%d, tmp1 = %f\n", __func__, j, tmp1);
1105dda4fb85SAurabindo Pillai //dml_print("DML::%s: j=%d, tmp2 = %f\n", __func__, j, tmp2);
1106dda4fb85SAurabindo Pillai
1107dda4fb85SAurabindo Pillai NextDETBufferPieceInKByte = dml_min(
1108dda4fb85SAurabindo Pillai dml_round((double) DETBufferSizePoolInKByte *
1109dda4fb85SAurabindo Pillai (ReadBandwidthLuma[NextSurfaceToAssignDETPiece] +
1110dda4fb85SAurabindo Pillai ReadBandwidthChroma[NextSurfaceToAssignDETPiece]) /
1111dda4fb85SAurabindo Pillai BandwidthOfSurfacesNotAssignedDETPiece /
1112dda4fb85SAurabindo Pillai ((ForceSingleDPP ? 1 :
1113dda4fb85SAurabindo Pillai DPPPerSurface[NextSurfaceToAssignDETPiece]) * 64.0)) *
1114dda4fb85SAurabindo Pillai (ForceSingleDPP ? 1 :
1115dda4fb85SAurabindo Pillai DPPPerSurface[NextSurfaceToAssignDETPiece]) * 64.0,
1116dda4fb85SAurabindo Pillai dml_floor((double) DETBufferSizePoolInKByte,
1117dda4fb85SAurabindo Pillai (ForceSingleDPP ? 1 :
1118dda4fb85SAurabindo Pillai DPPPerSurface[NextSurfaceToAssignDETPiece]) * 64.0));
1119dda4fb85SAurabindo Pillai
1120dda4fb85SAurabindo Pillai // Above calculation can assign the entire DET buffer allocation to a single pipe.
1121dda4fb85SAurabindo Pillai // We should limit the per-pipe DET size to the nominal / max per pipe.
1122dda4fb85SAurabindo Pillai if (NextDETBufferPieceInKByte > nomDETInKByte * (ForceSingleDPP ? 1 : DPPPerSurface[k])) {
1123dda4fb85SAurabindo Pillai if (DETBufferSizeInKByte[NextSurfaceToAssignDETPiece] <
1124dda4fb85SAurabindo Pillai nomDETInKByte * (ForceSingleDPP ? 1 : DPPPerSurface[k])) {
1125dda4fb85SAurabindo Pillai NextDETBufferPieceInKByte = nomDETInKByte * (ForceSingleDPP ? 1 : DPPPerSurface[k]) -
1126dda4fb85SAurabindo Pillai DETBufferSizeInKByte[NextSurfaceToAssignDETPiece];
1127dda4fb85SAurabindo Pillai } else {
1128dda4fb85SAurabindo Pillai // Case where DETBufferSizeInKByte[NextSurfaceToAssignDETPiece]
1129dda4fb85SAurabindo Pillai // already has the max per-pipe value
1130dda4fb85SAurabindo Pillai NextDETBufferPieceInKByte = 0;
1131dda4fb85SAurabindo Pillai }
1132dda4fb85SAurabindo Pillai }
1133dda4fb85SAurabindo Pillai
1134dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
1135dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%0d, DETBufferSizePoolInKByte = %d\n", __func__, j,
1136dda4fb85SAurabindo Pillai DETBufferSizePoolInKByte);
1137dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%0d, NextSurfaceToAssignDETPiece = %d\n", __func__, j,
1138dda4fb85SAurabindo Pillai NextSurfaceToAssignDETPiece);
1139dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%0d, ReadBandwidthLuma[%0d] = %f\n", __func__, j,
1140dda4fb85SAurabindo Pillai NextSurfaceToAssignDETPiece, ReadBandwidthLuma[NextSurfaceToAssignDETPiece]);
1141dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%0d, ReadBandwidthChroma[%0d] = %f\n", __func__, j,
1142dda4fb85SAurabindo Pillai NextSurfaceToAssignDETPiece, ReadBandwidthChroma[NextSurfaceToAssignDETPiece]);
1143dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%0d, BandwidthOfSurfacesNotAssignedDETPiece = %f\n",
1144dda4fb85SAurabindo Pillai __func__, j, BandwidthOfSurfacesNotAssignedDETPiece);
1145dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%0d, NextDETBufferPieceInKByte = %d\n", __func__, j,
1146dda4fb85SAurabindo Pillai NextDETBufferPieceInKByte);
1147dda4fb85SAurabindo Pillai dml_print("DML::%s: j=%0d, DETBufferSizeInKByte[%0d] increases from %0d ",
1148dda4fb85SAurabindo Pillai __func__, j, NextSurfaceToAssignDETPiece,
1149dda4fb85SAurabindo Pillai DETBufferSizeInKByte[NextSurfaceToAssignDETPiece]);
1150dda4fb85SAurabindo Pillai #endif
1151dda4fb85SAurabindo Pillai
1152dda4fb85SAurabindo Pillai DETBufferSizeInKByte[NextSurfaceToAssignDETPiece] =
1153dda4fb85SAurabindo Pillai DETBufferSizeInKByte[NextSurfaceToAssignDETPiece]
1154dda4fb85SAurabindo Pillai + NextDETBufferPieceInKByte
1155dda4fb85SAurabindo Pillai / (ForceSingleDPP ? 1 : DPPPerSurface[NextSurfaceToAssignDETPiece]);
1156dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
1157dda4fb85SAurabindo Pillai dml_print("to %0d\n", DETBufferSizeInKByte[NextSurfaceToAssignDETPiece]);
1158dda4fb85SAurabindo Pillai #endif
1159dda4fb85SAurabindo Pillai
1160dda4fb85SAurabindo Pillai DETBufferSizePoolInKByte = DETBufferSizePoolInKByte - NextDETBufferPieceInKByte;
1161dda4fb85SAurabindo Pillai DETPieceAssignedToThisSurfaceAlready[NextSurfaceToAssignDETPiece] = true;
1162dda4fb85SAurabindo Pillai BandwidthOfSurfacesNotAssignedDETPiece = BandwidthOfSurfacesNotAssignedDETPiece -
1163dda4fb85SAurabindo Pillai (ReadBandwidthLuma[NextSurfaceToAssignDETPiece] +
1164dda4fb85SAurabindo Pillai ReadBandwidthChroma[NextSurfaceToAssignDETPiece]);
1165dda4fb85SAurabindo Pillai }
1166dda4fb85SAurabindo Pillai }
1167dda4fb85SAurabindo Pillai *CompressedBufferSizeInkByte = MinCompressedBufferSizeInKByte;
1168dda4fb85SAurabindo Pillai }
1169dda4fb85SAurabindo Pillai *CompressedBufferSizeInkByte = *CompressedBufferSizeInkByte * CompressedBufferSegmentSizeInkByteFinal / 64;
1170dda4fb85SAurabindo Pillai
1171dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
1172dda4fb85SAurabindo Pillai dml_print("DML::%s: --- After bandwidth adjustment ---\n", __func__);
1173dda4fb85SAurabindo Pillai dml_print("DML::%s: CompressedBufferSizeInkByte = %d\n", __func__, *CompressedBufferSizeInkByte);
1174dda4fb85SAurabindo Pillai for (uint k = 0; k < NumberOfActiveSurfaces; ++k) {
1175dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d DETBufferSizeInKByte = %d (TotalReadBandWidth=%f)\n",
1176dda4fb85SAurabindo Pillai __func__, k, DETBufferSizeInKByte[k], ReadBandwidthLuma[k] + ReadBandwidthChroma[k]);
1177dda4fb85SAurabindo Pillai }
1178dda4fb85SAurabindo Pillai #endif
1179dda4fb85SAurabindo Pillai } // CalculateDETBufferSize
1180dda4fb85SAurabindo Pillai
dml32_CalculateODMMode(unsigned int MaximumPixelsPerLinePerDSCUnit,unsigned int HActive,enum output_format_class OutFormat,enum output_encoder_class Output,enum odm_combine_policy ODMUse,double StateDispclk,double MaxDispclk,bool DSCEnable,unsigned int TotalNumberOfActiveDPP,unsigned int MaxNumDPP,double PixelClock,double DISPCLKDPPCLKDSCCLKDownSpreading,double DISPCLKRampingMargin,double DISPCLKDPPCLKVCOSpeed,unsigned int NumberOfDSCSlices,bool * TotalAvailablePipesSupport,unsigned int * NumberOfDPP,enum odm_combine_mode * ODMMode,double * RequiredDISPCLKPerSurface)1181dda4fb85SAurabindo Pillai void dml32_CalculateODMMode(
1182dda4fb85SAurabindo Pillai unsigned int MaximumPixelsPerLinePerDSCUnit,
1183dda4fb85SAurabindo Pillai unsigned int HActive,
118416e5859dSChris Park enum output_format_class OutFormat,
1185dda4fb85SAurabindo Pillai enum output_encoder_class Output,
1186dda4fb85SAurabindo Pillai enum odm_combine_policy ODMUse,
1187dda4fb85SAurabindo Pillai double StateDispclk,
1188dda4fb85SAurabindo Pillai double MaxDispclk,
1189dda4fb85SAurabindo Pillai bool DSCEnable,
1190dda4fb85SAurabindo Pillai unsigned int TotalNumberOfActiveDPP,
1191dda4fb85SAurabindo Pillai unsigned int MaxNumDPP,
1192dda4fb85SAurabindo Pillai double PixelClock,
1193dda4fb85SAurabindo Pillai double DISPCLKDPPCLKDSCCLKDownSpreading,
1194dda4fb85SAurabindo Pillai double DISPCLKRampingMargin,
1195dda4fb85SAurabindo Pillai double DISPCLKDPPCLKVCOSpeed,
1196572200dbSTaimur Hassan unsigned int NumberOfDSCSlices,
1197dda4fb85SAurabindo Pillai
1198dda4fb85SAurabindo Pillai /* Output */
1199dda4fb85SAurabindo Pillai bool *TotalAvailablePipesSupport,
1200dda4fb85SAurabindo Pillai unsigned int *NumberOfDPP,
1201dda4fb85SAurabindo Pillai enum odm_combine_mode *ODMMode,
1202dda4fb85SAurabindo Pillai double *RequiredDISPCLKPerSurface)
1203dda4fb85SAurabindo Pillai {
1204dda4fb85SAurabindo Pillai
1205dda4fb85SAurabindo Pillai double SurfaceRequiredDISPCLKWithoutODMCombine;
1206dda4fb85SAurabindo Pillai double SurfaceRequiredDISPCLKWithODMCombineTwoToOne;
1207dda4fb85SAurabindo Pillai double SurfaceRequiredDISPCLKWithODMCombineFourToOne;
1208dda4fb85SAurabindo Pillai
1209dda4fb85SAurabindo Pillai SurfaceRequiredDISPCLKWithoutODMCombine = dml32_CalculateRequiredDispclk(dm_odm_combine_mode_disabled,
1210dda4fb85SAurabindo Pillai PixelClock, DISPCLKDPPCLKDSCCLKDownSpreading, DISPCLKRampingMargin, DISPCLKDPPCLKVCOSpeed,
1211dda4fb85SAurabindo Pillai MaxDispclk);
1212dda4fb85SAurabindo Pillai SurfaceRequiredDISPCLKWithODMCombineTwoToOne = dml32_CalculateRequiredDispclk(dm_odm_combine_mode_2to1,
1213dda4fb85SAurabindo Pillai PixelClock, DISPCLKDPPCLKDSCCLKDownSpreading, DISPCLKRampingMargin, DISPCLKDPPCLKVCOSpeed,
1214dda4fb85SAurabindo Pillai MaxDispclk);
1215dda4fb85SAurabindo Pillai SurfaceRequiredDISPCLKWithODMCombineFourToOne = dml32_CalculateRequiredDispclk(dm_odm_combine_mode_4to1,
1216dda4fb85SAurabindo Pillai PixelClock, DISPCLKDPPCLKDSCCLKDownSpreading, DISPCLKRampingMargin, DISPCLKDPPCLKVCOSpeed,
1217dda4fb85SAurabindo Pillai MaxDispclk);
1218dda4fb85SAurabindo Pillai *TotalAvailablePipesSupport = true;
1219dda4fb85SAurabindo Pillai *ODMMode = dm_odm_combine_mode_disabled; // initialize as disable
1220dda4fb85SAurabindo Pillai
1221dda4fb85SAurabindo Pillai if (ODMUse == dm_odm_combine_policy_none)
1222dda4fb85SAurabindo Pillai *ODMMode = dm_odm_combine_mode_disabled;
1223dda4fb85SAurabindo Pillai
1224dda4fb85SAurabindo Pillai *RequiredDISPCLKPerSurface = SurfaceRequiredDISPCLKWithoutODMCombine;
1225dda4fb85SAurabindo Pillai *NumberOfDPP = 0;
1226dda4fb85SAurabindo Pillai
1227dda4fb85SAurabindo Pillai // FIXME check ODMUse == "" condition does it mean bypass or Gabriel means something like don't care??
1228dda4fb85SAurabindo Pillai // (ODMUse == "" || ODMUse == "CombineAsNeeded")
1229dda4fb85SAurabindo Pillai
1230dda4fb85SAurabindo Pillai if (!(Output == dm_hdmi || Output == dm_dp || Output == dm_edp) && (ODMUse == dm_odm_combine_policy_4to1 ||
1231dda4fb85SAurabindo Pillai ((SurfaceRequiredDISPCLKWithODMCombineTwoToOne > StateDispclk ||
1232572200dbSTaimur Hassan (DSCEnable && (HActive > 2 * MaximumPixelsPerLinePerDSCUnit))
1233572200dbSTaimur Hassan || NumberOfDSCSlices > 8)))) {
1234dda4fb85SAurabindo Pillai if (TotalNumberOfActiveDPP + 4 <= MaxNumDPP) {
1235dda4fb85SAurabindo Pillai *ODMMode = dm_odm_combine_mode_4to1;
1236dda4fb85SAurabindo Pillai *RequiredDISPCLKPerSurface = SurfaceRequiredDISPCLKWithODMCombineFourToOne;
1237dda4fb85SAurabindo Pillai *NumberOfDPP = 4;
1238dda4fb85SAurabindo Pillai } else {
1239dda4fb85SAurabindo Pillai *TotalAvailablePipesSupport = false;
1240dda4fb85SAurabindo Pillai }
1241dda4fb85SAurabindo Pillai } else if (Output != dm_hdmi && (ODMUse == dm_odm_combine_policy_2to1 ||
1242dda4fb85SAurabindo Pillai (((SurfaceRequiredDISPCLKWithoutODMCombine > StateDispclk &&
1243dda4fb85SAurabindo Pillai SurfaceRequiredDISPCLKWithODMCombineTwoToOne <= StateDispclk) ||
1244572200dbSTaimur Hassan (DSCEnable && (HActive > MaximumPixelsPerLinePerDSCUnit))
1245572200dbSTaimur Hassan || (NumberOfDSCSlices <= 8 && NumberOfDSCSlices > 4))))) {
1246dda4fb85SAurabindo Pillai if (TotalNumberOfActiveDPP + 2 <= MaxNumDPP) {
1247dda4fb85SAurabindo Pillai *ODMMode = dm_odm_combine_mode_2to1;
1248dda4fb85SAurabindo Pillai *RequiredDISPCLKPerSurface = SurfaceRequiredDISPCLKWithODMCombineTwoToOne;
1249dda4fb85SAurabindo Pillai *NumberOfDPP = 2;
1250dda4fb85SAurabindo Pillai } else {
1251dda4fb85SAurabindo Pillai *TotalAvailablePipesSupport = false;
1252dda4fb85SAurabindo Pillai }
1253dda4fb85SAurabindo Pillai } else {
1254dda4fb85SAurabindo Pillai if (TotalNumberOfActiveDPP + 1 <= MaxNumDPP)
1255dda4fb85SAurabindo Pillai *NumberOfDPP = 1;
1256dda4fb85SAurabindo Pillai else
1257dda4fb85SAurabindo Pillai *TotalAvailablePipesSupport = false;
1258dda4fb85SAurabindo Pillai }
125916e5859dSChris Park if (OutFormat == dm_420 && HActive > DCN32_MAX_FMT_420_BUFFER_WIDTH &&
126016e5859dSChris Park ODMUse != dm_odm_combine_policy_4to1) {
126116e5859dSChris Park if (HActive > DCN32_MAX_FMT_420_BUFFER_WIDTH * 4) {
126216e5859dSChris Park *ODMMode = dm_odm_combine_mode_disabled;
126316e5859dSChris Park *NumberOfDPP = 0;
126416e5859dSChris Park *TotalAvailablePipesSupport = false;
126516e5859dSChris Park } else if (HActive > DCN32_MAX_FMT_420_BUFFER_WIDTH * 2 ||
126616e5859dSChris Park *ODMMode == dm_odm_combine_mode_4to1) {
126716e5859dSChris Park *ODMMode = dm_odm_combine_mode_4to1;
126816e5859dSChris Park *RequiredDISPCLKPerSurface = SurfaceRequiredDISPCLKWithODMCombineFourToOne;
126916e5859dSChris Park *NumberOfDPP = 4;
127016e5859dSChris Park } else {
127116e5859dSChris Park *ODMMode = dm_odm_combine_mode_2to1;
127216e5859dSChris Park *RequiredDISPCLKPerSurface = SurfaceRequiredDISPCLKWithODMCombineTwoToOne;
127316e5859dSChris Park *NumberOfDPP = 2;
127416e5859dSChris Park }
127516e5859dSChris Park }
127616e5859dSChris Park if (Output == dm_hdmi && OutFormat == dm_420 &&
127716e5859dSChris Park HActive > DCN32_MAX_FMT_420_BUFFER_WIDTH) {
127816e5859dSChris Park *ODMMode = dm_odm_combine_mode_disabled;
127916e5859dSChris Park *NumberOfDPP = 0;
128016e5859dSChris Park *TotalAvailablePipesSupport = false;
128116e5859dSChris Park }
1282dda4fb85SAurabindo Pillai }
1283dda4fb85SAurabindo Pillai
dml32_CalculateRequiredDispclk(enum odm_combine_mode ODMMode,double PixelClock,double DISPCLKDPPCLKDSCCLKDownSpreading,double DISPCLKRampingMargin,double DISPCLKDPPCLKVCOSpeed,double MaxDispclk)1284dda4fb85SAurabindo Pillai double dml32_CalculateRequiredDispclk(
1285dda4fb85SAurabindo Pillai enum odm_combine_mode ODMMode,
1286dda4fb85SAurabindo Pillai double PixelClock,
1287dda4fb85SAurabindo Pillai double DISPCLKDPPCLKDSCCLKDownSpreading,
1288dda4fb85SAurabindo Pillai double DISPCLKRampingMargin,
1289dda4fb85SAurabindo Pillai double DISPCLKDPPCLKVCOSpeed,
1290dda4fb85SAurabindo Pillai double MaxDispclk)
1291dda4fb85SAurabindo Pillai {
1292dda4fb85SAurabindo Pillai double RequiredDispclk = 0.;
1293dda4fb85SAurabindo Pillai double PixelClockAfterODM;
1294dda4fb85SAurabindo Pillai double DISPCLKWithRampingRoundedToDFSGranularity;
1295dda4fb85SAurabindo Pillai double DISPCLKWithoutRampingRoundedToDFSGranularity;
1296dda4fb85SAurabindo Pillai double MaxDispclkRoundedDownToDFSGranularity;
1297dda4fb85SAurabindo Pillai
1298dda4fb85SAurabindo Pillai if (ODMMode == dm_odm_combine_mode_4to1)
1299dda4fb85SAurabindo Pillai PixelClockAfterODM = PixelClock / 4;
1300dda4fb85SAurabindo Pillai else if (ODMMode == dm_odm_combine_mode_2to1)
1301dda4fb85SAurabindo Pillai PixelClockAfterODM = PixelClock / 2;
1302dda4fb85SAurabindo Pillai else
1303dda4fb85SAurabindo Pillai PixelClockAfterODM = PixelClock;
1304dda4fb85SAurabindo Pillai
1305dda4fb85SAurabindo Pillai
1306dda4fb85SAurabindo Pillai DISPCLKWithRampingRoundedToDFSGranularity = dml32_RoundToDFSGranularity(
1307dda4fb85SAurabindo Pillai PixelClockAfterODM * (1 + DISPCLKDPPCLKDSCCLKDownSpreading / 100)
1308dda4fb85SAurabindo Pillai * (1 + DISPCLKRampingMargin / 100), 1, DISPCLKDPPCLKVCOSpeed);
1309dda4fb85SAurabindo Pillai
1310dda4fb85SAurabindo Pillai DISPCLKWithoutRampingRoundedToDFSGranularity = dml32_RoundToDFSGranularity(
1311dda4fb85SAurabindo Pillai PixelClockAfterODM * (1 + DISPCLKDPPCLKDSCCLKDownSpreading / 100), 1, DISPCLKDPPCLKVCOSpeed);
1312dda4fb85SAurabindo Pillai
1313dda4fb85SAurabindo Pillai MaxDispclkRoundedDownToDFSGranularity = dml32_RoundToDFSGranularity(MaxDispclk, 0, DISPCLKDPPCLKVCOSpeed);
1314dda4fb85SAurabindo Pillai
1315dda4fb85SAurabindo Pillai if (DISPCLKWithoutRampingRoundedToDFSGranularity > MaxDispclkRoundedDownToDFSGranularity)
1316dda4fb85SAurabindo Pillai RequiredDispclk = DISPCLKWithoutRampingRoundedToDFSGranularity;
1317dda4fb85SAurabindo Pillai else if (DISPCLKWithRampingRoundedToDFSGranularity > MaxDispclkRoundedDownToDFSGranularity)
1318dda4fb85SAurabindo Pillai RequiredDispclk = MaxDispclkRoundedDownToDFSGranularity;
1319dda4fb85SAurabindo Pillai else
1320dda4fb85SAurabindo Pillai RequiredDispclk = DISPCLKWithRampingRoundedToDFSGranularity;
1321dda4fb85SAurabindo Pillai
1322dda4fb85SAurabindo Pillai return RequiredDispclk;
1323dda4fb85SAurabindo Pillai }
1324dda4fb85SAurabindo Pillai
dml32_RoundToDFSGranularity(double Clock,bool round_up,double VCOSpeed)1325dda4fb85SAurabindo Pillai double dml32_RoundToDFSGranularity(double Clock, bool round_up, double VCOSpeed)
1326dda4fb85SAurabindo Pillai {
1327dda4fb85SAurabindo Pillai if (Clock <= 0.0)
1328dda4fb85SAurabindo Pillai return 0.0;
1329dda4fb85SAurabindo Pillai
1330dda4fb85SAurabindo Pillai if (round_up)
1331dda4fb85SAurabindo Pillai return VCOSpeed * 4.0 / dml_floor(VCOSpeed * 4.0 / Clock, 1.0);
1332dda4fb85SAurabindo Pillai else
1333dda4fb85SAurabindo Pillai return VCOSpeed * 4.0 / dml_ceil(VCOSpeed * 4.0 / Clock, 1.0);
1334dda4fb85SAurabindo Pillai }
1335dda4fb85SAurabindo Pillai
dml32_CalculateOutputLink(double PHYCLKPerState,double PHYCLKD18PerState,double PHYCLKD32PerState,double Downspreading,bool IsMainSurfaceUsingTheIndicatedTiming,enum output_encoder_class Output,enum output_format_class OutputFormat,unsigned int HTotal,unsigned int HActive,double PixelClockBackEnd,double ForcedOutputLinkBPP,unsigned int DSCInputBitPerComponent,unsigned int NumberOfDSCSlices,double AudioSampleRate,unsigned int AudioSampleLayout,enum odm_combine_mode ODMModeNoDSC,enum odm_combine_mode ODMModeDSC,bool DSCEnable,unsigned int OutputLinkDPLanes,enum dm_output_link_dp_rate OutputLinkDPRate,bool * RequiresDSC,double * RequiresFEC,double * OutBpp,enum dm_output_type * OutputType,enum dm_output_rate * OutputRate,unsigned int * RequiredSlots)1336dda4fb85SAurabindo Pillai void dml32_CalculateOutputLink(
1337dda4fb85SAurabindo Pillai double PHYCLKPerState,
1338dda4fb85SAurabindo Pillai double PHYCLKD18PerState,
1339dda4fb85SAurabindo Pillai double PHYCLKD32PerState,
1340dda4fb85SAurabindo Pillai double Downspreading,
1341dda4fb85SAurabindo Pillai bool IsMainSurfaceUsingTheIndicatedTiming,
1342dda4fb85SAurabindo Pillai enum output_encoder_class Output,
1343dda4fb85SAurabindo Pillai enum output_format_class OutputFormat,
1344dda4fb85SAurabindo Pillai unsigned int HTotal,
1345dda4fb85SAurabindo Pillai unsigned int HActive,
1346dda4fb85SAurabindo Pillai double PixelClockBackEnd,
1347dda4fb85SAurabindo Pillai double ForcedOutputLinkBPP,
1348dda4fb85SAurabindo Pillai unsigned int DSCInputBitPerComponent,
1349dda4fb85SAurabindo Pillai unsigned int NumberOfDSCSlices,
1350dda4fb85SAurabindo Pillai double AudioSampleRate,
1351dda4fb85SAurabindo Pillai unsigned int AudioSampleLayout,
1352dda4fb85SAurabindo Pillai enum odm_combine_mode ODMModeNoDSC,
1353dda4fb85SAurabindo Pillai enum odm_combine_mode ODMModeDSC,
1354dda4fb85SAurabindo Pillai bool DSCEnable,
1355dda4fb85SAurabindo Pillai unsigned int OutputLinkDPLanes,
1356dda4fb85SAurabindo Pillai enum dm_output_link_dp_rate OutputLinkDPRate,
1357dda4fb85SAurabindo Pillai
1358dda4fb85SAurabindo Pillai /* Output */
1359dda4fb85SAurabindo Pillai bool *RequiresDSC,
1360dda4fb85SAurabindo Pillai double *RequiresFEC,
1361dda4fb85SAurabindo Pillai double *OutBpp,
1362dda4fb85SAurabindo Pillai enum dm_output_type *OutputType,
1363dda4fb85SAurabindo Pillai enum dm_output_rate *OutputRate,
1364dda4fb85SAurabindo Pillai unsigned int *RequiredSlots)
1365dda4fb85SAurabindo Pillai {
1366dda4fb85SAurabindo Pillai bool LinkDSCEnable;
1367dda4fb85SAurabindo Pillai unsigned int dummy;
1368dda4fb85SAurabindo Pillai *RequiresDSC = false;
1369dda4fb85SAurabindo Pillai *RequiresFEC = false;
1370dda4fb85SAurabindo Pillai *OutBpp = 0;
1371dda4fb85SAurabindo Pillai *OutputType = dm_output_type_unknown;
1372dda4fb85SAurabindo Pillai *OutputRate = dm_output_rate_unknown;
1373dda4fb85SAurabindo Pillai
1374dda4fb85SAurabindo Pillai if (IsMainSurfaceUsingTheIndicatedTiming) {
1375dda4fb85SAurabindo Pillai if (Output == dm_hdmi) {
1376dda4fb85SAurabindo Pillai *RequiresDSC = false;
1377dda4fb85SAurabindo Pillai *RequiresFEC = false;
1378dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP(dml_min(600, PHYCLKPerState) * 10, 3, HTotal, HActive,
1379dda4fb85SAurabindo Pillai PixelClockBackEnd, ForcedOutputLinkBPP, false, Output, OutputFormat,
1380dda4fb85SAurabindo Pillai DSCInputBitPerComponent, NumberOfDSCSlices, AudioSampleRate, AudioSampleLayout,
1381dda4fb85SAurabindo Pillai ODMModeNoDSC, ODMModeDSC, &dummy);
1382dda4fb85SAurabindo Pillai //OutputTypeAndRate = "HDMI";
1383dda4fb85SAurabindo Pillai *OutputType = dm_output_type_hdmi;
1384dda4fb85SAurabindo Pillai
1385dda4fb85SAurabindo Pillai } else if (Output == dm_dp || Output == dm_dp2p0 || Output == dm_edp) {
1386dda4fb85SAurabindo Pillai if (DSCEnable == true) {
1387dda4fb85SAurabindo Pillai *RequiresDSC = true;
1388dda4fb85SAurabindo Pillai LinkDSCEnable = true;
1389dda4fb85SAurabindo Pillai if (Output == dm_dp || Output == dm_dp2p0)
1390dda4fb85SAurabindo Pillai *RequiresFEC = true;
1391dda4fb85SAurabindo Pillai else
1392dda4fb85SAurabindo Pillai *RequiresFEC = false;
1393dda4fb85SAurabindo Pillai } else {
1394dda4fb85SAurabindo Pillai *RequiresDSC = false;
1395dda4fb85SAurabindo Pillai LinkDSCEnable = false;
1396dda4fb85SAurabindo Pillai if (Output == dm_dp2p0)
1397dda4fb85SAurabindo Pillai *RequiresFEC = true;
1398dda4fb85SAurabindo Pillai else
1399dda4fb85SAurabindo Pillai *RequiresFEC = false;
1400dda4fb85SAurabindo Pillai }
1401dda4fb85SAurabindo Pillai if (Output == dm_dp2p0) {
1402dda4fb85SAurabindo Pillai *OutBpp = 0;
1403dda4fb85SAurabindo Pillai if ((OutputLinkDPRate == dm_dp_rate_na || OutputLinkDPRate == dm_dp_rate_uhbr10) &&
1404dda4fb85SAurabindo Pillai PHYCLKD32PerState >= 10000 / 32) {
1405dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 10000,
1406dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd,
1407dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output, OutputFormat,
1408dda4fb85SAurabindo Pillai DSCInputBitPerComponent, NumberOfDSCSlices, AudioSampleRate,
1409dda4fb85SAurabindo Pillai AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
1410dda4fb85SAurabindo Pillai if (*OutBpp == 0 && PHYCLKD32PerState < 13500 / 32 && DSCEnable == true &&
1411dda4fb85SAurabindo Pillai ForcedOutputLinkBPP == 0) {
1412dda4fb85SAurabindo Pillai *RequiresDSC = true;
1413dda4fb85SAurabindo Pillai LinkDSCEnable = true;
1414dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 10000,
1415dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd,
1416dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output,
1417dda4fb85SAurabindo Pillai OutputFormat, DSCInputBitPerComponent,
1418dda4fb85SAurabindo Pillai NumberOfDSCSlices, AudioSampleRate, AudioSampleLayout,
1419dda4fb85SAurabindo Pillai ODMModeNoDSC, ODMModeDSC, RequiredSlots);
1420dda4fb85SAurabindo Pillai }
1421dda4fb85SAurabindo Pillai //OutputTypeAndRate = Output & " UHBR10";
1422dda4fb85SAurabindo Pillai *OutputType = dm_output_type_dp2p0;
1423dda4fb85SAurabindo Pillai *OutputRate = dm_output_rate_dp_rate_uhbr10;
1424dda4fb85SAurabindo Pillai }
1425dda4fb85SAurabindo Pillai if ((OutputLinkDPRate == dm_dp_rate_na || OutputLinkDPRate == dm_dp_rate_uhbr13p5) &&
1426dda4fb85SAurabindo Pillai *OutBpp == 0 && PHYCLKD32PerState >= 13500 / 32) {
1427dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 13500,
1428dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd,
1429dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output, OutputFormat,
1430dda4fb85SAurabindo Pillai DSCInputBitPerComponent, NumberOfDSCSlices, AudioSampleRate,
1431dda4fb85SAurabindo Pillai AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
1432dda4fb85SAurabindo Pillai
1433dda4fb85SAurabindo Pillai if (*OutBpp == 0 && PHYCLKD32PerState < 20000 / 32 && DSCEnable == true &&
1434dda4fb85SAurabindo Pillai ForcedOutputLinkBPP == 0) {
1435dda4fb85SAurabindo Pillai *RequiresDSC = true;
1436dda4fb85SAurabindo Pillai LinkDSCEnable = true;
1437dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 13500,
1438dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd,
1439dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output,
1440dda4fb85SAurabindo Pillai OutputFormat, DSCInputBitPerComponent,
1441dda4fb85SAurabindo Pillai NumberOfDSCSlices, AudioSampleRate, AudioSampleLayout,
1442dda4fb85SAurabindo Pillai ODMModeNoDSC, ODMModeDSC, RequiredSlots);
1443dda4fb85SAurabindo Pillai }
1444dda4fb85SAurabindo Pillai //OutputTypeAndRate = Output & " UHBR13p5";
1445dda4fb85SAurabindo Pillai *OutputType = dm_output_type_dp2p0;
1446dda4fb85SAurabindo Pillai *OutputRate = dm_output_rate_dp_rate_uhbr13p5;
1447dda4fb85SAurabindo Pillai }
1448dda4fb85SAurabindo Pillai if ((OutputLinkDPRate == dm_dp_rate_na || OutputLinkDPRate == dm_dp_rate_uhbr20) &&
1449dda4fb85SAurabindo Pillai *OutBpp == 0 && PHYCLKD32PerState >= 20000 / 32) {
1450dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 20000,
1451dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd,
1452dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output, OutputFormat,
1453dda4fb85SAurabindo Pillai DSCInputBitPerComponent, NumberOfDSCSlices, AudioSampleRate,
1454dda4fb85SAurabindo Pillai AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
1455dda4fb85SAurabindo Pillai if (*OutBpp == 0 && DSCEnable == true && ForcedOutputLinkBPP == 0) {
1456dda4fb85SAurabindo Pillai *RequiresDSC = true;
1457dda4fb85SAurabindo Pillai LinkDSCEnable = true;
1458dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 20000,
1459dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd,
1460dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output,
1461dda4fb85SAurabindo Pillai OutputFormat, DSCInputBitPerComponent,
1462dda4fb85SAurabindo Pillai NumberOfDSCSlices, AudioSampleRate, AudioSampleLayout,
1463dda4fb85SAurabindo Pillai ODMModeNoDSC, ODMModeDSC, RequiredSlots);
1464dda4fb85SAurabindo Pillai }
1465dda4fb85SAurabindo Pillai //OutputTypeAndRate = Output & " UHBR20";
1466dda4fb85SAurabindo Pillai *OutputType = dm_output_type_dp2p0;
1467dda4fb85SAurabindo Pillai *OutputRate = dm_output_rate_dp_rate_uhbr20;
1468dda4fb85SAurabindo Pillai }
1469dda4fb85SAurabindo Pillai } else {
1470dda4fb85SAurabindo Pillai *OutBpp = 0;
1471dda4fb85SAurabindo Pillai if ((OutputLinkDPRate == dm_dp_rate_na || OutputLinkDPRate == dm_dp_rate_hbr) &&
1472dda4fb85SAurabindo Pillai PHYCLKPerState >= 270) {
1473dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 2700,
1474dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd,
1475dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output, OutputFormat,
1476dda4fb85SAurabindo Pillai DSCInputBitPerComponent, NumberOfDSCSlices, AudioSampleRate,
1477dda4fb85SAurabindo Pillai AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
1478dda4fb85SAurabindo Pillai if (*OutBpp == 0 && PHYCLKPerState < 540 && DSCEnable == true &&
1479dda4fb85SAurabindo Pillai ForcedOutputLinkBPP == 0) {
1480dda4fb85SAurabindo Pillai *RequiresDSC = true;
1481dda4fb85SAurabindo Pillai LinkDSCEnable = true;
1482dda4fb85SAurabindo Pillai if (Output == dm_dp)
1483dda4fb85SAurabindo Pillai *RequiresFEC = true;
1484dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 2700,
1485dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd,
1486dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output,
1487dda4fb85SAurabindo Pillai OutputFormat, DSCInputBitPerComponent,
1488dda4fb85SAurabindo Pillai NumberOfDSCSlices, AudioSampleRate, AudioSampleLayout,
1489dda4fb85SAurabindo Pillai ODMModeNoDSC, ODMModeDSC, RequiredSlots);
1490dda4fb85SAurabindo Pillai }
1491dda4fb85SAurabindo Pillai //OutputTypeAndRate = Output & " HBR";
1492dda4fb85SAurabindo Pillai *OutputType = (Output == dm_dp) ? dm_output_type_dp : dm_output_type_edp;
1493dda4fb85SAurabindo Pillai *OutputRate = dm_output_rate_dp_rate_hbr;
1494dda4fb85SAurabindo Pillai }
1495dda4fb85SAurabindo Pillai if ((OutputLinkDPRate == dm_dp_rate_na || OutputLinkDPRate == dm_dp_rate_hbr2) &&
1496dda4fb85SAurabindo Pillai *OutBpp == 0 && PHYCLKPerState >= 540) {
1497dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 5400,
1498dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd,
1499dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output, OutputFormat,
1500dda4fb85SAurabindo Pillai DSCInputBitPerComponent, NumberOfDSCSlices, AudioSampleRate,
1501dda4fb85SAurabindo Pillai AudioSampleLayout, ODMModeNoDSC, ODMModeDSC, RequiredSlots);
1502dda4fb85SAurabindo Pillai
1503dda4fb85SAurabindo Pillai if (*OutBpp == 0 && PHYCLKPerState < 810 && DSCEnable == true &&
1504dda4fb85SAurabindo Pillai ForcedOutputLinkBPP == 0) {
1505dda4fb85SAurabindo Pillai *RequiresDSC = true;
1506dda4fb85SAurabindo Pillai LinkDSCEnable = true;
1507dda4fb85SAurabindo Pillai if (Output == dm_dp)
1508dda4fb85SAurabindo Pillai *RequiresFEC = true;
1509dda4fb85SAurabindo Pillai
1510dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 5400,
1511dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd,
1512dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output,
1513dda4fb85SAurabindo Pillai OutputFormat, DSCInputBitPerComponent,
1514dda4fb85SAurabindo Pillai NumberOfDSCSlices, AudioSampleRate, AudioSampleLayout,
1515dda4fb85SAurabindo Pillai ODMModeNoDSC, ODMModeDSC, RequiredSlots);
1516dda4fb85SAurabindo Pillai }
1517dda4fb85SAurabindo Pillai //OutputTypeAndRate = Output & " HBR2";
1518dda4fb85SAurabindo Pillai *OutputType = (Output == dm_dp) ? dm_output_type_dp : dm_output_type_edp;
1519dda4fb85SAurabindo Pillai *OutputRate = dm_output_rate_dp_rate_hbr2;
1520dda4fb85SAurabindo Pillai }
1521dda4fb85SAurabindo Pillai if ((OutputLinkDPRate == dm_dp_rate_na || OutputLinkDPRate == dm_dp_rate_hbr3) && *OutBpp == 0 && PHYCLKPerState >= 810) {
1522dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 8100,
1523dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd,
1524dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output,
1525dda4fb85SAurabindo Pillai OutputFormat, DSCInputBitPerComponent, NumberOfDSCSlices,
1526dda4fb85SAurabindo Pillai AudioSampleRate, AudioSampleLayout, ODMModeNoDSC, ODMModeDSC,
1527dda4fb85SAurabindo Pillai RequiredSlots);
1528dda4fb85SAurabindo Pillai
1529dda4fb85SAurabindo Pillai if (*OutBpp == 0 && DSCEnable == true && ForcedOutputLinkBPP == 0) {
1530dda4fb85SAurabindo Pillai *RequiresDSC = true;
1531dda4fb85SAurabindo Pillai LinkDSCEnable = true;
1532dda4fb85SAurabindo Pillai if (Output == dm_dp)
1533dda4fb85SAurabindo Pillai *RequiresFEC = true;
1534dda4fb85SAurabindo Pillai
1535dda4fb85SAurabindo Pillai *OutBpp = dml32_TruncToValidBPP((1 - Downspreading / 100) * 8100,
1536dda4fb85SAurabindo Pillai OutputLinkDPLanes, HTotal, HActive, PixelClockBackEnd,
1537dda4fb85SAurabindo Pillai ForcedOutputLinkBPP, LinkDSCEnable, Output,
1538dda4fb85SAurabindo Pillai OutputFormat, DSCInputBitPerComponent,
1539dda4fb85SAurabindo Pillai NumberOfDSCSlices, AudioSampleRate, AudioSampleLayout,
1540dda4fb85SAurabindo Pillai ODMModeNoDSC, ODMModeDSC, RequiredSlots);
1541dda4fb85SAurabindo Pillai }
1542dda4fb85SAurabindo Pillai //OutputTypeAndRate = Output & " HBR3";
1543dda4fb85SAurabindo Pillai *OutputType = (Output == dm_dp) ? dm_output_type_dp : dm_output_type_edp;
1544dda4fb85SAurabindo Pillai *OutputRate = dm_output_rate_dp_rate_hbr3;
1545dda4fb85SAurabindo Pillai }
1546dda4fb85SAurabindo Pillai }
1547dda4fb85SAurabindo Pillai }
1548dda4fb85SAurabindo Pillai }
1549dda4fb85SAurabindo Pillai }
1550dda4fb85SAurabindo Pillai
dml32_CalculateDPPCLK(unsigned int NumberOfActiveSurfaces,double DISPCLKDPPCLKDSCCLKDownSpreading,double DISPCLKDPPCLKVCOSpeed,double DPPCLKUsingSingleDPP[],unsigned int DPPPerSurface[],double * GlobalDPPCLK,double Dppclk[])1551dda4fb85SAurabindo Pillai void dml32_CalculateDPPCLK(
1552dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces,
1553dda4fb85SAurabindo Pillai double DISPCLKDPPCLKDSCCLKDownSpreading,
1554dda4fb85SAurabindo Pillai double DISPCLKDPPCLKVCOSpeed,
1555dda4fb85SAurabindo Pillai double DPPCLKUsingSingleDPP[],
1556dda4fb85SAurabindo Pillai unsigned int DPPPerSurface[],
1557dda4fb85SAurabindo Pillai
1558dda4fb85SAurabindo Pillai /* output */
1559dda4fb85SAurabindo Pillai double *GlobalDPPCLK,
1560dda4fb85SAurabindo Pillai double Dppclk[])
1561dda4fb85SAurabindo Pillai {
1562dda4fb85SAurabindo Pillai unsigned int k;
1563dda4fb85SAurabindo Pillai *GlobalDPPCLK = 0;
1564dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
1565dda4fb85SAurabindo Pillai Dppclk[k] = DPPCLKUsingSingleDPP[k] / DPPPerSurface[k] * (1 + DISPCLKDPPCLKDSCCLKDownSpreading / 100);
1566dda4fb85SAurabindo Pillai *GlobalDPPCLK = dml_max(*GlobalDPPCLK, Dppclk[k]);
1567dda4fb85SAurabindo Pillai }
1568dda4fb85SAurabindo Pillai *GlobalDPPCLK = dml32_RoundToDFSGranularity(*GlobalDPPCLK, 1, DISPCLKDPPCLKVCOSpeed);
1569dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k)
1570dda4fb85SAurabindo Pillai Dppclk[k] = *GlobalDPPCLK / 255 * dml_ceil(Dppclk[k] * 255.0 / *GlobalDPPCLK, 1.0);
1571dda4fb85SAurabindo Pillai }
1572dda4fb85SAurabindo Pillai
dml32_TruncToValidBPP(double LinkBitRate,unsigned int Lanes,unsigned int HTotal,unsigned int HActive,double PixelClock,double DesiredBPP,bool DSCEnable,enum output_encoder_class Output,enum output_format_class Format,unsigned int DSCInputBitPerComponent,unsigned int DSCSlices,unsigned int AudioRate,unsigned int AudioLayout,enum odm_combine_mode ODMModeNoDSC,enum odm_combine_mode ODMModeDSC,unsigned int * RequiredSlots)1573dda4fb85SAurabindo Pillai double dml32_TruncToValidBPP(
1574dda4fb85SAurabindo Pillai double LinkBitRate,
1575dda4fb85SAurabindo Pillai unsigned int Lanes,
1576dda4fb85SAurabindo Pillai unsigned int HTotal,
1577dda4fb85SAurabindo Pillai unsigned int HActive,
1578dda4fb85SAurabindo Pillai double PixelClock,
1579dda4fb85SAurabindo Pillai double DesiredBPP,
1580dda4fb85SAurabindo Pillai bool DSCEnable,
1581dda4fb85SAurabindo Pillai enum output_encoder_class Output,
1582dda4fb85SAurabindo Pillai enum output_format_class Format,
1583dda4fb85SAurabindo Pillai unsigned int DSCInputBitPerComponent,
1584dda4fb85SAurabindo Pillai unsigned int DSCSlices,
1585dda4fb85SAurabindo Pillai unsigned int AudioRate,
1586dda4fb85SAurabindo Pillai unsigned int AudioLayout,
1587dda4fb85SAurabindo Pillai enum odm_combine_mode ODMModeNoDSC,
1588dda4fb85SAurabindo Pillai enum odm_combine_mode ODMModeDSC,
1589dda4fb85SAurabindo Pillai /* Output */
1590dda4fb85SAurabindo Pillai unsigned int *RequiredSlots)
1591dda4fb85SAurabindo Pillai {
1592dda4fb85SAurabindo Pillai double MaxLinkBPP;
1593dda4fb85SAurabindo Pillai unsigned int MinDSCBPP;
1594dda4fb85SAurabindo Pillai double MaxDSCBPP;
1595dda4fb85SAurabindo Pillai unsigned int NonDSCBPP0;
1596dda4fb85SAurabindo Pillai unsigned int NonDSCBPP1;
1597dda4fb85SAurabindo Pillai unsigned int NonDSCBPP2;
1598dda4fb85SAurabindo Pillai
1599dda4fb85SAurabindo Pillai if (Format == dm_420) {
1600dda4fb85SAurabindo Pillai NonDSCBPP0 = 12;
1601dda4fb85SAurabindo Pillai NonDSCBPP1 = 15;
1602dda4fb85SAurabindo Pillai NonDSCBPP2 = 18;
1603dda4fb85SAurabindo Pillai MinDSCBPP = 6;
1604dda4fb85SAurabindo Pillai MaxDSCBPP = 1.5 * DSCInputBitPerComponent - 1 / 16;
1605dda4fb85SAurabindo Pillai } else if (Format == dm_444) {
160692d1fe59SDillon Varone NonDSCBPP0 = 24;
160792d1fe59SDillon Varone NonDSCBPP1 = 30;
160892d1fe59SDillon Varone NonDSCBPP2 = 36;
1609dda4fb85SAurabindo Pillai MinDSCBPP = 8;
1610dda4fb85SAurabindo Pillai MaxDSCBPP = 3 * DSCInputBitPerComponent - 1.0 / 16;
1611dda4fb85SAurabindo Pillai } else {
1612dda4fb85SAurabindo Pillai if (Output == dm_hdmi) {
1613dda4fb85SAurabindo Pillai NonDSCBPP0 = 24;
1614dda4fb85SAurabindo Pillai NonDSCBPP1 = 24;
1615dda4fb85SAurabindo Pillai NonDSCBPP2 = 24;
1616dda4fb85SAurabindo Pillai } else {
1617dda4fb85SAurabindo Pillai NonDSCBPP0 = 16;
1618dda4fb85SAurabindo Pillai NonDSCBPP1 = 20;
1619dda4fb85SAurabindo Pillai NonDSCBPP2 = 24;
1620dda4fb85SAurabindo Pillai }
1621dda4fb85SAurabindo Pillai if (Format == dm_n422) {
1622dda4fb85SAurabindo Pillai MinDSCBPP = 7;
1623dda4fb85SAurabindo Pillai MaxDSCBPP = 2 * DSCInputBitPerComponent - 1.0 / 16.0;
1624dda4fb85SAurabindo Pillai } else {
1625dda4fb85SAurabindo Pillai MinDSCBPP = 8;
1626dda4fb85SAurabindo Pillai MaxDSCBPP = 3 * DSCInputBitPerComponent - 1.0 / 16.0;
1627dda4fb85SAurabindo Pillai }
1628dda4fb85SAurabindo Pillai }
1629dda4fb85SAurabindo Pillai if (Output == dm_dp2p0) {
1630dda4fb85SAurabindo Pillai MaxLinkBPP = LinkBitRate * Lanes / PixelClock * 128 / 132 * 383 / 384 * 65536 / 65540;
1631dda4fb85SAurabindo Pillai } else if (DSCEnable && Output == dm_dp) {
1632dda4fb85SAurabindo Pillai MaxLinkBPP = LinkBitRate / 10 * 8 * Lanes / PixelClock * (1 - 2.4 / 100);
1633dda4fb85SAurabindo Pillai } else {
1634dda4fb85SAurabindo Pillai MaxLinkBPP = LinkBitRate / 10 * 8 * Lanes / PixelClock;
1635dda4fb85SAurabindo Pillai }
1636dda4fb85SAurabindo Pillai
1637dda4fb85SAurabindo Pillai if (DSCEnable) {
1638dda4fb85SAurabindo Pillai if (ODMModeDSC == dm_odm_combine_mode_4to1)
1639dda4fb85SAurabindo Pillai MaxLinkBPP = dml_min(MaxLinkBPP, 16);
1640dda4fb85SAurabindo Pillai else if (ODMModeDSC == dm_odm_combine_mode_2to1)
1641dda4fb85SAurabindo Pillai MaxLinkBPP = dml_min(MaxLinkBPP, 32);
1642dda4fb85SAurabindo Pillai else if (ODMModeDSC == dm_odm_split_mode_1to2)
1643dda4fb85SAurabindo Pillai MaxLinkBPP = 2 * MaxLinkBPP;
1644dda4fb85SAurabindo Pillai } else {
1645dda4fb85SAurabindo Pillai if (ODMModeNoDSC == dm_odm_combine_mode_4to1)
1646dda4fb85SAurabindo Pillai MaxLinkBPP = dml_min(MaxLinkBPP, 16);
1647dda4fb85SAurabindo Pillai else if (ODMModeNoDSC == dm_odm_combine_mode_2to1)
1648dda4fb85SAurabindo Pillai MaxLinkBPP = dml_min(MaxLinkBPP, 32);
1649dda4fb85SAurabindo Pillai else if (ODMModeNoDSC == dm_odm_split_mode_1to2)
1650dda4fb85SAurabindo Pillai MaxLinkBPP = 2 * MaxLinkBPP;
1651dda4fb85SAurabindo Pillai }
1652dda4fb85SAurabindo Pillai
1653dda4fb85SAurabindo Pillai if (DesiredBPP == 0) {
1654dda4fb85SAurabindo Pillai if (DSCEnable) {
1655dda4fb85SAurabindo Pillai if (MaxLinkBPP < MinDSCBPP)
1656dda4fb85SAurabindo Pillai return BPP_INVALID;
1657dda4fb85SAurabindo Pillai else if (MaxLinkBPP >= MaxDSCBPP)
1658dda4fb85SAurabindo Pillai return MaxDSCBPP;
1659dda4fb85SAurabindo Pillai else
1660dda4fb85SAurabindo Pillai return dml_floor(16.0 * MaxLinkBPP, 1.0) / 16.0;
1661dda4fb85SAurabindo Pillai } else {
166292d1fe59SDillon Varone if (MaxLinkBPP >= NonDSCBPP2)
1663dda4fb85SAurabindo Pillai return NonDSCBPP2;
1664dda4fb85SAurabindo Pillai else if (MaxLinkBPP >= NonDSCBPP1)
1665dda4fb85SAurabindo Pillai return NonDSCBPP1;
1666dda4fb85SAurabindo Pillai else if (MaxLinkBPP >= NonDSCBPP0)
1667dda4fb85SAurabindo Pillai return 16.0;
1668dda4fb85SAurabindo Pillai else
1669dda4fb85SAurabindo Pillai return BPP_INVALID;
1670dda4fb85SAurabindo Pillai }
1671dda4fb85SAurabindo Pillai } else {
1672dda4fb85SAurabindo Pillai if (!((DSCEnable == false && (DesiredBPP == NonDSCBPP2 || DesiredBPP == NonDSCBPP1 ||
167392d1fe59SDillon Varone DesiredBPP <= NonDSCBPP0)) ||
1674dda4fb85SAurabindo Pillai (DSCEnable && DesiredBPP >= MinDSCBPP && DesiredBPP <= MaxDSCBPP)))
1675dda4fb85SAurabindo Pillai return BPP_INVALID;
1676dda4fb85SAurabindo Pillai else
1677dda4fb85SAurabindo Pillai return DesiredBPP;
1678dda4fb85SAurabindo Pillai }
1679dda4fb85SAurabindo Pillai
1680dda4fb85SAurabindo Pillai *RequiredSlots = dml_ceil(DesiredBPP / MaxLinkBPP * 64, 1);
1681dda4fb85SAurabindo Pillai
1682dda4fb85SAurabindo Pillai return BPP_INVALID;
1683dda4fb85SAurabindo Pillai } // TruncToValidBPP
1684dda4fb85SAurabindo Pillai
dml32_RequiredDTBCLK(bool DSCEnable,double PixelClock,enum output_format_class OutputFormat,double OutputBpp,unsigned int DSCSlices,unsigned int HTotal,unsigned int HActive,unsigned int AudioRate,unsigned int AudioLayout)1685dda4fb85SAurabindo Pillai double dml32_RequiredDTBCLK(
1686dda4fb85SAurabindo Pillai bool DSCEnable,
1687dda4fb85SAurabindo Pillai double PixelClock,
1688dda4fb85SAurabindo Pillai enum output_format_class OutputFormat,
1689dda4fb85SAurabindo Pillai double OutputBpp,
1690dda4fb85SAurabindo Pillai unsigned int DSCSlices,
1691dda4fb85SAurabindo Pillai unsigned int HTotal,
1692dda4fb85SAurabindo Pillai unsigned int HActive,
1693dda4fb85SAurabindo Pillai unsigned int AudioRate,
1694dda4fb85SAurabindo Pillai unsigned int AudioLayout)
1695dda4fb85SAurabindo Pillai {
1696074293ddSRodrigo Siqueira double PixelWordRate;
1697074293ddSRodrigo Siqueira double HCActive;
1698074293ddSRodrigo Siqueira double HCBlank;
1699074293ddSRodrigo Siqueira double AverageTribyteRate;
1700074293ddSRodrigo Siqueira double HActiveTribyteRate;
1701dda4fb85SAurabindo Pillai
1702dda4fb85SAurabindo Pillai if (DSCEnable != true)
1703dda4fb85SAurabindo Pillai return dml_max(PixelClock / 4.0 * OutputBpp / 24.0, 25.0);
1704dda4fb85SAurabindo Pillai
1705074293ddSRodrigo Siqueira PixelWordRate = PixelClock / (OutputFormat == dm_444 ? 1 : 2);
1706074293ddSRodrigo Siqueira HCActive = dml_ceil(DSCSlices * dml_ceil(OutputBpp *
1707074293ddSRodrigo Siqueira dml_ceil(HActive / DSCSlices, 1) / 8.0, 1) / 3.0, 1);
1708074293ddSRodrigo Siqueira HCBlank = 64 + 32 *
1709074293ddSRodrigo Siqueira dml_ceil(AudioRate * (AudioLayout == 1 ? 1 : 0.25) * HTotal / (PixelClock * 1000), 1);
1710074293ddSRodrigo Siqueira AverageTribyteRate = PixelWordRate * (HCActive + HCBlank) / HTotal;
1711074293ddSRodrigo Siqueira HActiveTribyteRate = PixelWordRate * HCActive / HActive;
1712dda4fb85SAurabindo Pillai return dml_max4(PixelWordRate / 4.0, AverageTribyteRate / 4.0, HActiveTribyteRate / 4.0, 25.0) * 1.002;
1713dda4fb85SAurabindo Pillai }
1714dda4fb85SAurabindo Pillai
dml32_DSCDelayRequirement(bool DSCEnabled,enum odm_combine_mode ODMMode,unsigned int DSCInputBitPerComponent,double OutputBpp,unsigned int HActive,unsigned int HTotal,unsigned int NumberOfDSCSlices,enum output_format_class OutputFormat,enum output_encoder_class Output,double PixelClock,double PixelClockBackEnd,double dsc_delay_factor_wa)1715dda4fb85SAurabindo Pillai unsigned int dml32_DSCDelayRequirement(bool DSCEnabled,
1716dda4fb85SAurabindo Pillai enum odm_combine_mode ODMMode,
1717dda4fb85SAurabindo Pillai unsigned int DSCInputBitPerComponent,
1718dda4fb85SAurabindo Pillai double OutputBpp,
1719dda4fb85SAurabindo Pillai unsigned int HActive,
1720dda4fb85SAurabindo Pillai unsigned int HTotal,
1721dda4fb85SAurabindo Pillai unsigned int NumberOfDSCSlices,
1722dda4fb85SAurabindo Pillai enum output_format_class OutputFormat,
1723dda4fb85SAurabindo Pillai enum output_encoder_class Output,
1724dda4fb85SAurabindo Pillai double PixelClock,
1725f30508e9SGeorge Shen double PixelClockBackEnd,
1726f30508e9SGeorge Shen double dsc_delay_factor_wa)
1727dda4fb85SAurabindo Pillai {
1728dda4fb85SAurabindo Pillai unsigned int DSCDelayRequirement_val;
1729dda4fb85SAurabindo Pillai
1730dda4fb85SAurabindo Pillai if (DSCEnabled == true && OutputBpp != 0) {
1731dda4fb85SAurabindo Pillai if (ODMMode == dm_odm_combine_mode_4to1) {
1732dda4fb85SAurabindo Pillai DSCDelayRequirement_val = 4 * (dml32_dscceComputeDelay(DSCInputBitPerComponent, OutputBpp,
1733dda4fb85SAurabindo Pillai dml_ceil(HActive / NumberOfDSCSlices, 1), NumberOfDSCSlices / 4,
1734dda4fb85SAurabindo Pillai OutputFormat, Output) + dml32_dscComputeDelay(OutputFormat, Output));
1735dda4fb85SAurabindo Pillai } else if (ODMMode == dm_odm_combine_mode_2to1) {
1736dda4fb85SAurabindo Pillai DSCDelayRequirement_val = 2 * (dml32_dscceComputeDelay(DSCInputBitPerComponent, OutputBpp,
1737dda4fb85SAurabindo Pillai dml_ceil(HActive / NumberOfDSCSlices, 1), NumberOfDSCSlices / 2,
1738dda4fb85SAurabindo Pillai OutputFormat, Output) + dml32_dscComputeDelay(OutputFormat, Output));
1739dda4fb85SAurabindo Pillai } else {
1740dda4fb85SAurabindo Pillai DSCDelayRequirement_val = dml32_dscceComputeDelay(DSCInputBitPerComponent, OutputBpp,
1741dda4fb85SAurabindo Pillai dml_ceil(HActive / NumberOfDSCSlices, 1), NumberOfDSCSlices,
1742dda4fb85SAurabindo Pillai OutputFormat, Output) + dml32_dscComputeDelay(OutputFormat, Output);
1743dda4fb85SAurabindo Pillai }
1744dda4fb85SAurabindo Pillai
1745dda4fb85SAurabindo Pillai DSCDelayRequirement_val = DSCDelayRequirement_val + (HTotal - HActive) *
174686975c34SGeorge Shen dml_ceil((double)DSCDelayRequirement_val / HActive, 1);
1747dda4fb85SAurabindo Pillai
1748dda4fb85SAurabindo Pillai DSCDelayRequirement_val = DSCDelayRequirement_val * PixelClock / PixelClockBackEnd;
1749dda4fb85SAurabindo Pillai
1750dda4fb85SAurabindo Pillai } else {
1751dda4fb85SAurabindo Pillai DSCDelayRequirement_val = 0;
1752dda4fb85SAurabindo Pillai }
1753dda4fb85SAurabindo Pillai
1754dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
1755dda4fb85SAurabindo Pillai dml_print("DML::%s: DSCEnabled = %d\n", __func__, DSCEnabled);
1756dda4fb85SAurabindo Pillai dml_print("DML::%s: OutputBpp = %f\n", __func__, OutputBpp);
1757dda4fb85SAurabindo Pillai dml_print("DML::%s: HActive = %d\n", __func__, HActive);
1758dda4fb85SAurabindo Pillai dml_print("DML::%s: OutputFormat = %d\n", __func__, OutputFormat);
1759dda4fb85SAurabindo Pillai dml_print("DML::%s: DSCInputBitPerComponent = %d\n", __func__, DSCInputBitPerComponent);
1760dda4fb85SAurabindo Pillai dml_print("DML::%s: NumberOfDSCSlices = %d\n", __func__, NumberOfDSCSlices);
1761dda4fb85SAurabindo Pillai dml_print("DML::%s: DSCDelayRequirement_val = %d\n", __func__, DSCDelayRequirement_val);
1762dda4fb85SAurabindo Pillai #endif
1763dda4fb85SAurabindo Pillai
1764f30508e9SGeorge Shen return dml_ceil(DSCDelayRequirement_val * dsc_delay_factor_wa, 1);
1765dda4fb85SAurabindo Pillai }
1766dda4fb85SAurabindo Pillai
dml32_CalculateSurfaceSizeInMall(unsigned int NumberOfActiveSurfaces,unsigned int MALLAllocatedForDCN,enum dm_use_mall_for_static_screen_mode UseMALLForStaticScreen[],enum dm_use_mall_for_pstate_change_mode UsesMALLForPStateChange[],bool DCCEnable[],bool ViewportStationary[],unsigned int ViewportXStartY[],unsigned int ViewportYStartY[],unsigned int ViewportXStartC[],unsigned int ViewportYStartC[],unsigned int ViewportWidthY[],unsigned int ViewportHeightY[],unsigned int BytesPerPixelY[],unsigned int ViewportWidthC[],unsigned int ViewportHeightC[],unsigned int BytesPerPixelC[],unsigned int SurfaceWidthY[],unsigned int SurfaceWidthC[],unsigned int SurfaceHeightY[],unsigned int SurfaceHeightC[],unsigned int Read256BytesBlockWidthY[],unsigned int Read256BytesBlockWidthC[],unsigned int Read256BytesBlockHeightY[],unsigned int Read256BytesBlockHeightC[],unsigned int ReadBlockWidthY[],unsigned int ReadBlockWidthC[],unsigned int ReadBlockHeightY[],unsigned int ReadBlockHeightC[],unsigned int DCCMetaPitchY[],unsigned int DCCMetaPitchC[],unsigned int SurfaceSizeInMALL[],bool * ExceededMALLSize)1767dda4fb85SAurabindo Pillai void dml32_CalculateSurfaceSizeInMall(
1768dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces,
1769dda4fb85SAurabindo Pillai unsigned int MALLAllocatedForDCN,
1770dda4fb85SAurabindo Pillai enum dm_use_mall_for_static_screen_mode UseMALLForStaticScreen[],
1771a21005e4SDillon Varone enum dm_use_mall_for_pstate_change_mode UsesMALLForPStateChange[],
1772dda4fb85SAurabindo Pillai bool DCCEnable[],
1773dda4fb85SAurabindo Pillai bool ViewportStationary[],
1774dda4fb85SAurabindo Pillai unsigned int ViewportXStartY[],
1775dda4fb85SAurabindo Pillai unsigned int ViewportYStartY[],
1776dda4fb85SAurabindo Pillai unsigned int ViewportXStartC[],
1777dda4fb85SAurabindo Pillai unsigned int ViewportYStartC[],
1778dda4fb85SAurabindo Pillai unsigned int ViewportWidthY[],
1779dda4fb85SAurabindo Pillai unsigned int ViewportHeightY[],
1780dda4fb85SAurabindo Pillai unsigned int BytesPerPixelY[],
1781dda4fb85SAurabindo Pillai unsigned int ViewportWidthC[],
1782dda4fb85SAurabindo Pillai unsigned int ViewportHeightC[],
1783dda4fb85SAurabindo Pillai unsigned int BytesPerPixelC[],
1784dda4fb85SAurabindo Pillai unsigned int SurfaceWidthY[],
1785dda4fb85SAurabindo Pillai unsigned int SurfaceWidthC[],
1786dda4fb85SAurabindo Pillai unsigned int SurfaceHeightY[],
1787dda4fb85SAurabindo Pillai unsigned int SurfaceHeightC[],
1788dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockWidthY[],
1789dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockWidthC[],
1790dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockHeightY[],
1791dda4fb85SAurabindo Pillai unsigned int Read256BytesBlockHeightC[],
1792dda4fb85SAurabindo Pillai unsigned int ReadBlockWidthY[],
1793dda4fb85SAurabindo Pillai unsigned int ReadBlockWidthC[],
1794dda4fb85SAurabindo Pillai unsigned int ReadBlockHeightY[],
1795dda4fb85SAurabindo Pillai unsigned int ReadBlockHeightC[],
179695c454caSDillon Varone unsigned int DCCMetaPitchY[],
179795c454caSDillon Varone unsigned int DCCMetaPitchC[],
1798dda4fb85SAurabindo Pillai
1799dda4fb85SAurabindo Pillai /* Output */
1800dda4fb85SAurabindo Pillai unsigned int SurfaceSizeInMALL[],
1801dda4fb85SAurabindo Pillai bool *ExceededMALLSize)
1802dda4fb85SAurabindo Pillai {
1803dda4fb85SAurabindo Pillai unsigned int k;
1804a21005e4SDillon Varone unsigned int TotalSurfaceSizeInMALLForSS = 0;
1805a21005e4SDillon Varone unsigned int TotalSurfaceSizeInMALLForSubVP = 0;
1806a21005e4SDillon Varone unsigned int MALLAllocatedForDCNInBytes = MALLAllocatedForDCN * 1024 * 1024;
1807dda4fb85SAurabindo Pillai
1808dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
1809dda4fb85SAurabindo Pillai if (ViewportStationary[k]) {
1810dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] = dml_min(dml_ceil(SurfaceWidthY[k], ReadBlockWidthY[k]),
1811dda4fb85SAurabindo Pillai dml_floor(ViewportXStartY[k] + ViewportWidthY[k] + ReadBlockWidthY[k] - 1,
1812dda4fb85SAurabindo Pillai ReadBlockWidthY[k]) - dml_floor(ViewportXStartY[k],
1813dda4fb85SAurabindo Pillai ReadBlockWidthY[k])) * dml_min(dml_ceil(SurfaceHeightY[k],
1814dda4fb85SAurabindo Pillai ReadBlockHeightY[k]), dml_floor(ViewportYStartY[k] +
1815dda4fb85SAurabindo Pillai ViewportHeightY[k] + ReadBlockHeightY[k] - 1, ReadBlockHeightY[k]) -
1816dda4fb85SAurabindo Pillai dml_floor(ViewportYStartY[k], ReadBlockHeightY[k])) * BytesPerPixelY[k];
1817dda4fb85SAurabindo Pillai
1818dda4fb85SAurabindo Pillai if (ReadBlockWidthC[k] > 0) {
1819dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] = SurfaceSizeInMALL[k] +
1820dda4fb85SAurabindo Pillai dml_min(dml_ceil(SurfaceWidthC[k], ReadBlockWidthC[k]),
1821dda4fb85SAurabindo Pillai dml_floor(ViewportXStartC[k] + ViewportWidthC[k] +
1822dda4fb85SAurabindo Pillai ReadBlockWidthC[k] - 1, ReadBlockWidthC[k]) -
1823dda4fb85SAurabindo Pillai dml_floor(ViewportXStartC[k], ReadBlockWidthC[k])) *
1824dda4fb85SAurabindo Pillai dml_min(dml_ceil(SurfaceHeightC[k], ReadBlockHeightC[k]),
1825dda4fb85SAurabindo Pillai dml_floor(ViewportYStartC[k] + ViewportHeightC[k] +
1826dda4fb85SAurabindo Pillai ReadBlockHeightC[k] - 1, ReadBlockHeightC[k]) -
1827dda4fb85SAurabindo Pillai dml_floor(ViewportYStartC[k], ReadBlockHeightC[k])) *
1828dda4fb85SAurabindo Pillai BytesPerPixelC[k];
1829dda4fb85SAurabindo Pillai }
1830dda4fb85SAurabindo Pillai if (DCCEnable[k] == true) {
1831dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] = SurfaceSizeInMALL[k] +
1832b5c397c8SSaaem Rizvi (dml_min(dml_ceil(DCCMetaPitchY[k], 8 * Read256BytesBlockWidthY[k]),
1833dda4fb85SAurabindo Pillai dml_floor(ViewportXStartY[k] + ViewportWidthY[k] + 8 *
1834dda4fb85SAurabindo Pillai Read256BytesBlockWidthY[k] - 1, 8 * Read256BytesBlockWidthY[k])
1835dda4fb85SAurabindo Pillai - dml_floor(ViewportXStartY[k], 8 * Read256BytesBlockWidthY[k]))
1836dda4fb85SAurabindo Pillai * dml_min(dml_ceil(SurfaceHeightY[k], 8 *
1837dda4fb85SAurabindo Pillai Read256BytesBlockHeightY[k]), dml_floor(ViewportYStartY[k] +
1838dda4fb85SAurabindo Pillai ViewportHeightY[k] + 8 * Read256BytesBlockHeightY[k] - 1, 8 *
1839b5c397c8SSaaem Rizvi Read256BytesBlockHeightY[k]) - dml_floor(ViewportYStartY[k], 8 *
1840b5c397c8SSaaem Rizvi Read256BytesBlockHeightY[k])) * BytesPerPixelY[k] / 256) + (64 * 1024);
1841dda4fb85SAurabindo Pillai if (Read256BytesBlockWidthC[k] > 0) {
1842dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] = SurfaceSizeInMALL[k] +
184395c454caSDillon Varone dml_min(dml_ceil(DCCMetaPitchC[k], 8 *
1844dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k]),
1845dda4fb85SAurabindo Pillai dml_floor(ViewportXStartC[k] + ViewportWidthC[k] + 8
1846dda4fb85SAurabindo Pillai * Read256BytesBlockWidthC[k] - 1, 8 *
1847dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k]) -
1848dda4fb85SAurabindo Pillai dml_floor(ViewportXStartC[k], 8 *
1849dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k])) *
1850dda4fb85SAurabindo Pillai dml_min(dml_ceil(SurfaceHeightC[k], 8 *
1851dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k]),
1852dda4fb85SAurabindo Pillai dml_floor(ViewportYStartC[k] + ViewportHeightC[k] +
1853dda4fb85SAurabindo Pillai 8 * Read256BytesBlockHeightC[k] - 1, 8 *
1854dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k]) -
1855dda4fb85SAurabindo Pillai dml_floor(ViewportYStartC[k], 8 *
1856dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k])) *
1857dda4fb85SAurabindo Pillai BytesPerPixelC[k] / 256;
1858dda4fb85SAurabindo Pillai }
1859dda4fb85SAurabindo Pillai }
1860dda4fb85SAurabindo Pillai } else {
1861dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] = dml_ceil(dml_min(SurfaceWidthY[k], ViewportWidthY[k] +
1862dda4fb85SAurabindo Pillai ReadBlockWidthY[k] - 1), ReadBlockWidthY[k]) *
1863dda4fb85SAurabindo Pillai dml_ceil(dml_min(SurfaceHeightY[k], ViewportHeightY[k] +
1864dda4fb85SAurabindo Pillai ReadBlockHeightY[k] - 1), ReadBlockHeightY[k]) *
1865dda4fb85SAurabindo Pillai BytesPerPixelY[k];
1866dda4fb85SAurabindo Pillai if (ReadBlockWidthC[k] > 0) {
1867dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] = SurfaceSizeInMALL[k] +
1868dda4fb85SAurabindo Pillai dml_ceil(dml_min(SurfaceWidthC[k], ViewportWidthC[k] +
1869dda4fb85SAurabindo Pillai ReadBlockWidthC[k] - 1), ReadBlockWidthC[k]) *
1870dda4fb85SAurabindo Pillai dml_ceil(dml_min(SurfaceHeightC[k], ViewportHeightC[k] +
1871dda4fb85SAurabindo Pillai ReadBlockHeightC[k] - 1), ReadBlockHeightC[k]) *
1872dda4fb85SAurabindo Pillai BytesPerPixelC[k];
1873dda4fb85SAurabindo Pillai }
1874dda4fb85SAurabindo Pillai if (DCCEnable[k] == true) {
1875dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] = SurfaceSizeInMALL[k] +
1876b5c397c8SSaaem Rizvi (dml_ceil(dml_min(DCCMetaPitchY[k], ViewportWidthY[k] + 8 *
1877dda4fb85SAurabindo Pillai Read256BytesBlockWidthY[k] - 1), 8 *
1878dda4fb85SAurabindo Pillai Read256BytesBlockWidthY[k]) *
1879dda4fb85SAurabindo Pillai dml_ceil(dml_min(SurfaceHeightY[k], ViewportHeightY[k] + 8 *
1880dda4fb85SAurabindo Pillai Read256BytesBlockHeightY[k] - 1), 8 *
1881b5c397c8SSaaem Rizvi Read256BytesBlockHeightY[k]) * BytesPerPixelY[k] / 256) + (64 * 1024);
1882dda4fb85SAurabindo Pillai
1883dda4fb85SAurabindo Pillai if (Read256BytesBlockWidthC[k] > 0) {
1884dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] = SurfaceSizeInMALL[k] +
188595c454caSDillon Varone dml_ceil(dml_min(DCCMetaPitchC[k], ViewportWidthC[k] + 8 *
1886dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k] - 1), 8 *
1887dda4fb85SAurabindo Pillai Read256BytesBlockWidthC[k]) *
1888dda4fb85SAurabindo Pillai dml_ceil(dml_min(SurfaceHeightC[k], ViewportHeightC[k] + 8 *
1889dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k] - 1), 8 *
1890dda4fb85SAurabindo Pillai Read256BytesBlockHeightC[k]) *
1891dda4fb85SAurabindo Pillai BytesPerPixelC[k] / 256;
1892dda4fb85SAurabindo Pillai }
1893dda4fb85SAurabindo Pillai }
1894dda4fb85SAurabindo Pillai }
1895dda4fb85SAurabindo Pillai }
1896dda4fb85SAurabindo Pillai
1897dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
1898a21005e4SDillon Varone /* SS and Subvp counted separate as they are never used at the same time */
1899a21005e4SDillon Varone if (UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe)
1900a21005e4SDillon Varone TotalSurfaceSizeInMALLForSubVP = TotalSurfaceSizeInMALLForSubVP + SurfaceSizeInMALL[k];
1901a21005e4SDillon Varone else if (UseMALLForStaticScreen[k] == dm_use_mall_static_screen_enable)
1902a21005e4SDillon Varone TotalSurfaceSizeInMALLForSS = TotalSurfaceSizeInMALLForSS + SurfaceSizeInMALL[k];
1903dda4fb85SAurabindo Pillai }
1904a21005e4SDillon Varone *ExceededMALLSize = (TotalSurfaceSizeInMALLForSS > MALLAllocatedForDCNInBytes) ||
1905a21005e4SDillon Varone (TotalSurfaceSizeInMALLForSubVP > MALLAllocatedForDCNInBytes);
1906dda4fb85SAurabindo Pillai } // CalculateSurfaceSizeInMall
1907dda4fb85SAurabindo Pillai
dml32_CalculateVMRowAndSwath(unsigned int NumberOfActiveSurfaces,DmlPipe myPipe[],unsigned int SurfaceSizeInMALL[],unsigned int PTEBufferSizeInRequestsLuma,unsigned int PTEBufferSizeInRequestsChroma,unsigned int DCCMetaBufferSizeBytes,enum dm_use_mall_for_static_screen_mode UseMALLForStaticScreen[],enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange[],unsigned int MALLAllocatedForDCN,double SwathWidthY[],double SwathWidthC[],bool GPUVMEnable,bool HostVMEnable,unsigned int HostVMMaxNonCachedPageTableLevels,unsigned int GPUVMMaxPageTableLevels,unsigned int GPUVMMinPageSizeKBytes[],unsigned int HostVMMinPageSize,bool PTEBufferSizeNotExceeded[],bool DCCMetaBufferSizeNotExceeded[],unsigned int dpte_row_width_luma_ub[],unsigned int dpte_row_width_chroma_ub[],unsigned int dpte_row_height_luma[],unsigned int dpte_row_height_chroma[],unsigned int dpte_row_height_linear_luma[],unsigned int dpte_row_height_linear_chroma[],unsigned int meta_req_width[],unsigned int meta_req_width_chroma[],unsigned int meta_req_height[],unsigned int meta_req_height_chroma[],unsigned int meta_row_width[],unsigned int meta_row_width_chroma[],unsigned int meta_row_height[],unsigned int meta_row_height_chroma[],unsigned int vm_group_bytes[],unsigned int dpte_group_bytes[],unsigned int PixelPTEReqWidthY[],unsigned int PixelPTEReqHeightY[],unsigned int PTERequestSizeY[],unsigned int PixelPTEReqWidthC[],unsigned int PixelPTEReqHeightC[],unsigned int PTERequestSizeC[],unsigned int dpde0_bytes_per_frame_ub_l[],unsigned int meta_pte_bytes_per_frame_ub_l[],unsigned int dpde0_bytes_per_frame_ub_c[],unsigned int meta_pte_bytes_per_frame_ub_c[],double PrefetchSourceLinesY[],double PrefetchSourceLinesC[],double VInitPreFillY[],double VInitPreFillC[],unsigned int MaxNumSwathY[],unsigned int MaxNumSwathC[],double meta_row_bw[],double dpte_row_bw[],double PixelPTEBytesPerRow[],double PDEAndMetaPTEBytesFrame[],double MetaRowByte[],bool use_one_row_for_frame[],bool use_one_row_for_frame_flip[],bool UsesMALLForStaticScreen[],bool PTE_BUFFER_MODE[],unsigned int BIGK_FRAGMENT_SIZE[])1908dda4fb85SAurabindo Pillai void dml32_CalculateVMRowAndSwath(
1909dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces,
1910dda4fb85SAurabindo Pillai DmlPipe myPipe[],
1911dda4fb85SAurabindo Pillai unsigned int SurfaceSizeInMALL[],
1912dda4fb85SAurabindo Pillai unsigned int PTEBufferSizeInRequestsLuma,
1913dda4fb85SAurabindo Pillai unsigned int PTEBufferSizeInRequestsChroma,
1914dda4fb85SAurabindo Pillai unsigned int DCCMetaBufferSizeBytes,
1915dda4fb85SAurabindo Pillai enum dm_use_mall_for_static_screen_mode UseMALLForStaticScreen[],
1916dda4fb85SAurabindo Pillai enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange[],
1917dda4fb85SAurabindo Pillai unsigned int MALLAllocatedForDCN,
1918dda4fb85SAurabindo Pillai double SwathWidthY[],
1919dda4fb85SAurabindo Pillai double SwathWidthC[],
1920dda4fb85SAurabindo Pillai bool GPUVMEnable,
1921dda4fb85SAurabindo Pillai bool HostVMEnable,
1922dda4fb85SAurabindo Pillai unsigned int HostVMMaxNonCachedPageTableLevels,
1923dda4fb85SAurabindo Pillai unsigned int GPUVMMaxPageTableLevels,
1924dda4fb85SAurabindo Pillai unsigned int GPUVMMinPageSizeKBytes[],
1925dda4fb85SAurabindo Pillai unsigned int HostVMMinPageSize,
1926dda4fb85SAurabindo Pillai
1927dda4fb85SAurabindo Pillai /* Output */
1928dda4fb85SAurabindo Pillai bool PTEBufferSizeNotExceeded[],
1929dda4fb85SAurabindo Pillai bool DCCMetaBufferSizeNotExceeded[],
1930dda4fb85SAurabindo Pillai unsigned int dpte_row_width_luma_ub[],
1931dda4fb85SAurabindo Pillai unsigned int dpte_row_width_chroma_ub[],
1932dda4fb85SAurabindo Pillai unsigned int dpte_row_height_luma[],
1933dda4fb85SAurabindo Pillai unsigned int dpte_row_height_chroma[],
1934dda4fb85SAurabindo Pillai unsigned int dpte_row_height_linear_luma[], // VBA_DELTA
1935dda4fb85SAurabindo Pillai unsigned int dpte_row_height_linear_chroma[], // VBA_DELTA
1936dda4fb85SAurabindo Pillai unsigned int meta_req_width[],
1937dda4fb85SAurabindo Pillai unsigned int meta_req_width_chroma[],
1938dda4fb85SAurabindo Pillai unsigned int meta_req_height[],
1939dda4fb85SAurabindo Pillai unsigned int meta_req_height_chroma[],
1940dda4fb85SAurabindo Pillai unsigned int meta_row_width[],
1941dda4fb85SAurabindo Pillai unsigned int meta_row_width_chroma[],
1942dda4fb85SAurabindo Pillai unsigned int meta_row_height[],
1943dda4fb85SAurabindo Pillai unsigned int meta_row_height_chroma[],
1944dda4fb85SAurabindo Pillai unsigned int vm_group_bytes[],
1945dda4fb85SAurabindo Pillai unsigned int dpte_group_bytes[],
1946dda4fb85SAurabindo Pillai unsigned int PixelPTEReqWidthY[],
1947dda4fb85SAurabindo Pillai unsigned int PixelPTEReqHeightY[],
1948dda4fb85SAurabindo Pillai unsigned int PTERequestSizeY[],
1949dda4fb85SAurabindo Pillai unsigned int PixelPTEReqWidthC[],
1950dda4fb85SAurabindo Pillai unsigned int PixelPTEReqHeightC[],
1951dda4fb85SAurabindo Pillai unsigned int PTERequestSizeC[],
1952dda4fb85SAurabindo Pillai unsigned int dpde0_bytes_per_frame_ub_l[],
1953dda4fb85SAurabindo Pillai unsigned int meta_pte_bytes_per_frame_ub_l[],
1954dda4fb85SAurabindo Pillai unsigned int dpde0_bytes_per_frame_ub_c[],
1955dda4fb85SAurabindo Pillai unsigned int meta_pte_bytes_per_frame_ub_c[],
1956dda4fb85SAurabindo Pillai double PrefetchSourceLinesY[],
1957dda4fb85SAurabindo Pillai double PrefetchSourceLinesC[],
1958dda4fb85SAurabindo Pillai double VInitPreFillY[],
1959dda4fb85SAurabindo Pillai double VInitPreFillC[],
1960dda4fb85SAurabindo Pillai unsigned int MaxNumSwathY[],
1961dda4fb85SAurabindo Pillai unsigned int MaxNumSwathC[],
1962dda4fb85SAurabindo Pillai double meta_row_bw[],
1963dda4fb85SAurabindo Pillai double dpte_row_bw[],
1964dda4fb85SAurabindo Pillai double PixelPTEBytesPerRow[],
1965dda4fb85SAurabindo Pillai double PDEAndMetaPTEBytesFrame[],
1966dda4fb85SAurabindo Pillai double MetaRowByte[],
1967dda4fb85SAurabindo Pillai bool use_one_row_for_frame[],
1968dda4fb85SAurabindo Pillai bool use_one_row_for_frame_flip[],
1969dda4fb85SAurabindo Pillai bool UsesMALLForStaticScreen[],
1970dda4fb85SAurabindo Pillai bool PTE_BUFFER_MODE[],
1971dda4fb85SAurabindo Pillai unsigned int BIGK_FRAGMENT_SIZE[])
1972dda4fb85SAurabindo Pillai {
1973dda4fb85SAurabindo Pillai unsigned int k;
1974968d4098SRodrigo Siqueira unsigned int PTEBufferSizeInRequestsForLuma[DC__NUM_DPP__MAX];
1975968d4098SRodrigo Siqueira unsigned int PTEBufferSizeInRequestsForChroma[DC__NUM_DPP__MAX];
1976968d4098SRodrigo Siqueira unsigned int PDEAndMetaPTEBytesFrameY;
1977968d4098SRodrigo Siqueira unsigned int PDEAndMetaPTEBytesFrameC;
1978968d4098SRodrigo Siqueira unsigned int MetaRowByteY[DC__NUM_DPP__MAX];
1979968d4098SRodrigo Siqueira unsigned int MetaRowByteC[DC__NUM_DPP__MAX];
1980968d4098SRodrigo Siqueira unsigned int PixelPTEBytesPerRowY[DC__NUM_DPP__MAX];
1981968d4098SRodrigo Siqueira unsigned int PixelPTEBytesPerRowC[DC__NUM_DPP__MAX];
1982968d4098SRodrigo Siqueira unsigned int PixelPTEBytesPerRowY_one_row_per_frame[DC__NUM_DPP__MAX];
1983968d4098SRodrigo Siqueira unsigned int PixelPTEBytesPerRowC_one_row_per_frame[DC__NUM_DPP__MAX];
1984968d4098SRodrigo Siqueira unsigned int dpte_row_width_luma_ub_one_row_per_frame[DC__NUM_DPP__MAX];
1985968d4098SRodrigo Siqueira unsigned int dpte_row_height_luma_one_row_per_frame[DC__NUM_DPP__MAX];
1986968d4098SRodrigo Siqueira unsigned int dpte_row_width_chroma_ub_one_row_per_frame[DC__NUM_DPP__MAX];
1987968d4098SRodrigo Siqueira unsigned int dpte_row_height_chroma_one_row_per_frame[DC__NUM_DPP__MAX];
1988968d4098SRodrigo Siqueira bool one_row_per_frame_fits_in_buffer[DC__NUM_DPP__MAX];
1989dda4fb85SAurabindo Pillai
1990dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
1991dda4fb85SAurabindo Pillai if (HostVMEnable == true) {
1992dda4fb85SAurabindo Pillai vm_group_bytes[k] = 512;
1993dda4fb85SAurabindo Pillai dpte_group_bytes[k] = 512;
1994dda4fb85SAurabindo Pillai } else if (GPUVMEnable == true) {
1995dda4fb85SAurabindo Pillai vm_group_bytes[k] = 2048;
1996dda4fb85SAurabindo Pillai if (GPUVMMinPageSizeKBytes[k] >= 64 && IsVertical(myPipe[k].SourceRotation))
1997dda4fb85SAurabindo Pillai dpte_group_bytes[k] = 512;
1998dda4fb85SAurabindo Pillai else
1999dda4fb85SAurabindo Pillai dpte_group_bytes[k] = 2048;
2000dda4fb85SAurabindo Pillai } else {
2001dda4fb85SAurabindo Pillai vm_group_bytes[k] = 0;
2002dda4fb85SAurabindo Pillai dpte_group_bytes[k] = 0;
2003dda4fb85SAurabindo Pillai }
2004dda4fb85SAurabindo Pillai
2005dda4fb85SAurabindo Pillai if (myPipe[k].SourcePixelFormat == dm_420_8 || myPipe[k].SourcePixelFormat == dm_420_10 ||
2006dda4fb85SAurabindo Pillai myPipe[k].SourcePixelFormat == dm_420_12 ||
2007dda4fb85SAurabindo Pillai myPipe[k].SourcePixelFormat == dm_rgbe_alpha) {
2008dda4fb85SAurabindo Pillai if ((myPipe[k].SourcePixelFormat == dm_420_10 || myPipe[k].SourcePixelFormat == dm_420_12) &&
2009dda4fb85SAurabindo Pillai !IsVertical(myPipe[k].SourceRotation)) {
2010968d4098SRodrigo Siqueira PTEBufferSizeInRequestsForLuma[k] =
2011dda4fb85SAurabindo Pillai (PTEBufferSizeInRequestsLuma + PTEBufferSizeInRequestsChroma) / 2;
2012968d4098SRodrigo Siqueira PTEBufferSizeInRequestsForChroma[k] = PTEBufferSizeInRequestsForLuma[k];
2013dda4fb85SAurabindo Pillai } else {
2014968d4098SRodrigo Siqueira PTEBufferSizeInRequestsForLuma[k] = PTEBufferSizeInRequestsLuma;
2015968d4098SRodrigo Siqueira PTEBufferSizeInRequestsForChroma[k] = PTEBufferSizeInRequestsChroma;
2016dda4fb85SAurabindo Pillai }
2017dda4fb85SAurabindo Pillai
2018968d4098SRodrigo Siqueira PDEAndMetaPTEBytesFrameC = dml32_CalculateVMAndRowBytes(
2019dda4fb85SAurabindo Pillai myPipe[k].ViewportStationary,
2020dda4fb85SAurabindo Pillai myPipe[k].DCCEnable,
2021dda4fb85SAurabindo Pillai myPipe[k].DPPPerSurface,
2022dda4fb85SAurabindo Pillai myPipe[k].BlockHeight256BytesC,
2023dda4fb85SAurabindo Pillai myPipe[k].BlockWidth256BytesC,
2024dda4fb85SAurabindo Pillai myPipe[k].SourcePixelFormat,
2025dda4fb85SAurabindo Pillai myPipe[k].SurfaceTiling,
2026dda4fb85SAurabindo Pillai myPipe[k].BytePerPixelC,
2027dda4fb85SAurabindo Pillai myPipe[k].SourceRotation,
2028dda4fb85SAurabindo Pillai SwathWidthC[k],
2029dda4fb85SAurabindo Pillai myPipe[k].ViewportHeightChroma,
2030dda4fb85SAurabindo Pillai myPipe[k].ViewportXStartC,
2031dda4fb85SAurabindo Pillai myPipe[k].ViewportYStartC,
2032dda4fb85SAurabindo Pillai GPUVMEnable,
2033dda4fb85SAurabindo Pillai HostVMEnable,
2034dda4fb85SAurabindo Pillai HostVMMaxNonCachedPageTableLevels,
2035dda4fb85SAurabindo Pillai GPUVMMaxPageTableLevels,
2036dda4fb85SAurabindo Pillai GPUVMMinPageSizeKBytes[k],
2037dda4fb85SAurabindo Pillai HostVMMinPageSize,
2038968d4098SRodrigo Siqueira PTEBufferSizeInRequestsForChroma[k],
2039dda4fb85SAurabindo Pillai myPipe[k].PitchC,
2040dda4fb85SAurabindo Pillai myPipe[k].DCCMetaPitchC,
2041dda4fb85SAurabindo Pillai myPipe[k].BlockWidthC,
2042dda4fb85SAurabindo Pillai myPipe[k].BlockHeightC,
2043dda4fb85SAurabindo Pillai
2044dda4fb85SAurabindo Pillai /* Output */
2045968d4098SRodrigo Siqueira &MetaRowByteC[k],
2046968d4098SRodrigo Siqueira &PixelPTEBytesPerRowC[k],
2047dda4fb85SAurabindo Pillai &dpte_row_width_chroma_ub[k],
2048dda4fb85SAurabindo Pillai &dpte_row_height_chroma[k],
2049dda4fb85SAurabindo Pillai &dpte_row_height_linear_chroma[k],
2050968d4098SRodrigo Siqueira &PixelPTEBytesPerRowC_one_row_per_frame[k],
2051968d4098SRodrigo Siqueira &dpte_row_width_chroma_ub_one_row_per_frame[k],
2052968d4098SRodrigo Siqueira &dpte_row_height_chroma_one_row_per_frame[k],
2053dda4fb85SAurabindo Pillai &meta_req_width_chroma[k],
2054dda4fb85SAurabindo Pillai &meta_req_height_chroma[k],
2055dda4fb85SAurabindo Pillai &meta_row_width_chroma[k],
2056dda4fb85SAurabindo Pillai &meta_row_height_chroma[k],
2057dda4fb85SAurabindo Pillai &PixelPTEReqWidthC[k],
2058dda4fb85SAurabindo Pillai &PixelPTEReqHeightC[k],
2059dda4fb85SAurabindo Pillai &PTERequestSizeC[k],
2060dda4fb85SAurabindo Pillai &dpde0_bytes_per_frame_ub_c[k],
2061dda4fb85SAurabindo Pillai &meta_pte_bytes_per_frame_ub_c[k]);
2062dda4fb85SAurabindo Pillai
2063dda4fb85SAurabindo Pillai PrefetchSourceLinesC[k] = dml32_CalculatePrefetchSourceLines(
2064dda4fb85SAurabindo Pillai myPipe[k].VRatioChroma,
2065dda4fb85SAurabindo Pillai myPipe[k].VTapsChroma,
2066dda4fb85SAurabindo Pillai myPipe[k].InterlaceEnable,
2067dda4fb85SAurabindo Pillai myPipe[k].ProgressiveToInterlaceUnitInOPP,
2068dda4fb85SAurabindo Pillai myPipe[k].SwathHeightC,
2069dda4fb85SAurabindo Pillai myPipe[k].SourceRotation,
2070dda4fb85SAurabindo Pillai myPipe[k].ViewportStationary,
2071dda4fb85SAurabindo Pillai SwathWidthC[k],
2072dda4fb85SAurabindo Pillai myPipe[k].ViewportHeightChroma,
2073dda4fb85SAurabindo Pillai myPipe[k].ViewportXStartC,
2074dda4fb85SAurabindo Pillai myPipe[k].ViewportYStartC,
2075dda4fb85SAurabindo Pillai
2076dda4fb85SAurabindo Pillai /* Output */
2077dda4fb85SAurabindo Pillai &VInitPreFillC[k],
2078dda4fb85SAurabindo Pillai &MaxNumSwathC[k]);
2079dda4fb85SAurabindo Pillai } else {
2080968d4098SRodrigo Siqueira PTEBufferSizeInRequestsForLuma[k] = PTEBufferSizeInRequestsLuma + PTEBufferSizeInRequestsChroma;
2081968d4098SRodrigo Siqueira PTEBufferSizeInRequestsForChroma[k] = 0;
2082968d4098SRodrigo Siqueira PixelPTEBytesPerRowC[k] = 0;
2083968d4098SRodrigo Siqueira PDEAndMetaPTEBytesFrameC = 0;
2084968d4098SRodrigo Siqueira MetaRowByteC[k] = 0;
2085dda4fb85SAurabindo Pillai MaxNumSwathC[k] = 0;
2086dda4fb85SAurabindo Pillai PrefetchSourceLinesC[k] = 0;
2087968d4098SRodrigo Siqueira dpte_row_height_chroma_one_row_per_frame[k] = 0;
2088968d4098SRodrigo Siqueira dpte_row_width_chroma_ub_one_row_per_frame[k] = 0;
2089968d4098SRodrigo Siqueira PixelPTEBytesPerRowC_one_row_per_frame[k] = 0;
2090dda4fb85SAurabindo Pillai }
2091dda4fb85SAurabindo Pillai
2092968d4098SRodrigo Siqueira PDEAndMetaPTEBytesFrameY = dml32_CalculateVMAndRowBytes(
2093dda4fb85SAurabindo Pillai myPipe[k].ViewportStationary,
2094dda4fb85SAurabindo Pillai myPipe[k].DCCEnable,
2095dda4fb85SAurabindo Pillai myPipe[k].DPPPerSurface,
2096dda4fb85SAurabindo Pillai myPipe[k].BlockHeight256BytesY,
2097dda4fb85SAurabindo Pillai myPipe[k].BlockWidth256BytesY,
2098dda4fb85SAurabindo Pillai myPipe[k].SourcePixelFormat,
2099dda4fb85SAurabindo Pillai myPipe[k].SurfaceTiling,
2100dda4fb85SAurabindo Pillai myPipe[k].BytePerPixelY,
2101dda4fb85SAurabindo Pillai myPipe[k].SourceRotation,
2102dda4fb85SAurabindo Pillai SwathWidthY[k],
2103dda4fb85SAurabindo Pillai myPipe[k].ViewportHeight,
2104dda4fb85SAurabindo Pillai myPipe[k].ViewportXStart,
2105dda4fb85SAurabindo Pillai myPipe[k].ViewportYStart,
2106dda4fb85SAurabindo Pillai GPUVMEnable,
2107dda4fb85SAurabindo Pillai HostVMEnable,
2108dda4fb85SAurabindo Pillai HostVMMaxNonCachedPageTableLevels,
2109dda4fb85SAurabindo Pillai GPUVMMaxPageTableLevels,
2110dda4fb85SAurabindo Pillai GPUVMMinPageSizeKBytes[k],
2111dda4fb85SAurabindo Pillai HostVMMinPageSize,
2112968d4098SRodrigo Siqueira PTEBufferSizeInRequestsForLuma[k],
2113dda4fb85SAurabindo Pillai myPipe[k].PitchY,
2114dda4fb85SAurabindo Pillai myPipe[k].DCCMetaPitchY,
2115dda4fb85SAurabindo Pillai myPipe[k].BlockWidthY,
2116dda4fb85SAurabindo Pillai myPipe[k].BlockHeightY,
2117dda4fb85SAurabindo Pillai
2118dda4fb85SAurabindo Pillai /* Output */
2119968d4098SRodrigo Siqueira &MetaRowByteY[k],
2120968d4098SRodrigo Siqueira &PixelPTEBytesPerRowY[k],
2121dda4fb85SAurabindo Pillai &dpte_row_width_luma_ub[k],
2122dda4fb85SAurabindo Pillai &dpte_row_height_luma[k],
2123dda4fb85SAurabindo Pillai &dpte_row_height_linear_luma[k],
2124968d4098SRodrigo Siqueira &PixelPTEBytesPerRowY_one_row_per_frame[k],
2125968d4098SRodrigo Siqueira &dpte_row_width_luma_ub_one_row_per_frame[k],
2126968d4098SRodrigo Siqueira &dpte_row_height_luma_one_row_per_frame[k],
2127dda4fb85SAurabindo Pillai &meta_req_width[k],
2128dda4fb85SAurabindo Pillai &meta_req_height[k],
2129dda4fb85SAurabindo Pillai &meta_row_width[k],
2130dda4fb85SAurabindo Pillai &meta_row_height[k],
2131dda4fb85SAurabindo Pillai &PixelPTEReqWidthY[k],
2132dda4fb85SAurabindo Pillai &PixelPTEReqHeightY[k],
2133dda4fb85SAurabindo Pillai &PTERequestSizeY[k],
2134dda4fb85SAurabindo Pillai &dpde0_bytes_per_frame_ub_l[k],
2135dda4fb85SAurabindo Pillai &meta_pte_bytes_per_frame_ub_l[k]);
2136dda4fb85SAurabindo Pillai
2137dda4fb85SAurabindo Pillai PrefetchSourceLinesY[k] = dml32_CalculatePrefetchSourceLines(
2138dda4fb85SAurabindo Pillai myPipe[k].VRatio,
2139dda4fb85SAurabindo Pillai myPipe[k].VTaps,
2140dda4fb85SAurabindo Pillai myPipe[k].InterlaceEnable,
2141dda4fb85SAurabindo Pillai myPipe[k].ProgressiveToInterlaceUnitInOPP,
2142dda4fb85SAurabindo Pillai myPipe[k].SwathHeightY,
2143dda4fb85SAurabindo Pillai myPipe[k].SourceRotation,
2144dda4fb85SAurabindo Pillai myPipe[k].ViewportStationary,
2145dda4fb85SAurabindo Pillai SwathWidthY[k],
2146dda4fb85SAurabindo Pillai myPipe[k].ViewportHeight,
2147dda4fb85SAurabindo Pillai myPipe[k].ViewportXStart,
2148dda4fb85SAurabindo Pillai myPipe[k].ViewportYStart,
2149dda4fb85SAurabindo Pillai
2150dda4fb85SAurabindo Pillai /* Output */
2151dda4fb85SAurabindo Pillai &VInitPreFillY[k],
2152dda4fb85SAurabindo Pillai &MaxNumSwathY[k]);
2153dda4fb85SAurabindo Pillai
2154968d4098SRodrigo Siqueira PDEAndMetaPTEBytesFrame[k] = PDEAndMetaPTEBytesFrameY + PDEAndMetaPTEBytesFrameC;
2155968d4098SRodrigo Siqueira MetaRowByte[k] = MetaRowByteY[k] + MetaRowByteC[k];
2156dda4fb85SAurabindo Pillai
2157968d4098SRodrigo Siqueira if (PixelPTEBytesPerRowY[k] <= 64 * PTEBufferSizeInRequestsForLuma[k] &&
2158968d4098SRodrigo Siqueira PixelPTEBytesPerRowC[k] <= 64 * PTEBufferSizeInRequestsForChroma[k]) {
2159dda4fb85SAurabindo Pillai PTEBufferSizeNotExceeded[k] = true;
2160dda4fb85SAurabindo Pillai } else {
2161dda4fb85SAurabindo Pillai PTEBufferSizeNotExceeded[k] = false;
2162dda4fb85SAurabindo Pillai }
2163dda4fb85SAurabindo Pillai
2164968d4098SRodrigo Siqueira one_row_per_frame_fits_in_buffer[k] = (PixelPTEBytesPerRowY_one_row_per_frame[k] <= 64 * 2 *
2165968d4098SRodrigo Siqueira PTEBufferSizeInRequestsForLuma[k] &&
2166968d4098SRodrigo Siqueira PixelPTEBytesPerRowC_one_row_per_frame[k] <= 64 * 2 * PTEBufferSizeInRequestsForChroma[k]);
2167dda4fb85SAurabindo Pillai }
2168dda4fb85SAurabindo Pillai
2169dda4fb85SAurabindo Pillai dml32_CalculateMALLUseForStaticScreen(
2170dda4fb85SAurabindo Pillai NumberOfActiveSurfaces,
2171dda4fb85SAurabindo Pillai MALLAllocatedForDCN,
2172dda4fb85SAurabindo Pillai UseMALLForStaticScreen, // mode
2173dda4fb85SAurabindo Pillai SurfaceSizeInMALL,
2174968d4098SRodrigo Siqueira one_row_per_frame_fits_in_buffer,
2175dda4fb85SAurabindo Pillai /* Output */
2176dda4fb85SAurabindo Pillai UsesMALLForStaticScreen); // boolen
2177dda4fb85SAurabindo Pillai
2178dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
2179dda4fb85SAurabindo Pillai PTE_BUFFER_MODE[k] = myPipe[k].FORCE_ONE_ROW_FOR_FRAME || UsesMALLForStaticScreen[k] ||
2180dda4fb85SAurabindo Pillai (UseMALLForPStateChange[k] == dm_use_mall_pstate_change_sub_viewport) ||
2181dda4fb85SAurabindo Pillai (UseMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe) ||
2182dda4fb85SAurabindo Pillai (GPUVMMinPageSizeKBytes[k] > 64);
2183dda4fb85SAurabindo Pillai BIGK_FRAGMENT_SIZE[k] = dml_log2(GPUVMMinPageSizeKBytes[k] * 1024) - 12;
2184dda4fb85SAurabindo Pillai }
2185dda4fb85SAurabindo Pillai
2186dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
2187dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
2188dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, SurfaceSizeInMALL = %d\n", __func__, k, SurfaceSizeInMALL[k]);
2189dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, UsesMALLForStaticScreen = %d\n", __func__, k, UsesMALLForStaticScreen[k]);
2190dda4fb85SAurabindo Pillai #endif
2191dda4fb85SAurabindo Pillai use_one_row_for_frame[k] = myPipe[k].FORCE_ONE_ROW_FOR_FRAME || UsesMALLForStaticScreen[k] ||
2192dda4fb85SAurabindo Pillai (UseMALLForPStateChange[k] == dm_use_mall_pstate_change_sub_viewport) ||
2193dda4fb85SAurabindo Pillai (UseMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe) ||
2194dda4fb85SAurabindo Pillai (GPUVMMinPageSizeKBytes[k] > 64 && IsVertical(myPipe[k].SourceRotation));
2195dda4fb85SAurabindo Pillai
2196dda4fb85SAurabindo Pillai use_one_row_for_frame_flip[k] = use_one_row_for_frame[k] &&
2197dda4fb85SAurabindo Pillai !(UseMALLForPStateChange[k] == dm_use_mall_pstate_change_full_frame);
2198dda4fb85SAurabindo Pillai
2199dda4fb85SAurabindo Pillai if (use_one_row_for_frame[k]) {
2200968d4098SRodrigo Siqueira dpte_row_height_luma[k] = dpte_row_height_luma_one_row_per_frame[k];
2201968d4098SRodrigo Siqueira dpte_row_width_luma_ub[k] = dpte_row_width_luma_ub_one_row_per_frame[k];
2202968d4098SRodrigo Siqueira PixelPTEBytesPerRowY[k] = PixelPTEBytesPerRowY_one_row_per_frame[k];
2203968d4098SRodrigo Siqueira dpte_row_height_chroma[k] = dpte_row_height_chroma_one_row_per_frame[k];
2204968d4098SRodrigo Siqueira dpte_row_width_chroma_ub[k] = dpte_row_width_chroma_ub_one_row_per_frame[k];
2205968d4098SRodrigo Siqueira PixelPTEBytesPerRowC[k] = PixelPTEBytesPerRowC_one_row_per_frame[k];
2206968d4098SRodrigo Siqueira PTEBufferSizeNotExceeded[k] = one_row_per_frame_fits_in_buffer[k];
2207dda4fb85SAurabindo Pillai }
2208dda4fb85SAurabindo Pillai
2209dda4fb85SAurabindo Pillai if (MetaRowByte[k] <= DCCMetaBufferSizeBytes)
2210dda4fb85SAurabindo Pillai DCCMetaBufferSizeNotExceeded[k] = true;
2211dda4fb85SAurabindo Pillai else
2212dda4fb85SAurabindo Pillai DCCMetaBufferSizeNotExceeded[k] = false;
2213dda4fb85SAurabindo Pillai
2214968d4098SRodrigo Siqueira PixelPTEBytesPerRow[k] = PixelPTEBytesPerRowY[k] + PixelPTEBytesPerRowC[k];
2215dda4fb85SAurabindo Pillai if (use_one_row_for_frame[k])
2216dda4fb85SAurabindo Pillai PixelPTEBytesPerRow[k] = PixelPTEBytesPerRow[k] / 2;
2217dda4fb85SAurabindo Pillai
2218dda4fb85SAurabindo Pillai dml32_CalculateRowBandwidth(
2219dda4fb85SAurabindo Pillai GPUVMEnable,
2220dda4fb85SAurabindo Pillai myPipe[k].SourcePixelFormat,
2221dda4fb85SAurabindo Pillai myPipe[k].VRatio,
2222dda4fb85SAurabindo Pillai myPipe[k].VRatioChroma,
2223dda4fb85SAurabindo Pillai myPipe[k].DCCEnable,
2224dda4fb85SAurabindo Pillai myPipe[k].HTotal / myPipe[k].PixelClock,
2225968d4098SRodrigo Siqueira MetaRowByteY[k], MetaRowByteC[k],
2226dda4fb85SAurabindo Pillai meta_row_height[k],
2227dda4fb85SAurabindo Pillai meta_row_height_chroma[k],
2228968d4098SRodrigo Siqueira PixelPTEBytesPerRowY[k],
2229968d4098SRodrigo Siqueira PixelPTEBytesPerRowC[k],
2230dda4fb85SAurabindo Pillai dpte_row_height_luma[k],
2231dda4fb85SAurabindo Pillai dpte_row_height_chroma[k],
2232dda4fb85SAurabindo Pillai
2233dda4fb85SAurabindo Pillai /* Output */
2234dda4fb85SAurabindo Pillai &meta_row_bw[k],
2235dda4fb85SAurabindo Pillai &dpte_row_bw[k]);
2236dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
2237dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, use_one_row_for_frame = %d\n", __func__, k, use_one_row_for_frame[k]);
2238dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, use_one_row_for_frame_flip = %d\n",
2239dda4fb85SAurabindo Pillai __func__, k, use_one_row_for_frame_flip[k]);
2240dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, UseMALLForPStateChange = %d\n",
2241dda4fb85SAurabindo Pillai __func__, k, UseMALLForPStateChange[k]);
2242dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, dpte_row_height_luma = %d\n", __func__, k, dpte_row_height_luma[k]);
2243dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, dpte_row_width_luma_ub = %d\n",
2244dda4fb85SAurabindo Pillai __func__, k, dpte_row_width_luma_ub[k]);
2245968d4098SRodrigo Siqueira dml_print("DML::%s: k=%d, PixelPTEBytesPerRowY = %d\n", __func__, k, PixelPTEBytesPerRowY[k]);
2246dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, dpte_row_height_chroma = %d\n",
2247dda4fb85SAurabindo Pillai __func__, k, dpte_row_height_chroma[k]);
2248dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, dpte_row_width_chroma_ub = %d\n",
2249dda4fb85SAurabindo Pillai __func__, k, dpte_row_width_chroma_ub[k]);
2250968d4098SRodrigo Siqueira dml_print("DML::%s: k=%d, PixelPTEBytesPerRowC = %d\n", __func__, k, PixelPTEBytesPerRowC[k]);
2251dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, PixelPTEBytesPerRow = %d\n", __func__, k, PixelPTEBytesPerRow[k]);
2252dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, PTEBufferSizeNotExceeded = %d\n",
2253dda4fb85SAurabindo Pillai __func__, k, PTEBufferSizeNotExceeded[k]);
2254dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, PTE_BUFFER_MODE = %d\n", __func__, k, PTE_BUFFER_MODE[k]);
2255dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, BIGK_FRAGMENT_SIZE = %d\n", __func__, k, BIGK_FRAGMENT_SIZE[k]);
2256dda4fb85SAurabindo Pillai #endif
2257dda4fb85SAurabindo Pillai }
2258dda4fb85SAurabindo Pillai } // CalculateVMRowAndSwath
2259dda4fb85SAurabindo Pillai
dml32_CalculateVMAndRowBytes(bool ViewportStationary,bool DCCEnable,unsigned int NumberOfDPPs,unsigned int BlockHeight256Bytes,unsigned int BlockWidth256Bytes,enum source_format_class SourcePixelFormat,unsigned int SurfaceTiling,unsigned int BytePerPixel,enum dm_rotation_angle SourceRotation,double SwathWidth,unsigned int ViewportHeight,unsigned int ViewportXStart,unsigned int ViewportYStart,bool GPUVMEnable,bool HostVMEnable,unsigned int HostVMMaxNonCachedPageTableLevels,unsigned int GPUVMMaxPageTableLevels,unsigned int GPUVMMinPageSizeKBytes,unsigned int HostVMMinPageSize,unsigned int PTEBufferSizeInRequests,unsigned int Pitch,unsigned int DCCMetaPitch,unsigned int MacroTileWidth,unsigned int MacroTileHeight,unsigned int * MetaRowByte,unsigned int * PixelPTEBytesPerRow,unsigned int * dpte_row_width_ub,unsigned int * dpte_row_height,unsigned int * dpte_row_height_linear,unsigned int * PixelPTEBytesPerRow_one_row_per_frame,unsigned int * dpte_row_width_ub_one_row_per_frame,unsigned int * dpte_row_height_one_row_per_frame,unsigned int * MetaRequestWidth,unsigned int * MetaRequestHeight,unsigned int * meta_row_width,unsigned int * meta_row_height,unsigned int * PixelPTEReqWidth,unsigned int * PixelPTEReqHeight,unsigned int * PTERequestSize,unsigned int * DPDE0BytesFrame,unsigned int * MetaPTEBytesFrame)2260dda4fb85SAurabindo Pillai unsigned int dml32_CalculateVMAndRowBytes(
2261dda4fb85SAurabindo Pillai bool ViewportStationary,
2262dda4fb85SAurabindo Pillai bool DCCEnable,
2263dda4fb85SAurabindo Pillai unsigned int NumberOfDPPs,
2264dda4fb85SAurabindo Pillai unsigned int BlockHeight256Bytes,
2265dda4fb85SAurabindo Pillai unsigned int BlockWidth256Bytes,
2266dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat,
2267dda4fb85SAurabindo Pillai unsigned int SurfaceTiling,
2268dda4fb85SAurabindo Pillai unsigned int BytePerPixel,
2269dda4fb85SAurabindo Pillai enum dm_rotation_angle SourceRotation,
2270dda4fb85SAurabindo Pillai double SwathWidth,
2271dda4fb85SAurabindo Pillai unsigned int ViewportHeight,
2272dda4fb85SAurabindo Pillai unsigned int ViewportXStart,
2273dda4fb85SAurabindo Pillai unsigned int ViewportYStart,
2274dda4fb85SAurabindo Pillai bool GPUVMEnable,
2275dda4fb85SAurabindo Pillai bool HostVMEnable,
2276dda4fb85SAurabindo Pillai unsigned int HostVMMaxNonCachedPageTableLevels,
2277dda4fb85SAurabindo Pillai unsigned int GPUVMMaxPageTableLevels,
2278dda4fb85SAurabindo Pillai unsigned int GPUVMMinPageSizeKBytes,
2279dda4fb85SAurabindo Pillai unsigned int HostVMMinPageSize,
2280dda4fb85SAurabindo Pillai unsigned int PTEBufferSizeInRequests,
2281dda4fb85SAurabindo Pillai unsigned int Pitch,
2282dda4fb85SAurabindo Pillai unsigned int DCCMetaPitch,
2283dda4fb85SAurabindo Pillai unsigned int MacroTileWidth,
2284dda4fb85SAurabindo Pillai unsigned int MacroTileHeight,
2285dda4fb85SAurabindo Pillai
2286dda4fb85SAurabindo Pillai /* Output */
2287dda4fb85SAurabindo Pillai unsigned int *MetaRowByte,
2288dda4fb85SAurabindo Pillai unsigned int *PixelPTEBytesPerRow,
2289dda4fb85SAurabindo Pillai unsigned int *dpte_row_width_ub,
2290dda4fb85SAurabindo Pillai unsigned int *dpte_row_height,
2291dda4fb85SAurabindo Pillai unsigned int *dpte_row_height_linear,
2292dda4fb85SAurabindo Pillai unsigned int *PixelPTEBytesPerRow_one_row_per_frame,
2293dda4fb85SAurabindo Pillai unsigned int *dpte_row_width_ub_one_row_per_frame,
2294dda4fb85SAurabindo Pillai unsigned int *dpte_row_height_one_row_per_frame,
2295dda4fb85SAurabindo Pillai unsigned int *MetaRequestWidth,
2296dda4fb85SAurabindo Pillai unsigned int *MetaRequestHeight,
2297dda4fb85SAurabindo Pillai unsigned int *meta_row_width,
2298dda4fb85SAurabindo Pillai unsigned int *meta_row_height,
2299dda4fb85SAurabindo Pillai unsigned int *PixelPTEReqWidth,
2300dda4fb85SAurabindo Pillai unsigned int *PixelPTEReqHeight,
2301dda4fb85SAurabindo Pillai unsigned int *PTERequestSize,
2302dda4fb85SAurabindo Pillai unsigned int *DPDE0BytesFrame,
2303dda4fb85SAurabindo Pillai unsigned int *MetaPTEBytesFrame)
2304dda4fb85SAurabindo Pillai {
2305dda4fb85SAurabindo Pillai unsigned int MPDEBytesFrame;
2306dda4fb85SAurabindo Pillai unsigned int DCCMetaSurfaceBytes;
2307dda4fb85SAurabindo Pillai unsigned int ExtraDPDEBytesFrame;
2308dda4fb85SAurabindo Pillai unsigned int PDEAndMetaPTEBytesFrame;
2309dda4fb85SAurabindo Pillai unsigned int HostVMDynamicLevels = 0;
2310dda4fb85SAurabindo Pillai unsigned int MacroTileSizeBytes;
2311dda4fb85SAurabindo Pillai unsigned int vp_height_meta_ub;
2312dda4fb85SAurabindo Pillai unsigned int vp_height_dpte_ub;
2313dda4fb85SAurabindo Pillai unsigned int PixelPTEReqWidth_linear = 0; // VBA_DELTA. VBA doesn't calculate this
2314dda4fb85SAurabindo Pillai
2315dda4fb85SAurabindo Pillai if (GPUVMEnable == true && HostVMEnable == true) {
2316dda4fb85SAurabindo Pillai if (HostVMMinPageSize < 2048)
2317dda4fb85SAurabindo Pillai HostVMDynamicLevels = HostVMMaxNonCachedPageTableLevels;
2318dda4fb85SAurabindo Pillai else if (HostVMMinPageSize >= 2048 && HostVMMinPageSize < 1048576)
2319dda4fb85SAurabindo Pillai HostVMDynamicLevels = dml_max(0, (int) HostVMMaxNonCachedPageTableLevels - 1);
2320dda4fb85SAurabindo Pillai else
2321dda4fb85SAurabindo Pillai HostVMDynamicLevels = dml_max(0, (int) HostVMMaxNonCachedPageTableLevels - 2);
2322dda4fb85SAurabindo Pillai }
2323dda4fb85SAurabindo Pillai
2324dda4fb85SAurabindo Pillai *MetaRequestHeight = 8 * BlockHeight256Bytes;
2325dda4fb85SAurabindo Pillai *MetaRequestWidth = 8 * BlockWidth256Bytes;
2326dda4fb85SAurabindo Pillai if (SurfaceTiling == dm_sw_linear) {
2327dda4fb85SAurabindo Pillai *meta_row_height = 32;
2328dda4fb85SAurabindo Pillai *meta_row_width = dml_floor(ViewportXStart + SwathWidth + *MetaRequestWidth - 1, *MetaRequestWidth)
2329dda4fb85SAurabindo Pillai - dml_floor(ViewportXStart, *MetaRequestWidth);
2330dda4fb85SAurabindo Pillai } else if (!IsVertical(SourceRotation)) {
2331dda4fb85SAurabindo Pillai *meta_row_height = *MetaRequestHeight;
2332dda4fb85SAurabindo Pillai if (ViewportStationary && NumberOfDPPs == 1) {
2333dda4fb85SAurabindo Pillai *meta_row_width = dml_floor(ViewportXStart + SwathWidth + *MetaRequestWidth - 1,
2334dda4fb85SAurabindo Pillai *MetaRequestWidth) - dml_floor(ViewportXStart, *MetaRequestWidth);
2335dda4fb85SAurabindo Pillai } else {
2336dda4fb85SAurabindo Pillai *meta_row_width = dml_ceil(SwathWidth - 1, *MetaRequestWidth) + *MetaRequestWidth;
2337dda4fb85SAurabindo Pillai }
2338dda4fb85SAurabindo Pillai *MetaRowByte = *meta_row_width * *MetaRequestHeight * BytePerPixel / 256.0;
2339dda4fb85SAurabindo Pillai } else {
2340dda4fb85SAurabindo Pillai *meta_row_height = *MetaRequestWidth;
2341dda4fb85SAurabindo Pillai if (ViewportStationary && NumberOfDPPs == 1) {
2342dda4fb85SAurabindo Pillai *meta_row_width = dml_floor(ViewportYStart + ViewportHeight + *MetaRequestHeight - 1,
2343dda4fb85SAurabindo Pillai *MetaRequestHeight) - dml_floor(ViewportYStart, *MetaRequestHeight);
2344dda4fb85SAurabindo Pillai } else {
2345dda4fb85SAurabindo Pillai *meta_row_width = dml_ceil(SwathWidth - 1, *MetaRequestHeight) + *MetaRequestHeight;
2346dda4fb85SAurabindo Pillai }
2347dda4fb85SAurabindo Pillai *MetaRowByte = *meta_row_width * *MetaRequestWidth * BytePerPixel / 256.0;
2348dda4fb85SAurabindo Pillai }
2349dda4fb85SAurabindo Pillai
2350dda4fb85SAurabindo Pillai if (ViewportStationary && (NumberOfDPPs == 1 || !IsVertical(SourceRotation))) {
2351dda4fb85SAurabindo Pillai vp_height_meta_ub = dml_floor(ViewportYStart + ViewportHeight + 64 * BlockHeight256Bytes - 1,
2352dda4fb85SAurabindo Pillai 64 * BlockHeight256Bytes) - dml_floor(ViewportYStart, 64 * BlockHeight256Bytes);
2353dda4fb85SAurabindo Pillai } else if (!IsVertical(SourceRotation)) {
2354dda4fb85SAurabindo Pillai vp_height_meta_ub = dml_ceil(ViewportHeight - 1, 64 * BlockHeight256Bytes) + 64 * BlockHeight256Bytes;
2355dda4fb85SAurabindo Pillai } else {
2356dda4fb85SAurabindo Pillai vp_height_meta_ub = dml_ceil(SwathWidth - 1, 64 * BlockHeight256Bytes) + 64 * BlockHeight256Bytes;
2357dda4fb85SAurabindo Pillai }
2358dda4fb85SAurabindo Pillai
2359dda4fb85SAurabindo Pillai DCCMetaSurfaceBytes = DCCMetaPitch * vp_height_meta_ub * BytePerPixel / 256.0;
2360dda4fb85SAurabindo Pillai
2361dda4fb85SAurabindo Pillai if (GPUVMEnable == true) {
2362dda4fb85SAurabindo Pillai *MetaPTEBytesFrame = (dml_ceil((double) (DCCMetaSurfaceBytes - 4.0 * 1024.0) /
2363dda4fb85SAurabindo Pillai (8 * 4.0 * 1024), 1) + 1) * 64;
2364dda4fb85SAurabindo Pillai MPDEBytesFrame = 128 * (GPUVMMaxPageTableLevels - 1);
2365dda4fb85SAurabindo Pillai } else {
2366dda4fb85SAurabindo Pillai *MetaPTEBytesFrame = 0;
2367dda4fb85SAurabindo Pillai MPDEBytesFrame = 0;
2368dda4fb85SAurabindo Pillai }
2369dda4fb85SAurabindo Pillai
2370dda4fb85SAurabindo Pillai if (DCCEnable != true) {
2371dda4fb85SAurabindo Pillai *MetaPTEBytesFrame = 0;
2372dda4fb85SAurabindo Pillai MPDEBytesFrame = 0;
2373dda4fb85SAurabindo Pillai *MetaRowByte = 0;
2374dda4fb85SAurabindo Pillai }
2375dda4fb85SAurabindo Pillai
2376dda4fb85SAurabindo Pillai MacroTileSizeBytes = MacroTileWidth * BytePerPixel * MacroTileHeight;
2377dda4fb85SAurabindo Pillai
2378dda4fb85SAurabindo Pillai if (GPUVMEnable == true && GPUVMMaxPageTableLevels > 1) {
2379dda4fb85SAurabindo Pillai if (ViewportStationary && (NumberOfDPPs == 1 || !IsVertical(SourceRotation))) {
2380dda4fb85SAurabindo Pillai vp_height_dpte_ub = dml_floor(ViewportYStart + ViewportHeight +
2381dda4fb85SAurabindo Pillai MacroTileHeight - 1, MacroTileHeight) -
2382dda4fb85SAurabindo Pillai dml_floor(ViewportYStart, MacroTileHeight);
2383dda4fb85SAurabindo Pillai } else if (!IsVertical(SourceRotation)) {
2384dda4fb85SAurabindo Pillai vp_height_dpte_ub = dml_ceil(ViewportHeight - 1, MacroTileHeight) + MacroTileHeight;
2385dda4fb85SAurabindo Pillai } else {
2386dda4fb85SAurabindo Pillai vp_height_dpte_ub = dml_ceil(SwathWidth - 1, MacroTileHeight) + MacroTileHeight;
2387dda4fb85SAurabindo Pillai }
2388dda4fb85SAurabindo Pillai *DPDE0BytesFrame = 64 * (dml_ceil((Pitch * vp_height_dpte_ub * BytePerPixel - MacroTileSizeBytes) /
2389dda4fb85SAurabindo Pillai (8 * 2097152), 1) + 1);
2390dda4fb85SAurabindo Pillai ExtraDPDEBytesFrame = 128 * (GPUVMMaxPageTableLevels - 2);
2391dda4fb85SAurabindo Pillai } else {
2392dda4fb85SAurabindo Pillai *DPDE0BytesFrame = 0;
2393dda4fb85SAurabindo Pillai ExtraDPDEBytesFrame = 0;
2394dda4fb85SAurabindo Pillai vp_height_dpte_ub = 0;
2395dda4fb85SAurabindo Pillai }
2396dda4fb85SAurabindo Pillai
2397dda4fb85SAurabindo Pillai PDEAndMetaPTEBytesFrame = *MetaPTEBytesFrame + MPDEBytesFrame + *DPDE0BytesFrame + ExtraDPDEBytesFrame;
2398dda4fb85SAurabindo Pillai
2399dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
2400dda4fb85SAurabindo Pillai dml_print("DML::%s: DCCEnable = %d\n", __func__, DCCEnable);
2401dda4fb85SAurabindo Pillai dml_print("DML::%s: GPUVMEnable = %d\n", __func__, GPUVMEnable);
2402dda4fb85SAurabindo Pillai dml_print("DML::%s: SwModeLinear = %d\n", __func__, SurfaceTiling == dm_sw_linear);
2403dda4fb85SAurabindo Pillai dml_print("DML::%s: BytePerPixel = %d\n", __func__, BytePerPixel);
2404dda4fb85SAurabindo Pillai dml_print("DML::%s: GPUVMMaxPageTableLevels = %d\n", __func__, GPUVMMaxPageTableLevels);
2405dda4fb85SAurabindo Pillai dml_print("DML::%s: BlockHeight256Bytes = %d\n", __func__, BlockHeight256Bytes);
2406dda4fb85SAurabindo Pillai dml_print("DML::%s: BlockWidth256Bytes = %d\n", __func__, BlockWidth256Bytes);
2407dda4fb85SAurabindo Pillai dml_print("DML::%s: MacroTileHeight = %d\n", __func__, MacroTileHeight);
2408dda4fb85SAurabindo Pillai dml_print("DML::%s: MacroTileWidth = %d\n", __func__, MacroTileWidth);
2409dda4fb85SAurabindo Pillai dml_print("DML::%s: MetaPTEBytesFrame = %d\n", __func__, *MetaPTEBytesFrame);
2410dda4fb85SAurabindo Pillai dml_print("DML::%s: MPDEBytesFrame = %d\n", __func__, MPDEBytesFrame);
2411dda4fb85SAurabindo Pillai dml_print("DML::%s: DPDE0BytesFrame = %d\n", __func__, *DPDE0BytesFrame);
2412dda4fb85SAurabindo Pillai dml_print("DML::%s: ExtraDPDEBytesFrame= %d\n", __func__, ExtraDPDEBytesFrame);
2413dda4fb85SAurabindo Pillai dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %d\n", __func__, PDEAndMetaPTEBytesFrame);
2414dda4fb85SAurabindo Pillai dml_print("DML::%s: ViewportHeight = %d\n", __func__, ViewportHeight);
2415dda4fb85SAurabindo Pillai dml_print("DML::%s: SwathWidth = %d\n", __func__, SwathWidth);
2416dda4fb85SAurabindo Pillai dml_print("DML::%s: vp_height_dpte_ub = %d\n", __func__, vp_height_dpte_ub);
2417dda4fb85SAurabindo Pillai #endif
2418dda4fb85SAurabindo Pillai
2419dda4fb85SAurabindo Pillai if (HostVMEnable == true)
2420dda4fb85SAurabindo Pillai PDEAndMetaPTEBytesFrame = PDEAndMetaPTEBytesFrame * (1 + 8 * HostVMDynamicLevels);
2421dda4fb85SAurabindo Pillai
2422dda4fb85SAurabindo Pillai if (SurfaceTiling == dm_sw_linear) {
2423dda4fb85SAurabindo Pillai *PixelPTEReqHeight = 1;
2424dda4fb85SAurabindo Pillai *PixelPTEReqWidth = GPUVMMinPageSizeKBytes * 1024 * 8 / BytePerPixel;
2425dda4fb85SAurabindo Pillai PixelPTEReqWidth_linear = GPUVMMinPageSizeKBytes * 1024 * 8 / BytePerPixel;
2426dda4fb85SAurabindo Pillai *PTERequestSize = 64;
2427dda4fb85SAurabindo Pillai } else if (GPUVMMinPageSizeKBytes == 4) {
2428dda4fb85SAurabindo Pillai *PixelPTEReqHeight = 16 * BlockHeight256Bytes;
2429dda4fb85SAurabindo Pillai *PixelPTEReqWidth = 16 * BlockWidth256Bytes;
2430dda4fb85SAurabindo Pillai *PTERequestSize = 128;
2431dda4fb85SAurabindo Pillai } else {
2432dda4fb85SAurabindo Pillai *PixelPTEReqHeight = MacroTileHeight;
2433dda4fb85SAurabindo Pillai *PixelPTEReqWidth = 8 * 1024 * GPUVMMinPageSizeKBytes / (MacroTileHeight * BytePerPixel);
2434dda4fb85SAurabindo Pillai *PTERequestSize = 64;
2435dda4fb85SAurabindo Pillai }
2436dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
2437dda4fb85SAurabindo Pillai dml_print("DML::%s: GPUVMMinPageSizeKBytes = %d\n", __func__, GPUVMMinPageSizeKBytes);
2438dda4fb85SAurabindo Pillai dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %d (after HostVM factor)\n", __func__, PDEAndMetaPTEBytesFrame);
2439dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelPTEReqHeight = %d\n", __func__, *PixelPTEReqHeight);
2440dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelPTEReqWidth = %d\n", __func__, *PixelPTEReqWidth);
2441dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelPTEReqWidth_linear = %d\n", __func__, PixelPTEReqWidth_linear);
2442dda4fb85SAurabindo Pillai dml_print("DML::%s: PTERequestSize = %d\n", __func__, *PTERequestSize);
2443dda4fb85SAurabindo Pillai dml_print("DML::%s: Pitch = %d\n", __func__, Pitch);
2444dda4fb85SAurabindo Pillai #endif
2445dda4fb85SAurabindo Pillai
2446dda4fb85SAurabindo Pillai *dpte_row_height_one_row_per_frame = vp_height_dpte_ub;
2447dda4fb85SAurabindo Pillai *dpte_row_width_ub_one_row_per_frame = (dml_ceil(((double)Pitch * (double)*dpte_row_height_one_row_per_frame /
2448dda4fb85SAurabindo Pillai (double) *PixelPTEReqHeight - 1) / (double) *PixelPTEReqWidth, 1) + 1) *
2449dda4fb85SAurabindo Pillai (double) *PixelPTEReqWidth;
2450dda4fb85SAurabindo Pillai *PixelPTEBytesPerRow_one_row_per_frame = *dpte_row_width_ub_one_row_per_frame / *PixelPTEReqWidth *
2451dda4fb85SAurabindo Pillai *PTERequestSize;
2452dda4fb85SAurabindo Pillai
2453dda4fb85SAurabindo Pillai if (SurfaceTiling == dm_sw_linear) {
2454dda4fb85SAurabindo Pillai *dpte_row_height = dml_min(128, 1 << (unsigned int) dml_floor(dml_log2(PTEBufferSizeInRequests *
2455dda4fb85SAurabindo Pillai *PixelPTEReqWidth / Pitch), 1));
2456dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
2457dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_height = %d (1)\n", __func__,
2458dda4fb85SAurabindo Pillai PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch);
2459dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_height = %f (2)\n", __func__,
2460dda4fb85SAurabindo Pillai dml_log2(PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch));
2461dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_height = %f (3)\n", __func__,
2462dda4fb85SAurabindo Pillai dml_floor(dml_log2(PTEBufferSizeInRequests * *PixelPTEReqWidth / Pitch), 1));
2463dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_height = %d (4)\n", __func__,
2464dda4fb85SAurabindo Pillai 1 << (unsigned int) dml_floor(dml_log2(PTEBufferSizeInRequests *
2465dda4fb85SAurabindo Pillai *PixelPTEReqWidth / Pitch), 1));
2466dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_height = %d\n", __func__, *dpte_row_height);
2467dda4fb85SAurabindo Pillai #endif
2468dda4fb85SAurabindo Pillai *dpte_row_width_ub = dml_ceil(((double) Pitch * (double) *dpte_row_height - 1),
2469dda4fb85SAurabindo Pillai (double) *PixelPTEReqWidth) + *PixelPTEReqWidth;
2470dda4fb85SAurabindo Pillai *PixelPTEBytesPerRow = *dpte_row_width_ub / (double)*PixelPTEReqWidth * (double)*PTERequestSize;
2471dda4fb85SAurabindo Pillai
2472dda4fb85SAurabindo Pillai // VBA_DELTA, VBA doesn't have programming value for pte row height linear.
2473dda4fb85SAurabindo Pillai *dpte_row_height_linear = 1 << (unsigned int) dml_floor(dml_log2(PTEBufferSizeInRequests *
2474dda4fb85SAurabindo Pillai PixelPTEReqWidth_linear / Pitch), 1);
2475dda4fb85SAurabindo Pillai if (*dpte_row_height_linear > 128)
2476dda4fb85SAurabindo Pillai *dpte_row_height_linear = 128;
2477dda4fb85SAurabindo Pillai
2478dda4fb85SAurabindo Pillai } else if (!IsVertical(SourceRotation)) {
2479dda4fb85SAurabindo Pillai *dpte_row_height = *PixelPTEReqHeight;
2480dda4fb85SAurabindo Pillai
2481dda4fb85SAurabindo Pillai if (GPUVMMinPageSizeKBytes > 64) {
2482dda4fb85SAurabindo Pillai *dpte_row_width_ub = (dml_ceil((Pitch * *dpte_row_height / *PixelPTEReqHeight - 1) /
2483dda4fb85SAurabindo Pillai *PixelPTEReqWidth, 1) + 1) * *PixelPTEReqWidth;
2484dda4fb85SAurabindo Pillai } else if (ViewportStationary && (NumberOfDPPs == 1)) {
2485dda4fb85SAurabindo Pillai *dpte_row_width_ub = dml_floor(ViewportXStart + SwathWidth +
2486dda4fb85SAurabindo Pillai *PixelPTEReqWidth - 1, *PixelPTEReqWidth) -
2487dda4fb85SAurabindo Pillai dml_floor(ViewportXStart, *PixelPTEReqWidth);
2488dda4fb85SAurabindo Pillai } else {
2489dda4fb85SAurabindo Pillai *dpte_row_width_ub = (dml_ceil((SwathWidth - 1) / *PixelPTEReqWidth, 1) + 1) *
2490dda4fb85SAurabindo Pillai *PixelPTEReqWidth;
2491dda4fb85SAurabindo Pillai }
2492dda4fb85SAurabindo Pillai
2493dda4fb85SAurabindo Pillai *PixelPTEBytesPerRow = *dpte_row_width_ub / *PixelPTEReqWidth * *PTERequestSize;
2494dda4fb85SAurabindo Pillai } else {
2495dda4fb85SAurabindo Pillai *dpte_row_height = dml_min(*PixelPTEReqWidth, MacroTileWidth);
2496dda4fb85SAurabindo Pillai
2497dda4fb85SAurabindo Pillai if (ViewportStationary && (NumberOfDPPs == 1)) {
2498dda4fb85SAurabindo Pillai *dpte_row_width_ub = dml_floor(ViewportYStart + ViewportHeight + *PixelPTEReqHeight - 1,
2499dda4fb85SAurabindo Pillai *PixelPTEReqHeight) - dml_floor(ViewportYStart, *PixelPTEReqHeight);
2500dda4fb85SAurabindo Pillai } else {
2501dda4fb85SAurabindo Pillai *dpte_row_width_ub = (dml_ceil((SwathWidth - 1) / *PixelPTEReqHeight, 1) + 1)
2502dda4fb85SAurabindo Pillai * *PixelPTEReqHeight;
2503dda4fb85SAurabindo Pillai }
2504dda4fb85SAurabindo Pillai
2505dda4fb85SAurabindo Pillai *PixelPTEBytesPerRow = *dpte_row_width_ub / *PixelPTEReqHeight * *PTERequestSize;
2506dda4fb85SAurabindo Pillai }
2507dda4fb85SAurabindo Pillai
2508dda4fb85SAurabindo Pillai if (GPUVMEnable != true)
2509dda4fb85SAurabindo Pillai *PixelPTEBytesPerRow = 0;
2510dda4fb85SAurabindo Pillai if (HostVMEnable == true)
2511dda4fb85SAurabindo Pillai *PixelPTEBytesPerRow = *PixelPTEBytesPerRow * (1 + 8 * HostVMDynamicLevels);
2512dda4fb85SAurabindo Pillai
2513dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
2514dda4fb85SAurabindo Pillai dml_print("DML::%s: GPUVMMinPageSizeKBytes = %d\n", __func__, GPUVMMinPageSizeKBytes);
2515dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_height = %d\n", __func__, *dpte_row_height);
2516dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_height_linear = %d\n", __func__, *dpte_row_height_linear);
2517dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_width_ub = %d\n", __func__, *dpte_row_width_ub);
2518dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelPTEBytesPerRow = %d\n", __func__, *PixelPTEBytesPerRow);
2519dda4fb85SAurabindo Pillai dml_print("DML::%s: PTEBufferSizeInRequests = %d\n", __func__, PTEBufferSizeInRequests);
2520dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_height_one_row_per_frame = %d\n", __func__, *dpte_row_height_one_row_per_frame);
2521dda4fb85SAurabindo Pillai dml_print("DML::%s: dpte_row_width_ub_one_row_per_frame = %d\n",
2522dda4fb85SAurabindo Pillai __func__, *dpte_row_width_ub_one_row_per_frame);
2523dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelPTEBytesPerRow_one_row_per_frame = %d\n",
2524dda4fb85SAurabindo Pillai __func__, *PixelPTEBytesPerRow_one_row_per_frame);
2525dda4fb85SAurabindo Pillai dml_print("DML: vm_bytes = meta_pte_bytes_per_frame (per_pipe) = MetaPTEBytesFrame = : %i\n",
2526dda4fb85SAurabindo Pillai *MetaPTEBytesFrame);
2527dda4fb85SAurabindo Pillai #endif
2528dda4fb85SAurabindo Pillai
2529dda4fb85SAurabindo Pillai return PDEAndMetaPTEBytesFrame;
2530dda4fb85SAurabindo Pillai } // CalculateVMAndRowBytes
2531dda4fb85SAurabindo Pillai
dml32_CalculatePrefetchSourceLines(double VRatio,unsigned int VTaps,bool Interlace,bool ProgressiveToInterlaceUnitInOPP,unsigned int SwathHeight,enum dm_rotation_angle SourceRotation,bool ViewportStationary,double SwathWidth,unsigned int ViewportHeight,unsigned int ViewportXStart,unsigned int ViewportYStart,double * VInitPreFill,unsigned int * MaxNumSwath)2532dda4fb85SAurabindo Pillai double dml32_CalculatePrefetchSourceLines(
2533dda4fb85SAurabindo Pillai double VRatio,
2534dda4fb85SAurabindo Pillai unsigned int VTaps,
2535dda4fb85SAurabindo Pillai bool Interlace,
2536dda4fb85SAurabindo Pillai bool ProgressiveToInterlaceUnitInOPP,
2537dda4fb85SAurabindo Pillai unsigned int SwathHeight,
2538dda4fb85SAurabindo Pillai enum dm_rotation_angle SourceRotation,
2539dda4fb85SAurabindo Pillai bool ViewportStationary,
2540dda4fb85SAurabindo Pillai double SwathWidth,
2541dda4fb85SAurabindo Pillai unsigned int ViewportHeight,
2542dda4fb85SAurabindo Pillai unsigned int ViewportXStart,
2543dda4fb85SAurabindo Pillai unsigned int ViewportYStart,
2544dda4fb85SAurabindo Pillai
2545dda4fb85SAurabindo Pillai /* Output */
2546dda4fb85SAurabindo Pillai double *VInitPreFill,
2547dda4fb85SAurabindo Pillai unsigned int *MaxNumSwath)
2548dda4fb85SAurabindo Pillai {
2549dda4fb85SAurabindo Pillai
2550dda4fb85SAurabindo Pillai unsigned int vp_start_rot;
2551dda4fb85SAurabindo Pillai unsigned int sw0_tmp;
2552dda4fb85SAurabindo Pillai unsigned int MaxPartialSwath;
2553dda4fb85SAurabindo Pillai double numLines;
2554dda4fb85SAurabindo Pillai
2555dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
2556dda4fb85SAurabindo Pillai dml_print("DML::%s: VRatio = %f\n", __func__, VRatio);
2557dda4fb85SAurabindo Pillai dml_print("DML::%s: VTaps = %d\n", __func__, VTaps);
2558dda4fb85SAurabindo Pillai dml_print("DML::%s: ViewportXStart = %d\n", __func__, ViewportXStart);
2559dda4fb85SAurabindo Pillai dml_print("DML::%s: ViewportYStart = %d\n", __func__, ViewportYStart);
2560dda4fb85SAurabindo Pillai dml_print("DML::%s: ViewportStationary = %d\n", __func__, ViewportStationary);
2561dda4fb85SAurabindo Pillai dml_print("DML::%s: SwathHeight = %d\n", __func__, SwathHeight);
2562dda4fb85SAurabindo Pillai #endif
2563dda4fb85SAurabindo Pillai if (ProgressiveToInterlaceUnitInOPP)
2564dda4fb85SAurabindo Pillai *VInitPreFill = dml_floor((VRatio + (double) VTaps + 1) / 2.0, 1);
2565dda4fb85SAurabindo Pillai else
2566dda4fb85SAurabindo Pillai *VInitPreFill = dml_floor((VRatio + (double) VTaps + 1 + Interlace * 0.5 * VRatio) / 2.0, 1);
2567dda4fb85SAurabindo Pillai
2568dda4fb85SAurabindo Pillai if (ViewportStationary) {
2569dda4fb85SAurabindo Pillai if (SourceRotation == dm_rotation_180 || SourceRotation == dm_rotation_180m) {
2570dda4fb85SAurabindo Pillai vp_start_rot = SwathHeight -
2571dda4fb85SAurabindo Pillai (((unsigned int) (ViewportYStart + ViewportHeight - 1) % SwathHeight) + 1);
2572dda4fb85SAurabindo Pillai } else if (SourceRotation == dm_rotation_270 || SourceRotation == dm_rotation_90m) {
2573dda4fb85SAurabindo Pillai vp_start_rot = ViewportXStart;
2574dda4fb85SAurabindo Pillai } else if (SourceRotation == dm_rotation_90 || SourceRotation == dm_rotation_270m) {
2575dda4fb85SAurabindo Pillai vp_start_rot = SwathHeight -
2576dda4fb85SAurabindo Pillai (((unsigned int)(ViewportYStart + SwathWidth - 1) % SwathHeight) + 1);
2577dda4fb85SAurabindo Pillai } else {
2578dda4fb85SAurabindo Pillai vp_start_rot = ViewportYStart;
2579dda4fb85SAurabindo Pillai }
2580dda4fb85SAurabindo Pillai sw0_tmp = SwathHeight - (vp_start_rot % SwathHeight);
2581dda4fb85SAurabindo Pillai if (sw0_tmp < *VInitPreFill)
2582dda4fb85SAurabindo Pillai *MaxNumSwath = dml_ceil((*VInitPreFill - sw0_tmp) / SwathHeight, 1) + 1;
2583dda4fb85SAurabindo Pillai else
2584dda4fb85SAurabindo Pillai *MaxNumSwath = 1;
2585dda4fb85SAurabindo Pillai MaxPartialSwath = dml_max(1, (unsigned int) (vp_start_rot + *VInitPreFill - 1) % SwathHeight);
2586dda4fb85SAurabindo Pillai } else {
2587dda4fb85SAurabindo Pillai *MaxNumSwath = dml_ceil((*VInitPreFill - 1.0) / SwathHeight, 1) + 1;
2588dda4fb85SAurabindo Pillai if (*VInitPreFill > 1)
2589dda4fb85SAurabindo Pillai MaxPartialSwath = dml_max(1, (unsigned int) (*VInitPreFill - 2) % SwathHeight);
2590dda4fb85SAurabindo Pillai else
2591dda4fb85SAurabindo Pillai MaxPartialSwath = dml_max(1, (unsigned int) (*VInitPreFill + SwathHeight - 2) % SwathHeight);
2592dda4fb85SAurabindo Pillai }
2593dda4fb85SAurabindo Pillai numLines = *MaxNumSwath * SwathHeight + MaxPartialSwath;
2594dda4fb85SAurabindo Pillai
2595dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
2596dda4fb85SAurabindo Pillai dml_print("DML::%s: vp_start_rot = %d\n", __func__, vp_start_rot);
2597dda4fb85SAurabindo Pillai dml_print("DML::%s: VInitPreFill = %d\n", __func__, *VInitPreFill);
2598dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxPartialSwath = %d\n", __func__, MaxPartialSwath);
2599dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxNumSwath = %d\n", __func__, *MaxNumSwath);
2600dda4fb85SAurabindo Pillai dml_print("DML::%s: Prefetch source lines = %3.2f\n", __func__, numLines);
2601dda4fb85SAurabindo Pillai #endif
2602dda4fb85SAurabindo Pillai return numLines;
2603dda4fb85SAurabindo Pillai
2604dda4fb85SAurabindo Pillai } // CalculatePrefetchSourceLines
2605dda4fb85SAurabindo Pillai
dml32_CalculateMALLUseForStaticScreen(unsigned int NumberOfActiveSurfaces,unsigned int MALLAllocatedForDCNFinal,enum dm_use_mall_for_static_screen_mode * UseMALLForStaticScreen,unsigned int SurfaceSizeInMALL[],bool one_row_per_frame_fits_in_buffer[],bool UsesMALLForStaticScreen[])2606dda4fb85SAurabindo Pillai void dml32_CalculateMALLUseForStaticScreen(
2607dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces,
2608dda4fb85SAurabindo Pillai unsigned int MALLAllocatedForDCNFinal,
2609dda4fb85SAurabindo Pillai enum dm_use_mall_for_static_screen_mode *UseMALLForStaticScreen,
2610dda4fb85SAurabindo Pillai unsigned int SurfaceSizeInMALL[],
2611dda4fb85SAurabindo Pillai bool one_row_per_frame_fits_in_buffer[],
2612dda4fb85SAurabindo Pillai
2613dda4fb85SAurabindo Pillai /* output */
2614dda4fb85SAurabindo Pillai bool UsesMALLForStaticScreen[])
2615dda4fb85SAurabindo Pillai {
2616dda4fb85SAurabindo Pillai unsigned int k;
2617dda4fb85SAurabindo Pillai unsigned int SurfaceToAddToMALL;
2618dda4fb85SAurabindo Pillai bool CanAddAnotherSurfaceToMALL;
2619dda4fb85SAurabindo Pillai unsigned int TotalSurfaceSizeInMALL;
2620dda4fb85SAurabindo Pillai
2621dda4fb85SAurabindo Pillai TotalSurfaceSizeInMALL = 0;
2622dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
2623dda4fb85SAurabindo Pillai UsesMALLForStaticScreen[k] = (UseMALLForStaticScreen[k] == dm_use_mall_static_screen_enable);
2624dda4fb85SAurabindo Pillai if (UsesMALLForStaticScreen[k])
2625dda4fb85SAurabindo Pillai TotalSurfaceSizeInMALL = TotalSurfaceSizeInMALL + SurfaceSizeInMALL[k];
2626dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
2627dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, UsesMALLForStaticScreen = %d\n", __func__, k, UsesMALLForStaticScreen[k]);
2628dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, TotalSurfaceSizeInMALL = %d\n", __func__, k, TotalSurfaceSizeInMALL);
2629dda4fb85SAurabindo Pillai #endif
2630dda4fb85SAurabindo Pillai }
2631dda4fb85SAurabindo Pillai
2632dda4fb85SAurabindo Pillai SurfaceToAddToMALL = 0;
2633dda4fb85SAurabindo Pillai CanAddAnotherSurfaceToMALL = true;
2634dda4fb85SAurabindo Pillai while (CanAddAnotherSurfaceToMALL) {
2635dda4fb85SAurabindo Pillai CanAddAnotherSurfaceToMALL = false;
2636dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
2637dda4fb85SAurabindo Pillai if (TotalSurfaceSizeInMALL + SurfaceSizeInMALL[k] <= MALLAllocatedForDCNFinal * 1024 * 1024 &&
2638dda4fb85SAurabindo Pillai !UsesMALLForStaticScreen[k] &&
2639dda4fb85SAurabindo Pillai UseMALLForStaticScreen[k] != dm_use_mall_static_screen_disable &&
2640dda4fb85SAurabindo Pillai one_row_per_frame_fits_in_buffer[k] &&
2641dda4fb85SAurabindo Pillai (!CanAddAnotherSurfaceToMALL ||
2642dda4fb85SAurabindo Pillai SurfaceSizeInMALL[k] < SurfaceSizeInMALL[SurfaceToAddToMALL])) {
2643dda4fb85SAurabindo Pillai CanAddAnotherSurfaceToMALL = true;
2644dda4fb85SAurabindo Pillai SurfaceToAddToMALL = k;
2645dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
2646dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, UseMALLForStaticScreen = %d (dis, en, optimize)\n",
2647dda4fb85SAurabindo Pillai __func__, k, UseMALLForStaticScreen[k]);
2648dda4fb85SAurabindo Pillai #endif
2649dda4fb85SAurabindo Pillai }
2650dda4fb85SAurabindo Pillai }
2651dda4fb85SAurabindo Pillai if (CanAddAnotherSurfaceToMALL) {
2652dda4fb85SAurabindo Pillai UsesMALLForStaticScreen[SurfaceToAddToMALL] = true;
2653dda4fb85SAurabindo Pillai TotalSurfaceSizeInMALL = TotalSurfaceSizeInMALL + SurfaceSizeInMALL[SurfaceToAddToMALL];
2654dda4fb85SAurabindo Pillai
2655dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
2656dda4fb85SAurabindo Pillai dml_print("DML::%s: SurfaceToAddToMALL = %d\n", __func__, SurfaceToAddToMALL);
2657dda4fb85SAurabindo Pillai dml_print("DML::%s: TotalSurfaceSizeInMALL = %d\n", __func__, TotalSurfaceSizeInMALL);
2658dda4fb85SAurabindo Pillai #endif
2659dda4fb85SAurabindo Pillai
2660dda4fb85SAurabindo Pillai }
2661dda4fb85SAurabindo Pillai }
2662dda4fb85SAurabindo Pillai }
2663dda4fb85SAurabindo Pillai
dml32_CalculateRowBandwidth(bool GPUVMEnable,enum source_format_class SourcePixelFormat,double VRatio,double VRatioChroma,bool DCCEnable,double LineTime,unsigned int MetaRowByteLuma,unsigned int MetaRowByteChroma,unsigned int meta_row_height_luma,unsigned int meta_row_height_chroma,unsigned int PixelPTEBytesPerRowLuma,unsigned int PixelPTEBytesPerRowChroma,unsigned int dpte_row_height_luma,unsigned int dpte_row_height_chroma,double * meta_row_bw,double * dpte_row_bw)2664dda4fb85SAurabindo Pillai void dml32_CalculateRowBandwidth(
2665dda4fb85SAurabindo Pillai bool GPUVMEnable,
2666dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat,
2667dda4fb85SAurabindo Pillai double VRatio,
2668dda4fb85SAurabindo Pillai double VRatioChroma,
2669dda4fb85SAurabindo Pillai bool DCCEnable,
2670dda4fb85SAurabindo Pillai double LineTime,
2671dda4fb85SAurabindo Pillai unsigned int MetaRowByteLuma,
2672dda4fb85SAurabindo Pillai unsigned int MetaRowByteChroma,
2673dda4fb85SAurabindo Pillai unsigned int meta_row_height_luma,
2674dda4fb85SAurabindo Pillai unsigned int meta_row_height_chroma,
2675dda4fb85SAurabindo Pillai unsigned int PixelPTEBytesPerRowLuma,
2676dda4fb85SAurabindo Pillai unsigned int PixelPTEBytesPerRowChroma,
2677dda4fb85SAurabindo Pillai unsigned int dpte_row_height_luma,
2678dda4fb85SAurabindo Pillai unsigned int dpte_row_height_chroma,
2679dda4fb85SAurabindo Pillai /* Output */
2680dda4fb85SAurabindo Pillai double *meta_row_bw,
2681dda4fb85SAurabindo Pillai double *dpte_row_bw)
2682dda4fb85SAurabindo Pillai {
2683dda4fb85SAurabindo Pillai if (DCCEnable != true) {
2684dda4fb85SAurabindo Pillai *meta_row_bw = 0;
2685dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10 || SourcePixelFormat == dm_420_12 ||
2686dda4fb85SAurabindo Pillai SourcePixelFormat == dm_rgbe_alpha) {
2687dda4fb85SAurabindo Pillai *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime) + VRatioChroma *
2688dda4fb85SAurabindo Pillai MetaRowByteChroma / (meta_row_height_chroma * LineTime);
2689dda4fb85SAurabindo Pillai } else {
2690dda4fb85SAurabindo Pillai *meta_row_bw = VRatio * MetaRowByteLuma / (meta_row_height_luma * LineTime);
2691dda4fb85SAurabindo Pillai }
2692dda4fb85SAurabindo Pillai
2693dda4fb85SAurabindo Pillai if (GPUVMEnable != true) {
2694dda4fb85SAurabindo Pillai *dpte_row_bw = 0;
2695dda4fb85SAurabindo Pillai } else if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10 || SourcePixelFormat == dm_420_12 ||
2696dda4fb85SAurabindo Pillai SourcePixelFormat == dm_rgbe_alpha) {
2697dda4fb85SAurabindo Pillai *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime) +
2698dda4fb85SAurabindo Pillai VRatioChroma * PixelPTEBytesPerRowChroma / (dpte_row_height_chroma * LineTime);
2699dda4fb85SAurabindo Pillai } else {
2700dda4fb85SAurabindo Pillai *dpte_row_bw = VRatio * PixelPTEBytesPerRowLuma / (dpte_row_height_luma * LineTime);
2701dda4fb85SAurabindo Pillai }
2702dda4fb85SAurabindo Pillai }
2703dda4fb85SAurabindo Pillai
dml32_CalculateUrgentLatency(double UrgentLatencyPixelDataOnly,double UrgentLatencyPixelMixedWithVMData,double UrgentLatencyVMDataOnly,bool DoUrgentLatencyAdjustment,double UrgentLatencyAdjustmentFabricClockComponent,double UrgentLatencyAdjustmentFabricClockReference,double FabricClock)2704dda4fb85SAurabindo Pillai double dml32_CalculateUrgentLatency(
2705dda4fb85SAurabindo Pillai double UrgentLatencyPixelDataOnly,
2706dda4fb85SAurabindo Pillai double UrgentLatencyPixelMixedWithVMData,
2707dda4fb85SAurabindo Pillai double UrgentLatencyVMDataOnly,
2708dda4fb85SAurabindo Pillai bool DoUrgentLatencyAdjustment,
2709dda4fb85SAurabindo Pillai double UrgentLatencyAdjustmentFabricClockComponent,
2710dda4fb85SAurabindo Pillai double UrgentLatencyAdjustmentFabricClockReference,
2711dda4fb85SAurabindo Pillai double FabricClock)
2712dda4fb85SAurabindo Pillai {
2713dda4fb85SAurabindo Pillai double ret;
2714dda4fb85SAurabindo Pillai
2715dda4fb85SAurabindo Pillai ret = dml_max3(UrgentLatencyPixelDataOnly, UrgentLatencyPixelMixedWithVMData, UrgentLatencyVMDataOnly);
2716dda4fb85SAurabindo Pillai if (DoUrgentLatencyAdjustment == true) {
2717dda4fb85SAurabindo Pillai ret = ret + UrgentLatencyAdjustmentFabricClockComponent *
2718dda4fb85SAurabindo Pillai (UrgentLatencyAdjustmentFabricClockReference / FabricClock - 1);
2719dda4fb85SAurabindo Pillai }
2720dda4fb85SAurabindo Pillai return ret;
2721dda4fb85SAurabindo Pillai }
2722dda4fb85SAurabindo Pillai
dml32_CalculateUrgentBurstFactor(enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange,unsigned int swath_width_luma_ub,unsigned int swath_width_chroma_ub,unsigned int SwathHeightY,unsigned int SwathHeightC,double LineTime,double UrgentLatency,double CursorBufferSize,unsigned int CursorWidth,unsigned int CursorBPP,double VRatio,double VRatioC,double BytePerPixelInDETY,double BytePerPixelInDETC,unsigned int DETBufferSizeY,unsigned int DETBufferSizeC,double * UrgentBurstFactorCursor,double * UrgentBurstFactorLuma,double * UrgentBurstFactorChroma,bool * NotEnoughUrgentLatencyHiding)2723dda4fb85SAurabindo Pillai void dml32_CalculateUrgentBurstFactor(
2724dda4fb85SAurabindo Pillai enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange,
2725dda4fb85SAurabindo Pillai unsigned int swath_width_luma_ub,
2726dda4fb85SAurabindo Pillai unsigned int swath_width_chroma_ub,
2727dda4fb85SAurabindo Pillai unsigned int SwathHeightY,
2728dda4fb85SAurabindo Pillai unsigned int SwathHeightC,
2729dda4fb85SAurabindo Pillai double LineTime,
2730dda4fb85SAurabindo Pillai double UrgentLatency,
2731dda4fb85SAurabindo Pillai double CursorBufferSize,
2732dda4fb85SAurabindo Pillai unsigned int CursorWidth,
2733dda4fb85SAurabindo Pillai unsigned int CursorBPP,
2734dda4fb85SAurabindo Pillai double VRatio,
2735dda4fb85SAurabindo Pillai double VRatioC,
2736dda4fb85SAurabindo Pillai double BytePerPixelInDETY,
2737dda4fb85SAurabindo Pillai double BytePerPixelInDETC,
2738dda4fb85SAurabindo Pillai unsigned int DETBufferSizeY,
2739dda4fb85SAurabindo Pillai unsigned int DETBufferSizeC,
2740dda4fb85SAurabindo Pillai /* Output */
2741dda4fb85SAurabindo Pillai double *UrgentBurstFactorCursor,
2742dda4fb85SAurabindo Pillai double *UrgentBurstFactorLuma,
2743dda4fb85SAurabindo Pillai double *UrgentBurstFactorChroma,
2744dda4fb85SAurabindo Pillai bool *NotEnoughUrgentLatencyHiding)
2745dda4fb85SAurabindo Pillai {
2746dda4fb85SAurabindo Pillai double LinesInDETLuma;
2747dda4fb85SAurabindo Pillai double LinesInDETChroma;
2748dda4fb85SAurabindo Pillai unsigned int LinesInCursorBuffer;
2749dda4fb85SAurabindo Pillai double CursorBufferSizeInTime;
2750dda4fb85SAurabindo Pillai double DETBufferSizeInTimeLuma;
2751dda4fb85SAurabindo Pillai double DETBufferSizeInTimeChroma;
2752dda4fb85SAurabindo Pillai
2753dda4fb85SAurabindo Pillai *NotEnoughUrgentLatencyHiding = 0;
2754dda4fb85SAurabindo Pillai
2755dda4fb85SAurabindo Pillai if (CursorWidth > 0) {
2756dda4fb85SAurabindo Pillai LinesInCursorBuffer = 1 << (unsigned int) dml_floor(dml_log2(CursorBufferSize * 1024.0 /
2757dda4fb85SAurabindo Pillai (CursorWidth * CursorBPP / 8.0)), 1.0);
2758dda4fb85SAurabindo Pillai if (VRatio > 0) {
2759dda4fb85SAurabindo Pillai CursorBufferSizeInTime = LinesInCursorBuffer * LineTime / VRatio;
2760dda4fb85SAurabindo Pillai if (CursorBufferSizeInTime - UrgentLatency <= 0) {
2761dda4fb85SAurabindo Pillai *NotEnoughUrgentLatencyHiding = 1;
2762dda4fb85SAurabindo Pillai *UrgentBurstFactorCursor = 0;
2763dda4fb85SAurabindo Pillai } else {
2764dda4fb85SAurabindo Pillai *UrgentBurstFactorCursor = CursorBufferSizeInTime /
2765dda4fb85SAurabindo Pillai (CursorBufferSizeInTime - UrgentLatency);
2766dda4fb85SAurabindo Pillai }
2767dda4fb85SAurabindo Pillai } else {
2768dda4fb85SAurabindo Pillai *UrgentBurstFactorCursor = 1;
2769dda4fb85SAurabindo Pillai }
2770dda4fb85SAurabindo Pillai }
2771dda4fb85SAurabindo Pillai
2772dda4fb85SAurabindo Pillai LinesInDETLuma = (UseMALLForPStateChange == dm_use_mall_pstate_change_phantom_pipe ? 1024*1024 :
2773dda4fb85SAurabindo Pillai DETBufferSizeY) / BytePerPixelInDETY / swath_width_luma_ub;
2774dda4fb85SAurabindo Pillai
2775dda4fb85SAurabindo Pillai if (VRatio > 0) {
2776dda4fb85SAurabindo Pillai DETBufferSizeInTimeLuma = dml_floor(LinesInDETLuma, SwathHeightY) * LineTime / VRatio;
2777dda4fb85SAurabindo Pillai if (DETBufferSizeInTimeLuma - UrgentLatency <= 0) {
2778dda4fb85SAurabindo Pillai *NotEnoughUrgentLatencyHiding = 1;
2779dda4fb85SAurabindo Pillai *UrgentBurstFactorLuma = 0;
2780dda4fb85SAurabindo Pillai } else {
2781dda4fb85SAurabindo Pillai *UrgentBurstFactorLuma = DETBufferSizeInTimeLuma / (DETBufferSizeInTimeLuma - UrgentLatency);
2782dda4fb85SAurabindo Pillai }
2783dda4fb85SAurabindo Pillai } else {
2784dda4fb85SAurabindo Pillai *UrgentBurstFactorLuma = 1;
2785dda4fb85SAurabindo Pillai }
2786dda4fb85SAurabindo Pillai
2787dda4fb85SAurabindo Pillai if (BytePerPixelInDETC > 0) {
2788dda4fb85SAurabindo Pillai LinesInDETChroma = (UseMALLForPStateChange == dm_use_mall_pstate_change_phantom_pipe ?
2789dda4fb85SAurabindo Pillai 1024 * 1024 : DETBufferSizeC) / BytePerPixelInDETC
2790dda4fb85SAurabindo Pillai / swath_width_chroma_ub;
2791dda4fb85SAurabindo Pillai
2792dda4fb85SAurabindo Pillai if (VRatio > 0) {
2793dda4fb85SAurabindo Pillai DETBufferSizeInTimeChroma = dml_floor(LinesInDETChroma, SwathHeightC) * LineTime / VRatio;
2794dda4fb85SAurabindo Pillai if (DETBufferSizeInTimeChroma - UrgentLatency <= 0) {
2795dda4fb85SAurabindo Pillai *NotEnoughUrgentLatencyHiding = 1;
2796dda4fb85SAurabindo Pillai *UrgentBurstFactorChroma = 0;
2797dda4fb85SAurabindo Pillai } else {
2798dda4fb85SAurabindo Pillai *UrgentBurstFactorChroma = DETBufferSizeInTimeChroma
2799dda4fb85SAurabindo Pillai / (DETBufferSizeInTimeChroma - UrgentLatency);
2800dda4fb85SAurabindo Pillai }
2801dda4fb85SAurabindo Pillai } else {
2802dda4fb85SAurabindo Pillai *UrgentBurstFactorChroma = 1;
2803dda4fb85SAurabindo Pillai }
2804dda4fb85SAurabindo Pillai }
2805dda4fb85SAurabindo Pillai } // CalculateUrgentBurstFactor
2806dda4fb85SAurabindo Pillai
dml32_CalculateDCFCLKDeepSleep(unsigned int NumberOfActiveSurfaces,unsigned int BytePerPixelY[],unsigned int BytePerPixelC[],double VRatio[],double VRatioChroma[],double SwathWidthY[],double SwathWidthC[],unsigned int DPPPerSurface[],double HRatio[],double HRatioChroma[],double PixelClock[],double PSCL_THROUGHPUT[],double PSCL_THROUGHPUT_CHROMA[],double Dppclk[],double ReadBandwidthLuma[],double ReadBandwidthChroma[],unsigned int ReturnBusWidth,double * DCFClkDeepSleep)2807dda4fb85SAurabindo Pillai void dml32_CalculateDCFCLKDeepSleep(
2808dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces,
2809dda4fb85SAurabindo Pillai unsigned int BytePerPixelY[],
2810dda4fb85SAurabindo Pillai unsigned int BytePerPixelC[],
2811dda4fb85SAurabindo Pillai double VRatio[],
2812dda4fb85SAurabindo Pillai double VRatioChroma[],
2813dda4fb85SAurabindo Pillai double SwathWidthY[],
2814dda4fb85SAurabindo Pillai double SwathWidthC[],
2815dda4fb85SAurabindo Pillai unsigned int DPPPerSurface[],
2816dda4fb85SAurabindo Pillai double HRatio[],
2817dda4fb85SAurabindo Pillai double HRatioChroma[],
2818dda4fb85SAurabindo Pillai double PixelClock[],
2819dda4fb85SAurabindo Pillai double PSCL_THROUGHPUT[],
2820dda4fb85SAurabindo Pillai double PSCL_THROUGHPUT_CHROMA[],
2821dda4fb85SAurabindo Pillai double Dppclk[],
2822dda4fb85SAurabindo Pillai double ReadBandwidthLuma[],
2823dda4fb85SAurabindo Pillai double ReadBandwidthChroma[],
2824dda4fb85SAurabindo Pillai unsigned int ReturnBusWidth,
2825dda4fb85SAurabindo Pillai
2826dda4fb85SAurabindo Pillai /* Output */
2827dda4fb85SAurabindo Pillai double *DCFClkDeepSleep)
2828dda4fb85SAurabindo Pillai {
2829dda4fb85SAurabindo Pillai unsigned int k;
2830dda4fb85SAurabindo Pillai double DisplayPipeLineDeliveryTimeLuma;
2831dda4fb85SAurabindo Pillai double DisplayPipeLineDeliveryTimeChroma;
2832dda4fb85SAurabindo Pillai double DCFClkDeepSleepPerSurface[DC__NUM_DPP__MAX];
2833dda4fb85SAurabindo Pillai double ReadBandwidth = 0.0;
2834dda4fb85SAurabindo Pillai
2835dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
2836dda4fb85SAurabindo Pillai
2837dda4fb85SAurabindo Pillai if (VRatio[k] <= 1) {
2838dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeLuma = SwathWidthY[k] * DPPPerSurface[k] / HRatio[k]
2839dda4fb85SAurabindo Pillai / PixelClock[k];
2840dda4fb85SAurabindo Pillai } else {
2841dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeLuma = SwathWidthY[k] / PSCL_THROUGHPUT[k] / Dppclk[k];
2842dda4fb85SAurabindo Pillai }
2843dda4fb85SAurabindo Pillai if (BytePerPixelC[k] == 0) {
2844dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChroma = 0;
2845dda4fb85SAurabindo Pillai } else {
2846dda4fb85SAurabindo Pillai if (VRatioChroma[k] <= 1) {
2847dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChroma = SwathWidthC[k] *
2848dda4fb85SAurabindo Pillai DPPPerSurface[k] / HRatioChroma[k] / PixelClock[k];
2849dda4fb85SAurabindo Pillai } else {
2850dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChroma = SwathWidthC[k] / PSCL_THROUGHPUT_CHROMA[k]
2851dda4fb85SAurabindo Pillai / Dppclk[k];
2852dda4fb85SAurabindo Pillai }
2853dda4fb85SAurabindo Pillai }
2854dda4fb85SAurabindo Pillai
2855dda4fb85SAurabindo Pillai if (BytePerPixelC[k] > 0) {
2856dda4fb85SAurabindo Pillai DCFClkDeepSleepPerSurface[k] = dml_max(__DML_MIN_DCFCLK_FACTOR__ * SwathWidthY[k] *
2857dda4fb85SAurabindo Pillai BytePerPixelY[k] / 32.0 / DisplayPipeLineDeliveryTimeLuma,
2858dda4fb85SAurabindo Pillai __DML_MIN_DCFCLK_FACTOR__ * SwathWidthC[k] * BytePerPixelC[k] /
2859dda4fb85SAurabindo Pillai 32.0 / DisplayPipeLineDeliveryTimeChroma);
2860dda4fb85SAurabindo Pillai } else {
2861dda4fb85SAurabindo Pillai DCFClkDeepSleepPerSurface[k] = __DML_MIN_DCFCLK_FACTOR__ * SwathWidthY[k] * BytePerPixelY[k] /
2862dda4fb85SAurabindo Pillai 64.0 / DisplayPipeLineDeliveryTimeLuma;
2863dda4fb85SAurabindo Pillai }
2864dda4fb85SAurabindo Pillai DCFClkDeepSleepPerSurface[k] = dml_max(DCFClkDeepSleepPerSurface[k], PixelClock[k] / 16);
2865dda4fb85SAurabindo Pillai
2866dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
2867dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, PixelClock = %f\n", __func__, k, PixelClock[k]);
2868dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, DCFClkDeepSleepPerSurface = %f\n", __func__, k, DCFClkDeepSleepPerSurface[k]);
2869dda4fb85SAurabindo Pillai #endif
2870dda4fb85SAurabindo Pillai }
2871dda4fb85SAurabindo Pillai
2872dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k)
2873dda4fb85SAurabindo Pillai ReadBandwidth = ReadBandwidth + ReadBandwidthLuma[k] + ReadBandwidthChroma[k];
2874dda4fb85SAurabindo Pillai
2875dda4fb85SAurabindo Pillai *DCFClkDeepSleep = dml_max(8.0, __DML_MIN_DCFCLK_FACTOR__ * ReadBandwidth / (double) ReturnBusWidth);
2876dda4fb85SAurabindo Pillai
2877dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
2878dda4fb85SAurabindo Pillai dml_print("DML::%s: __DML_MIN_DCFCLK_FACTOR__ = %f\n", __func__, __DML_MIN_DCFCLK_FACTOR__);
2879dda4fb85SAurabindo Pillai dml_print("DML::%s: ReadBandwidth = %f\n", __func__, ReadBandwidth);
2880dda4fb85SAurabindo Pillai dml_print("DML::%s: ReturnBusWidth = %d\n", __func__, ReturnBusWidth);
2881dda4fb85SAurabindo Pillai dml_print("DML::%s: DCFClkDeepSleep = %f\n", __func__, *DCFClkDeepSleep);
2882dda4fb85SAurabindo Pillai #endif
2883dda4fb85SAurabindo Pillai
2884dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k)
2885dda4fb85SAurabindo Pillai *DCFClkDeepSleep = dml_max(*DCFClkDeepSleep, DCFClkDeepSleepPerSurface[k]);
2886dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
2887dda4fb85SAurabindo Pillai dml_print("DML::%s: DCFClkDeepSleep = %f (final)\n", __func__, *DCFClkDeepSleep);
2888dda4fb85SAurabindo Pillai #endif
2889dda4fb85SAurabindo Pillai } // CalculateDCFCLKDeepSleep
2890dda4fb85SAurabindo Pillai
dml32_CalculateWriteBackDelay(enum source_format_class WritebackPixelFormat,double WritebackHRatio,double WritebackVRatio,unsigned int WritebackVTaps,unsigned int WritebackDestinationWidth,unsigned int WritebackDestinationHeight,unsigned int WritebackSourceHeight,unsigned int HTotal)2891dda4fb85SAurabindo Pillai double dml32_CalculateWriteBackDelay(
2892dda4fb85SAurabindo Pillai enum source_format_class WritebackPixelFormat,
2893dda4fb85SAurabindo Pillai double WritebackHRatio,
2894dda4fb85SAurabindo Pillai double WritebackVRatio,
2895dda4fb85SAurabindo Pillai unsigned int WritebackVTaps,
2896dda4fb85SAurabindo Pillai unsigned int WritebackDestinationWidth,
2897dda4fb85SAurabindo Pillai unsigned int WritebackDestinationHeight,
2898dda4fb85SAurabindo Pillai unsigned int WritebackSourceHeight,
2899dda4fb85SAurabindo Pillai unsigned int HTotal)
2900dda4fb85SAurabindo Pillai {
2901dda4fb85SAurabindo Pillai double CalculateWriteBackDelay;
2902dda4fb85SAurabindo Pillai double Line_length;
2903dda4fb85SAurabindo Pillai double Output_lines_last_notclamped;
2904dda4fb85SAurabindo Pillai double WritebackVInit;
2905dda4fb85SAurabindo Pillai
2906dda4fb85SAurabindo Pillai WritebackVInit = (WritebackVRatio + WritebackVTaps + 1) / 2;
2907dda4fb85SAurabindo Pillai Line_length = dml_max((double) WritebackDestinationWidth,
2908dda4fb85SAurabindo Pillai dml_ceil((double)WritebackDestinationWidth / 6.0, 1.0) * WritebackVTaps);
2909dda4fb85SAurabindo Pillai Output_lines_last_notclamped = WritebackDestinationHeight - 1 -
2910dda4fb85SAurabindo Pillai dml_ceil(((double)WritebackSourceHeight -
2911dda4fb85SAurabindo Pillai (double) WritebackVInit) / (double)WritebackVRatio, 1.0);
2912dda4fb85SAurabindo Pillai if (Output_lines_last_notclamped < 0) {
2913dda4fb85SAurabindo Pillai CalculateWriteBackDelay = 0;
2914dda4fb85SAurabindo Pillai } else {
2915dda4fb85SAurabindo Pillai CalculateWriteBackDelay = Output_lines_last_notclamped * Line_length +
2916dda4fb85SAurabindo Pillai (HTotal - WritebackDestinationWidth) + 80;
2917dda4fb85SAurabindo Pillai }
2918dda4fb85SAurabindo Pillai return CalculateWriteBackDelay;
2919dda4fb85SAurabindo Pillai }
2920dda4fb85SAurabindo Pillai
dml32_UseMinimumDCFCLK(enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange[],bool DRRDisplay[],bool SynchronizeDRRDisplaysForUCLKPStateChangeFinal,unsigned int MaxInterDCNTileRepeaters,unsigned int MaxPrefetchMode,double DRAMClockChangeLatencyFinal,double FCLKChangeLatency,double SREnterPlusExitTime,unsigned int ReturnBusWidth,unsigned int RoundTripPingLatencyCycles,unsigned int ReorderingBytes,unsigned int PixelChunkSizeInKByte,unsigned int MetaChunkSize,bool GPUVMEnable,unsigned int GPUVMMaxPageTableLevels,bool HostVMEnable,unsigned int NumberOfActiveSurfaces,double HostVMMinPageSize,unsigned int HostVMMaxNonCachedPageTableLevels,bool DynamicMetadataVMEnabled,bool ImmediateFlipRequirement,bool ProgressiveToInterlaceUnitInOPP,double MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation,double PercentOfIdealSDPPortBWReceivedAfterUrgLatency,unsigned int VTotal[],unsigned int VActive[],unsigned int DynamicMetadataTransmittedBytes[],unsigned int DynamicMetadataLinesBeforeActiveRequired[],bool Interlace[],double RequiredDPPCLKPerSurface[][2][DC__NUM_DPP__MAX],double RequiredDISPCLK[][2],double UrgLatency[],unsigned int NoOfDPP[][2][DC__NUM_DPP__MAX],double ProjectedDCFClkDeepSleep[][2],double MaximumVStartup[][2][DC__NUM_DPP__MAX],unsigned int TotalNumberOfActiveDPP[][2],unsigned int TotalNumberOfDCCActiveDPP[][2],unsigned int dpte_group_bytes[],double PrefetchLinesY[][2][DC__NUM_DPP__MAX],double PrefetchLinesC[][2][DC__NUM_DPP__MAX],unsigned int swath_width_luma_ub_all_states[][2][DC__NUM_DPP__MAX],unsigned int swath_width_chroma_ub_all_states[][2][DC__NUM_DPP__MAX],unsigned int BytePerPixelY[],unsigned int BytePerPixelC[],unsigned int HTotal[],double PixelClock[],double PDEAndMetaPTEBytesPerFrame[][2][DC__NUM_DPP__MAX],double DPTEBytesPerRow[][2][DC__NUM_DPP__MAX],double MetaRowBytes[][2][DC__NUM_DPP__MAX],bool DynamicMetadataEnable[],double ReadBandwidthLuma[],double ReadBandwidthChroma[],double DCFCLKPerState[],double DCFCLKState[][2])2921dda4fb85SAurabindo Pillai void dml32_UseMinimumDCFCLK(
2922dda4fb85SAurabindo Pillai enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange[],
2923dda4fb85SAurabindo Pillai bool DRRDisplay[],
2924dda4fb85SAurabindo Pillai bool SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
2925dda4fb85SAurabindo Pillai unsigned int MaxInterDCNTileRepeaters,
2926dda4fb85SAurabindo Pillai unsigned int MaxPrefetchMode,
2927dda4fb85SAurabindo Pillai double DRAMClockChangeLatencyFinal,
2928dda4fb85SAurabindo Pillai double FCLKChangeLatency,
2929dda4fb85SAurabindo Pillai double SREnterPlusExitTime,
2930dda4fb85SAurabindo Pillai unsigned int ReturnBusWidth,
2931dda4fb85SAurabindo Pillai unsigned int RoundTripPingLatencyCycles,
2932dda4fb85SAurabindo Pillai unsigned int ReorderingBytes,
2933dda4fb85SAurabindo Pillai unsigned int PixelChunkSizeInKByte,
2934dda4fb85SAurabindo Pillai unsigned int MetaChunkSize,
2935dda4fb85SAurabindo Pillai bool GPUVMEnable,
2936dda4fb85SAurabindo Pillai unsigned int GPUVMMaxPageTableLevels,
2937dda4fb85SAurabindo Pillai bool HostVMEnable,
2938dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces,
2939dda4fb85SAurabindo Pillai double HostVMMinPageSize,
2940dda4fb85SAurabindo Pillai unsigned int HostVMMaxNonCachedPageTableLevels,
2941dda4fb85SAurabindo Pillai bool DynamicMetadataVMEnabled,
2942dda4fb85SAurabindo Pillai bool ImmediateFlipRequirement,
2943dda4fb85SAurabindo Pillai bool ProgressiveToInterlaceUnitInOPP,
2944dda4fb85SAurabindo Pillai double MaxAveragePercentOfIdealSDPPortBWDisplayCanUseInNormalSystemOperation,
2945dda4fb85SAurabindo Pillai double PercentOfIdealSDPPortBWReceivedAfterUrgLatency,
2946dda4fb85SAurabindo Pillai unsigned int VTotal[],
2947dda4fb85SAurabindo Pillai unsigned int VActive[],
2948dda4fb85SAurabindo Pillai unsigned int DynamicMetadataTransmittedBytes[],
2949dda4fb85SAurabindo Pillai unsigned int DynamicMetadataLinesBeforeActiveRequired[],
2950dda4fb85SAurabindo Pillai bool Interlace[],
2951dda4fb85SAurabindo Pillai double RequiredDPPCLKPerSurface[][2][DC__NUM_DPP__MAX],
2952dda4fb85SAurabindo Pillai double RequiredDISPCLK[][2],
2953dda4fb85SAurabindo Pillai double UrgLatency[],
2954dda4fb85SAurabindo Pillai unsigned int NoOfDPP[][2][DC__NUM_DPP__MAX],
2955dda4fb85SAurabindo Pillai double ProjectedDCFClkDeepSleep[][2],
2956dda4fb85SAurabindo Pillai double MaximumVStartup[][2][DC__NUM_DPP__MAX],
2957dda4fb85SAurabindo Pillai unsigned int TotalNumberOfActiveDPP[][2],
2958dda4fb85SAurabindo Pillai unsigned int TotalNumberOfDCCActiveDPP[][2],
2959dda4fb85SAurabindo Pillai unsigned int dpte_group_bytes[],
2960dda4fb85SAurabindo Pillai double PrefetchLinesY[][2][DC__NUM_DPP__MAX],
2961dda4fb85SAurabindo Pillai double PrefetchLinesC[][2][DC__NUM_DPP__MAX],
2962dda4fb85SAurabindo Pillai unsigned int swath_width_luma_ub_all_states[][2][DC__NUM_DPP__MAX],
2963dda4fb85SAurabindo Pillai unsigned int swath_width_chroma_ub_all_states[][2][DC__NUM_DPP__MAX],
2964dda4fb85SAurabindo Pillai unsigned int BytePerPixelY[],
2965dda4fb85SAurabindo Pillai unsigned int BytePerPixelC[],
2966dda4fb85SAurabindo Pillai unsigned int HTotal[],
2967dda4fb85SAurabindo Pillai double PixelClock[],
2968dda4fb85SAurabindo Pillai double PDEAndMetaPTEBytesPerFrame[][2][DC__NUM_DPP__MAX],
2969dda4fb85SAurabindo Pillai double DPTEBytesPerRow[][2][DC__NUM_DPP__MAX],
2970dda4fb85SAurabindo Pillai double MetaRowBytes[][2][DC__NUM_DPP__MAX],
2971dda4fb85SAurabindo Pillai bool DynamicMetadataEnable[],
2972dda4fb85SAurabindo Pillai double ReadBandwidthLuma[],
2973dda4fb85SAurabindo Pillai double ReadBandwidthChroma[],
2974dda4fb85SAurabindo Pillai double DCFCLKPerState[],
2975dda4fb85SAurabindo Pillai /* Output */
2976dda4fb85SAurabindo Pillai double DCFCLKState[][2])
2977dda4fb85SAurabindo Pillai {
2978dda4fb85SAurabindo Pillai unsigned int i, j, k;
2979dda4fb85SAurabindo Pillai unsigned int dummy1;
2980dda4fb85SAurabindo Pillai double dummy2, dummy3;
2981dda4fb85SAurabindo Pillai double NormalEfficiency;
2982dda4fb85SAurabindo Pillai double TotalMaxPrefetchFlipDPTERowBandwidth[DC__VOLTAGE_STATES][2];
2983dda4fb85SAurabindo Pillai
2984dda4fb85SAurabindo Pillai NormalEfficiency = PercentOfIdealSDPPortBWReceivedAfterUrgLatency / 100.0;
2985dda4fb85SAurabindo Pillai for (i = 0; i < DC__VOLTAGE_STATES; ++i) {
2986dda4fb85SAurabindo Pillai for (j = 0; j <= 1; ++j) {
2987dda4fb85SAurabindo Pillai double PixelDCFCLKCyclesRequiredInPrefetch[DC__NUM_DPP__MAX];
2988dda4fb85SAurabindo Pillai double PrefetchPixelLinesTime[DC__NUM_DPP__MAX];
2989dda4fb85SAurabindo Pillai double DCFCLKRequiredForPeakBandwidthPerSurface[DC__NUM_DPP__MAX];
2990dda4fb85SAurabindo Pillai double DynamicMetadataVMExtraLatency[DC__NUM_DPP__MAX];
2991dda4fb85SAurabindo Pillai double MinimumTWait = 0.0;
2992dda4fb85SAurabindo Pillai double DPTEBandwidth;
2993dda4fb85SAurabindo Pillai double DCFCLKRequiredForAverageBandwidth;
2994dda4fb85SAurabindo Pillai unsigned int ExtraLatencyBytes;
2995dda4fb85SAurabindo Pillai double ExtraLatencyCycles;
2996dda4fb85SAurabindo Pillai double DCFCLKRequiredForPeakBandwidth;
2997dda4fb85SAurabindo Pillai unsigned int NoOfDPPState[DC__NUM_DPP__MAX];
2998dda4fb85SAurabindo Pillai double MinimumTvmPlus2Tr0;
2999dda4fb85SAurabindo Pillai
3000dda4fb85SAurabindo Pillai TotalMaxPrefetchFlipDPTERowBandwidth[i][j] = 0;
3001dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
3002dda4fb85SAurabindo Pillai TotalMaxPrefetchFlipDPTERowBandwidth[i][j] = TotalMaxPrefetchFlipDPTERowBandwidth[i][j]
3003dda4fb85SAurabindo Pillai + NoOfDPP[i][j][k] * DPTEBytesPerRow[i][j][k]
3004dda4fb85SAurabindo Pillai / (15.75 * HTotal[k] / PixelClock[k]);
3005dda4fb85SAurabindo Pillai }
3006dda4fb85SAurabindo Pillai
3007dda4fb85SAurabindo Pillai for (k = 0; k <= NumberOfActiveSurfaces - 1; ++k)
3008dda4fb85SAurabindo Pillai NoOfDPPState[k] = NoOfDPP[i][j][k];
3009dda4fb85SAurabindo Pillai
3010dda4fb85SAurabindo Pillai DPTEBandwidth = TotalMaxPrefetchFlipDPTERowBandwidth[i][j];
3011dda4fb85SAurabindo Pillai DCFCLKRequiredForAverageBandwidth = dml_max(ProjectedDCFClkDeepSleep[i][j], DPTEBandwidth / NormalEfficiency / ReturnBusWidth);
3012dda4fb85SAurabindo Pillai
3013dda4fb85SAurabindo Pillai ExtraLatencyBytes = dml32_CalculateExtraLatencyBytes(ReorderingBytes,
3014dda4fb85SAurabindo Pillai TotalNumberOfActiveDPP[i][j], PixelChunkSizeInKByte,
3015dda4fb85SAurabindo Pillai TotalNumberOfDCCActiveDPP[i][j], MetaChunkSize, GPUVMEnable, HostVMEnable,
3016dda4fb85SAurabindo Pillai NumberOfActiveSurfaces, NoOfDPPState, dpte_group_bytes, 1, HostVMMinPageSize,
3017dda4fb85SAurabindo Pillai HostVMMaxNonCachedPageTableLevels);
3018dda4fb85SAurabindo Pillai ExtraLatencyCycles = RoundTripPingLatencyCycles + __DML_ARB_TO_RET_DELAY__
3019dda4fb85SAurabindo Pillai + ExtraLatencyBytes / NormalEfficiency / ReturnBusWidth;
3020dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
3021dda4fb85SAurabindo Pillai double DCFCLKCyclesRequiredInPrefetch;
3022dda4fb85SAurabindo Pillai double PrefetchTime;
3023dda4fb85SAurabindo Pillai
3024dda4fb85SAurabindo Pillai PixelDCFCLKCyclesRequiredInPrefetch[k] = (PrefetchLinesY[i][j][k]
3025dda4fb85SAurabindo Pillai * swath_width_luma_ub_all_states[i][j][k] * BytePerPixelY[k]
3026dda4fb85SAurabindo Pillai + PrefetchLinesC[i][j][k] * swath_width_chroma_ub_all_states[i][j][k]
3027dda4fb85SAurabindo Pillai * BytePerPixelC[k]) / NormalEfficiency
3028dda4fb85SAurabindo Pillai / ReturnBusWidth;
3029dda4fb85SAurabindo Pillai DCFCLKCyclesRequiredInPrefetch = 2 * ExtraLatencyCycles / NoOfDPPState[k]
3030dda4fb85SAurabindo Pillai + PDEAndMetaPTEBytesPerFrame[i][j][k] / NormalEfficiency
3031dda4fb85SAurabindo Pillai / NormalEfficiency / ReturnBusWidth
3032dda4fb85SAurabindo Pillai * (GPUVMMaxPageTableLevels > 2 ? 1 : 0)
3033dda4fb85SAurabindo Pillai + 2 * DPTEBytesPerRow[i][j][k] / NormalEfficiency / NormalEfficiency
3034dda4fb85SAurabindo Pillai / ReturnBusWidth
3035dda4fb85SAurabindo Pillai + 2 * MetaRowBytes[i][j][k] / NormalEfficiency / ReturnBusWidth
3036dda4fb85SAurabindo Pillai + PixelDCFCLKCyclesRequiredInPrefetch[k];
3037dda4fb85SAurabindo Pillai PrefetchPixelLinesTime[k] = dml_max(PrefetchLinesY[i][j][k], PrefetchLinesC[i][j][k])
3038dda4fb85SAurabindo Pillai * HTotal[k] / PixelClock[k];
3039dda4fb85SAurabindo Pillai DynamicMetadataVMExtraLatency[k] = (GPUVMEnable == true &&
3040dda4fb85SAurabindo Pillai DynamicMetadataEnable[k] == true && DynamicMetadataVMEnabled == true) ?
3041dda4fb85SAurabindo Pillai UrgLatency[i] * GPUVMMaxPageTableLevels *
3042dda4fb85SAurabindo Pillai (HostVMEnable == true ? HostVMMaxNonCachedPageTableLevels + 1 : 1) : 0;
3043dda4fb85SAurabindo Pillai
3044dda4fb85SAurabindo Pillai MinimumTWait = dml32_CalculateTWait(MaxPrefetchMode,
3045dda4fb85SAurabindo Pillai UseMALLForPStateChange[k],
3046dda4fb85SAurabindo Pillai SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
3047dda4fb85SAurabindo Pillai DRRDisplay[k],
3048dda4fb85SAurabindo Pillai DRAMClockChangeLatencyFinal,
3049dda4fb85SAurabindo Pillai FCLKChangeLatency,
3050dda4fb85SAurabindo Pillai UrgLatency[i],
3051dda4fb85SAurabindo Pillai SREnterPlusExitTime);
3052dda4fb85SAurabindo Pillai
3053dda4fb85SAurabindo Pillai PrefetchTime = (MaximumVStartup[i][j][k] - 1) * HTotal[k] / PixelClock[k] -
3054dda4fb85SAurabindo Pillai MinimumTWait - UrgLatency[i] *
3055dda4fb85SAurabindo Pillai ((GPUVMMaxPageTableLevels <= 2 ? GPUVMMaxPageTableLevels :
3056dda4fb85SAurabindo Pillai GPUVMMaxPageTableLevels - 2) * (HostVMEnable == true ?
3057dda4fb85SAurabindo Pillai HostVMMaxNonCachedPageTableLevels + 1 : 1) - 1) -
3058dda4fb85SAurabindo Pillai DynamicMetadataVMExtraLatency[k];
3059dda4fb85SAurabindo Pillai
3060dda4fb85SAurabindo Pillai if (PrefetchTime > 0) {
3061dda4fb85SAurabindo Pillai double ExpectedVRatioPrefetch;
3062dda4fb85SAurabindo Pillai
3063dda4fb85SAurabindo Pillai ExpectedVRatioPrefetch = PrefetchPixelLinesTime[k] / (PrefetchTime *
3064dda4fb85SAurabindo Pillai PixelDCFCLKCyclesRequiredInPrefetch[k] /
3065dda4fb85SAurabindo Pillai DCFCLKCyclesRequiredInPrefetch);
3066dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidthPerSurface[k] = NoOfDPPState[k] *
3067dda4fb85SAurabindo Pillai PixelDCFCLKCyclesRequiredInPrefetch[k] /
3068dda4fb85SAurabindo Pillai PrefetchPixelLinesTime[k] *
3069dda4fb85SAurabindo Pillai dml_max(1.0, ExpectedVRatioPrefetch) *
3070dda4fb85SAurabindo Pillai dml_max(1.0, ExpectedVRatioPrefetch / 4);
3071dda4fb85SAurabindo Pillai if (HostVMEnable == true || ImmediateFlipRequirement == true) {
3072dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidthPerSurface[k] =
3073dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidthPerSurface[k] +
3074dda4fb85SAurabindo Pillai NoOfDPPState[k] * DPTEBandwidth / NormalEfficiency /
3075dda4fb85SAurabindo Pillai NormalEfficiency / ReturnBusWidth;
3076dda4fb85SAurabindo Pillai }
3077dda4fb85SAurabindo Pillai } else {
3078dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidthPerSurface[k] = DCFCLKPerState[i];
3079dda4fb85SAurabindo Pillai }
3080dda4fb85SAurabindo Pillai if (DynamicMetadataEnable[k] == true) {
3081dda4fb85SAurabindo Pillai double TSetupPipe;
3082dda4fb85SAurabindo Pillai double TdmbfPipe;
3083dda4fb85SAurabindo Pillai double TdmsksPipe;
3084dda4fb85SAurabindo Pillai double TdmecPipe;
3085dda4fb85SAurabindo Pillai double AllowedTimeForUrgentExtraLatency;
3086dda4fb85SAurabindo Pillai
3087dda4fb85SAurabindo Pillai dml32_CalculateVUpdateAndDynamicMetadataParameters(
3088dda4fb85SAurabindo Pillai MaxInterDCNTileRepeaters,
3089dda4fb85SAurabindo Pillai RequiredDPPCLKPerSurface[i][j][k],
3090dda4fb85SAurabindo Pillai RequiredDISPCLK[i][j],
3091dda4fb85SAurabindo Pillai ProjectedDCFClkDeepSleep[i][j],
3092dda4fb85SAurabindo Pillai PixelClock[k],
3093dda4fb85SAurabindo Pillai HTotal[k],
3094dda4fb85SAurabindo Pillai VTotal[k] - VActive[k],
3095dda4fb85SAurabindo Pillai DynamicMetadataTransmittedBytes[k],
3096dda4fb85SAurabindo Pillai DynamicMetadataLinesBeforeActiveRequired[k],
3097dda4fb85SAurabindo Pillai Interlace[k],
3098dda4fb85SAurabindo Pillai ProgressiveToInterlaceUnitInOPP,
3099dda4fb85SAurabindo Pillai
3100dda4fb85SAurabindo Pillai /* output */
3101dda4fb85SAurabindo Pillai &TSetupPipe,
3102dda4fb85SAurabindo Pillai &TdmbfPipe,
3103dda4fb85SAurabindo Pillai &TdmecPipe,
3104dda4fb85SAurabindo Pillai &TdmsksPipe,
3105dda4fb85SAurabindo Pillai &dummy1,
3106dda4fb85SAurabindo Pillai &dummy2,
3107dda4fb85SAurabindo Pillai &dummy3);
3108dda4fb85SAurabindo Pillai AllowedTimeForUrgentExtraLatency = MaximumVStartup[i][j][k] * HTotal[k] /
3109dda4fb85SAurabindo Pillai PixelClock[k] - MinimumTWait - TSetupPipe - TdmbfPipe -
3110dda4fb85SAurabindo Pillai TdmecPipe - TdmsksPipe - DynamicMetadataVMExtraLatency[k];
3111dda4fb85SAurabindo Pillai if (AllowedTimeForUrgentExtraLatency > 0)
3112dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidthPerSurface[k] =
3113dda4fb85SAurabindo Pillai dml_max(DCFCLKRequiredForPeakBandwidthPerSurface[k],
3114dda4fb85SAurabindo Pillai ExtraLatencyCycles / AllowedTimeForUrgentExtraLatency);
3115dda4fb85SAurabindo Pillai else
3116dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidthPerSurface[k] = DCFCLKPerState[i];
3117dda4fb85SAurabindo Pillai }
3118dda4fb85SAurabindo Pillai }
3119dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidth = 0;
3120dda4fb85SAurabindo Pillai for (k = 0; k <= NumberOfActiveSurfaces - 1; ++k) {
3121dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidth = DCFCLKRequiredForPeakBandwidth +
3122dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidthPerSurface[k];
3123dda4fb85SAurabindo Pillai }
3124dda4fb85SAurabindo Pillai MinimumTvmPlus2Tr0 = UrgLatency[i] * (GPUVMEnable == true ?
3125dda4fb85SAurabindo Pillai (HostVMEnable == true ? (GPUVMMaxPageTableLevels + 2) *
3126dda4fb85SAurabindo Pillai (HostVMMaxNonCachedPageTableLevels + 1) - 1 : GPUVMMaxPageTableLevels + 1) : 0);
3127dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
3128dda4fb85SAurabindo Pillai double MaximumTvmPlus2Tr0PlusTsw;
3129dda4fb85SAurabindo Pillai
3130dda4fb85SAurabindo Pillai MaximumTvmPlus2Tr0PlusTsw = (MaximumVStartup[i][j][k] - 2) * HTotal[k] /
3131dda4fb85SAurabindo Pillai PixelClock[k] - MinimumTWait - DynamicMetadataVMExtraLatency[k];
3132dda4fb85SAurabindo Pillai if (MaximumTvmPlus2Tr0PlusTsw <= MinimumTvmPlus2Tr0 + PrefetchPixelLinesTime[k] / 4) {
3133dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidth = DCFCLKPerState[i];
3134dda4fb85SAurabindo Pillai } else {
3135dda4fb85SAurabindo Pillai DCFCLKRequiredForPeakBandwidth = dml_max3(DCFCLKRequiredForPeakBandwidth,
3136dda4fb85SAurabindo Pillai 2 * ExtraLatencyCycles / (MaximumTvmPlus2Tr0PlusTsw -
3137dda4fb85SAurabindo Pillai MinimumTvmPlus2Tr0 -
3138dda4fb85SAurabindo Pillai PrefetchPixelLinesTime[k] / 4),
3139dda4fb85SAurabindo Pillai (2 * ExtraLatencyCycles +
3140dda4fb85SAurabindo Pillai PixelDCFCLKCyclesRequiredInPrefetch[k]) /
3141dda4fb85SAurabindo Pillai (MaximumTvmPlus2Tr0PlusTsw - MinimumTvmPlus2Tr0));
3142dda4fb85SAurabindo Pillai }
3143dda4fb85SAurabindo Pillai }
3144dda4fb85SAurabindo Pillai DCFCLKState[i][j] = dml_min(DCFCLKPerState[i], 1.05 *
3145dda4fb85SAurabindo Pillai dml_max(DCFCLKRequiredForAverageBandwidth, DCFCLKRequiredForPeakBandwidth));
3146dda4fb85SAurabindo Pillai }
3147dda4fb85SAurabindo Pillai }
3148dda4fb85SAurabindo Pillai }
3149dda4fb85SAurabindo Pillai
dml32_CalculateExtraLatencyBytes(unsigned int ReorderingBytes,unsigned int TotalNumberOfActiveDPP,unsigned int PixelChunkSizeInKByte,unsigned int TotalNumberOfDCCActiveDPP,unsigned int MetaChunkSize,bool GPUVMEnable,bool HostVMEnable,unsigned int NumberOfActiveSurfaces,unsigned int NumberOfDPP[],unsigned int dpte_group_bytes[],double HostVMInefficiencyFactor,double HostVMMinPageSize,unsigned int HostVMMaxNonCachedPageTableLevels)3150dda4fb85SAurabindo Pillai unsigned int dml32_CalculateExtraLatencyBytes(unsigned int ReorderingBytes,
3151dda4fb85SAurabindo Pillai unsigned int TotalNumberOfActiveDPP,
3152dda4fb85SAurabindo Pillai unsigned int PixelChunkSizeInKByte,
3153dda4fb85SAurabindo Pillai unsigned int TotalNumberOfDCCActiveDPP,
3154dda4fb85SAurabindo Pillai unsigned int MetaChunkSize,
3155dda4fb85SAurabindo Pillai bool GPUVMEnable,
3156dda4fb85SAurabindo Pillai bool HostVMEnable,
3157dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces,
3158dda4fb85SAurabindo Pillai unsigned int NumberOfDPP[],
3159dda4fb85SAurabindo Pillai unsigned int dpte_group_bytes[],
3160dda4fb85SAurabindo Pillai double HostVMInefficiencyFactor,
3161dda4fb85SAurabindo Pillai double HostVMMinPageSize,
3162dda4fb85SAurabindo Pillai unsigned int HostVMMaxNonCachedPageTableLevels)
3163dda4fb85SAurabindo Pillai {
3164dda4fb85SAurabindo Pillai unsigned int k;
3165dda4fb85SAurabindo Pillai double ret;
3166dda4fb85SAurabindo Pillai unsigned int HostVMDynamicLevels;
3167dda4fb85SAurabindo Pillai
3168dda4fb85SAurabindo Pillai if (GPUVMEnable == true && HostVMEnable == true) {
3169dda4fb85SAurabindo Pillai if (HostVMMinPageSize < 2048)
3170dda4fb85SAurabindo Pillai HostVMDynamicLevels = HostVMMaxNonCachedPageTableLevels;
3171dda4fb85SAurabindo Pillai else if (HostVMMinPageSize >= 2048 && HostVMMinPageSize < 1048576)
3172dda4fb85SAurabindo Pillai HostVMDynamicLevels = dml_max(0, (int) HostVMMaxNonCachedPageTableLevels - 1);
3173dda4fb85SAurabindo Pillai else
3174dda4fb85SAurabindo Pillai HostVMDynamicLevels = dml_max(0, (int) HostVMMaxNonCachedPageTableLevels - 2);
3175dda4fb85SAurabindo Pillai } else {
3176dda4fb85SAurabindo Pillai HostVMDynamicLevels = 0;
3177dda4fb85SAurabindo Pillai }
3178dda4fb85SAurabindo Pillai
3179dda4fb85SAurabindo Pillai ret = ReorderingBytes + (TotalNumberOfActiveDPP * PixelChunkSizeInKByte +
3180dda4fb85SAurabindo Pillai TotalNumberOfDCCActiveDPP * MetaChunkSize) * 1024.0;
3181dda4fb85SAurabindo Pillai
3182dda4fb85SAurabindo Pillai if (GPUVMEnable == true) {
3183dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
3184dda4fb85SAurabindo Pillai ret = ret + NumberOfDPP[k] * dpte_group_bytes[k] *
3185dda4fb85SAurabindo Pillai (1 + 8 * HostVMDynamicLevels) * HostVMInefficiencyFactor;
3186dda4fb85SAurabindo Pillai }
3187dda4fb85SAurabindo Pillai }
3188dda4fb85SAurabindo Pillai return ret;
3189dda4fb85SAurabindo Pillai }
3190dda4fb85SAurabindo Pillai
dml32_CalculateVUpdateAndDynamicMetadataParameters(unsigned int MaxInterDCNTileRepeaters,double Dppclk,double Dispclk,double DCFClkDeepSleep,double PixelClock,unsigned int HTotal,unsigned int VBlank,unsigned int DynamicMetadataTransmittedBytes,unsigned int DynamicMetadataLinesBeforeActiveRequired,unsigned int InterlaceEnable,bool ProgressiveToInterlaceUnitInOPP,double * TSetup,double * Tdmbf,double * Tdmec,double * Tdmsks,unsigned int * VUpdateOffsetPix,double * VUpdateWidthPix,double * VReadyOffsetPix)3191dda4fb85SAurabindo Pillai void dml32_CalculateVUpdateAndDynamicMetadataParameters(
3192dda4fb85SAurabindo Pillai unsigned int MaxInterDCNTileRepeaters,
3193dda4fb85SAurabindo Pillai double Dppclk,
3194dda4fb85SAurabindo Pillai double Dispclk,
3195dda4fb85SAurabindo Pillai double DCFClkDeepSleep,
3196dda4fb85SAurabindo Pillai double PixelClock,
3197dda4fb85SAurabindo Pillai unsigned int HTotal,
3198dda4fb85SAurabindo Pillai unsigned int VBlank,
3199dda4fb85SAurabindo Pillai unsigned int DynamicMetadataTransmittedBytes,
3200dda4fb85SAurabindo Pillai unsigned int DynamicMetadataLinesBeforeActiveRequired,
3201dda4fb85SAurabindo Pillai unsigned int InterlaceEnable,
3202dda4fb85SAurabindo Pillai bool ProgressiveToInterlaceUnitInOPP,
3203dda4fb85SAurabindo Pillai
3204dda4fb85SAurabindo Pillai /* output */
3205dda4fb85SAurabindo Pillai double *TSetup,
3206dda4fb85SAurabindo Pillai double *Tdmbf,
3207dda4fb85SAurabindo Pillai double *Tdmec,
3208dda4fb85SAurabindo Pillai double *Tdmsks,
3209dda4fb85SAurabindo Pillai unsigned int *VUpdateOffsetPix,
3210dda4fb85SAurabindo Pillai double *VUpdateWidthPix,
3211dda4fb85SAurabindo Pillai double *VReadyOffsetPix)
3212dda4fb85SAurabindo Pillai {
3213dda4fb85SAurabindo Pillai double TotalRepeaterDelayTime;
3214dda4fb85SAurabindo Pillai
3215dda4fb85SAurabindo Pillai TotalRepeaterDelayTime = MaxInterDCNTileRepeaters * (2 / Dppclk + 3 / Dispclk);
3216dda4fb85SAurabindo Pillai *VUpdateWidthPix =
3217dda4fb85SAurabindo Pillai dml_ceil((14.0 / DCFClkDeepSleep + 12.0 / Dppclk + TotalRepeaterDelayTime) * PixelClock, 1.0);
3218dda4fb85SAurabindo Pillai *VReadyOffsetPix = dml_ceil(dml_max(150.0 / Dppclk,
3219dda4fb85SAurabindo Pillai TotalRepeaterDelayTime + 20.0 / DCFClkDeepSleep + 10.0 / Dppclk) * PixelClock, 1.0);
3220dda4fb85SAurabindo Pillai *VUpdateOffsetPix = dml_ceil(HTotal / 4.0, 1.0);
3221dda4fb85SAurabindo Pillai *TSetup = (*VUpdateOffsetPix + *VUpdateWidthPix + *VReadyOffsetPix) / PixelClock;
3222dda4fb85SAurabindo Pillai *Tdmbf = DynamicMetadataTransmittedBytes / 4.0 / Dispclk;
3223dda4fb85SAurabindo Pillai *Tdmec = HTotal / PixelClock;
3224dda4fb85SAurabindo Pillai
3225dda4fb85SAurabindo Pillai if (DynamicMetadataLinesBeforeActiveRequired == 0)
3226dda4fb85SAurabindo Pillai *Tdmsks = VBlank * HTotal / PixelClock / 2.0;
3227dda4fb85SAurabindo Pillai else
3228dda4fb85SAurabindo Pillai *Tdmsks = DynamicMetadataLinesBeforeActiveRequired * HTotal / PixelClock;
3229dda4fb85SAurabindo Pillai
3230dda4fb85SAurabindo Pillai if (InterlaceEnable == 1 && ProgressiveToInterlaceUnitInOPP == false)
3231dda4fb85SAurabindo Pillai *Tdmsks = *Tdmsks / 2;
3232dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3233dda4fb85SAurabindo Pillai dml_print("DML::%s: VUpdateWidthPix = %d\n", __func__, *VUpdateWidthPix);
3234dda4fb85SAurabindo Pillai dml_print("DML::%s: VReadyOffsetPix = %d\n", __func__, *VReadyOffsetPix);
3235dda4fb85SAurabindo Pillai dml_print("DML::%s: VUpdateOffsetPix = %d\n", __func__, *VUpdateOffsetPix);
3236dda4fb85SAurabindo Pillai
3237dda4fb85SAurabindo Pillai dml_print("DML::%s: DynamicMetadataLinesBeforeActiveRequired = %d\n",
3238dda4fb85SAurabindo Pillai __func__, DynamicMetadataLinesBeforeActiveRequired);
3239dda4fb85SAurabindo Pillai dml_print("DML::%s: VBlank = %d\n", __func__, VBlank);
3240dda4fb85SAurabindo Pillai dml_print("DML::%s: HTotal = %d\n", __func__, HTotal);
3241dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelClock = %f\n", __func__, PixelClock);
3242dda4fb85SAurabindo Pillai dml_print("DML::%s: Tdmsks = %f\n", __func__, *Tdmsks);
3243dda4fb85SAurabindo Pillai #endif
3244dda4fb85SAurabindo Pillai }
3245dda4fb85SAurabindo Pillai
dml32_CalculateTWait(unsigned int PrefetchMode,enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange,bool SynchronizeDRRDisplaysForUCLKPStateChangeFinal,bool DRRDisplay,double DRAMClockChangeLatency,double FCLKChangeLatency,double UrgentLatency,double SREnterPlusExitTime)3246dda4fb85SAurabindo Pillai double dml32_CalculateTWait(
3247dda4fb85SAurabindo Pillai unsigned int PrefetchMode,
3248dda4fb85SAurabindo Pillai enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange,
3249dda4fb85SAurabindo Pillai bool SynchronizeDRRDisplaysForUCLKPStateChangeFinal,
3250dda4fb85SAurabindo Pillai bool DRRDisplay,
3251dda4fb85SAurabindo Pillai double DRAMClockChangeLatency,
3252dda4fb85SAurabindo Pillai double FCLKChangeLatency,
3253dda4fb85SAurabindo Pillai double UrgentLatency,
3254dda4fb85SAurabindo Pillai double SREnterPlusExitTime)
3255dda4fb85SAurabindo Pillai {
3256dda4fb85SAurabindo Pillai double TWait = 0.0;
3257dda4fb85SAurabindo Pillai
3258dda4fb85SAurabindo Pillai if (PrefetchMode == 0 &&
3259dda4fb85SAurabindo Pillai !(UseMALLForPStateChange == dm_use_mall_pstate_change_full_frame) &&
3260dda4fb85SAurabindo Pillai !(UseMALLForPStateChange == dm_use_mall_pstate_change_sub_viewport) &&
3261dda4fb85SAurabindo Pillai !(UseMALLForPStateChange == dm_use_mall_pstate_change_phantom_pipe) &&
3262dda4fb85SAurabindo Pillai !(SynchronizeDRRDisplaysForUCLKPStateChangeFinal && DRRDisplay)) {
3263dda4fb85SAurabindo Pillai TWait = dml_max3(DRAMClockChangeLatency + UrgentLatency, SREnterPlusExitTime, UrgentLatency);
3264dda4fb85SAurabindo Pillai } else if (PrefetchMode <= 1 && !(UseMALLForPStateChange == dm_use_mall_pstate_change_phantom_pipe)) {
3265dda4fb85SAurabindo Pillai TWait = dml_max3(FCLKChangeLatency + UrgentLatency, SREnterPlusExitTime, UrgentLatency);
3266dda4fb85SAurabindo Pillai } else if (PrefetchMode <= 2 && !(UseMALLForPStateChange == dm_use_mall_pstate_change_phantom_pipe)) {
3267dda4fb85SAurabindo Pillai TWait = dml_max(SREnterPlusExitTime, UrgentLatency);
3268dda4fb85SAurabindo Pillai } else {
3269dda4fb85SAurabindo Pillai TWait = UrgentLatency;
3270dda4fb85SAurabindo Pillai }
3271dda4fb85SAurabindo Pillai
3272dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3273dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchMode = %d\n", __func__, PrefetchMode);
3274dda4fb85SAurabindo Pillai dml_print("DML::%s: TWait = %f\n", __func__, TWait);
3275dda4fb85SAurabindo Pillai #endif
3276dda4fb85SAurabindo Pillai return TWait;
3277dda4fb85SAurabindo Pillai } // CalculateTWait
3278dda4fb85SAurabindo Pillai
3279dda4fb85SAurabindo Pillai // Function: get_return_bw_mbps
3280dda4fb85SAurabindo Pillai // Megabyte per second
dml32_get_return_bw_mbps(const soc_bounding_box_st * soc,const int VoltageLevel,const bool HostVMEnable,const double DCFCLK,const double FabricClock,const double DRAMSpeed)3281dda4fb85SAurabindo Pillai double dml32_get_return_bw_mbps(const soc_bounding_box_st *soc,
3282dda4fb85SAurabindo Pillai const int VoltageLevel,
3283dda4fb85SAurabindo Pillai const bool HostVMEnable,
3284dda4fb85SAurabindo Pillai const double DCFCLK,
3285dda4fb85SAurabindo Pillai const double FabricClock,
3286dda4fb85SAurabindo Pillai const double DRAMSpeed)
3287dda4fb85SAurabindo Pillai {
3288dda4fb85SAurabindo Pillai double ReturnBW = 0.;
3289dda4fb85SAurabindo Pillai double IdealSDPPortBandwidth = soc->return_bus_width_bytes /*mode_lib->vba.ReturnBusWidth*/ * DCFCLK;
3290dda4fb85SAurabindo Pillai double IdealFabricBandwidth = FabricClock * soc->fabric_datapath_to_dcn_data_return_bytes;
3291dda4fb85SAurabindo Pillai double IdealDRAMBandwidth = DRAMSpeed * soc->num_chans * soc->dram_channel_width_bytes;
3292dda4fb85SAurabindo Pillai double PixelDataOnlyReturnBW = dml_min3(IdealSDPPortBandwidth * soc->pct_ideal_sdp_bw_after_urgent / 100,
3293dda4fb85SAurabindo Pillai IdealFabricBandwidth * soc->pct_ideal_fabric_bw_after_urgent / 100,
3294dda4fb85SAurabindo Pillai IdealDRAMBandwidth * (VoltageLevel < 2 ? soc->pct_ideal_dram_bw_after_urgent_strobe :
3295dda4fb85SAurabindo Pillai soc->pct_ideal_dram_sdp_bw_after_urgent_pixel_only) / 100);
3296dda4fb85SAurabindo Pillai double PixelMixedWithVMDataReturnBW = dml_min3(IdealSDPPortBandwidth * soc->pct_ideal_sdp_bw_after_urgent / 100,
3297dda4fb85SAurabindo Pillai IdealFabricBandwidth * soc->pct_ideal_fabric_bw_after_urgent / 100,
3298dda4fb85SAurabindo Pillai IdealDRAMBandwidth * (VoltageLevel < 2 ? soc->pct_ideal_dram_bw_after_urgent_strobe :
3299dda4fb85SAurabindo Pillai soc->pct_ideal_dram_sdp_bw_after_urgent_pixel_only) / 100);
3300dda4fb85SAurabindo Pillai
3301dda4fb85SAurabindo Pillai if (HostVMEnable != true)
3302dda4fb85SAurabindo Pillai ReturnBW = PixelDataOnlyReturnBW;
3303dda4fb85SAurabindo Pillai else
3304dda4fb85SAurabindo Pillai ReturnBW = PixelMixedWithVMDataReturnBW;
3305dda4fb85SAurabindo Pillai
3306dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3307dda4fb85SAurabindo Pillai dml_print("DML::%s: VoltageLevel = %d\n", __func__, VoltageLevel);
3308dda4fb85SAurabindo Pillai dml_print("DML::%s: HostVMEnable = %d\n", __func__, HostVMEnable);
3309dda4fb85SAurabindo Pillai dml_print("DML::%s: DCFCLK = %f\n", __func__, DCFCLK);
3310dda4fb85SAurabindo Pillai dml_print("DML::%s: FabricClock = %f\n", __func__, FabricClock);
3311dda4fb85SAurabindo Pillai dml_print("DML::%s: DRAMSpeed = %f\n", __func__, DRAMSpeed);
3312dda4fb85SAurabindo Pillai dml_print("DML::%s: IdealSDPPortBandwidth = %f\n", __func__, IdealSDPPortBandwidth);
3313dda4fb85SAurabindo Pillai dml_print("DML::%s: IdealFabricBandwidth = %f\n", __func__, IdealFabricBandwidth);
3314dda4fb85SAurabindo Pillai dml_print("DML::%s: IdealDRAMBandwidth = %f\n", __func__, IdealDRAMBandwidth);
3315dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelDataOnlyReturnBW = %f\n", __func__, PixelDataOnlyReturnBW);
3316dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelMixedWithVMDataReturnBW = %f\n", __func__, PixelMixedWithVMDataReturnBW);
3317dda4fb85SAurabindo Pillai dml_print("DML::%s: ReturnBW = %f MBps\n", __func__, ReturnBW);
3318dda4fb85SAurabindo Pillai #endif
3319dda4fb85SAurabindo Pillai return ReturnBW;
3320dda4fb85SAurabindo Pillai }
3321dda4fb85SAurabindo Pillai
3322dda4fb85SAurabindo Pillai // Function: get_return_bw_mbps_vm_only
3323dda4fb85SAurabindo Pillai // Megabyte per second
dml32_get_return_bw_mbps_vm_only(const soc_bounding_box_st * soc,const int VoltageLevel,const double DCFCLK,const double FabricClock,const double DRAMSpeed)3324dda4fb85SAurabindo Pillai double dml32_get_return_bw_mbps_vm_only(const soc_bounding_box_st *soc,
3325dda4fb85SAurabindo Pillai const int VoltageLevel,
3326dda4fb85SAurabindo Pillai const double DCFCLK,
3327dda4fb85SAurabindo Pillai const double FabricClock,
3328dda4fb85SAurabindo Pillai const double DRAMSpeed)
3329dda4fb85SAurabindo Pillai {
3330dda4fb85SAurabindo Pillai double VMDataOnlyReturnBW = dml_min3(
3331dda4fb85SAurabindo Pillai soc->return_bus_width_bytes * DCFCLK * soc->pct_ideal_sdp_bw_after_urgent / 100.0,
3332dda4fb85SAurabindo Pillai FabricClock * soc->fabric_datapath_to_dcn_data_return_bytes
3333dda4fb85SAurabindo Pillai * soc->pct_ideal_sdp_bw_after_urgent / 100.0,
3334dda4fb85SAurabindo Pillai DRAMSpeed * soc->num_chans * soc->dram_channel_width_bytes
3335dda4fb85SAurabindo Pillai * (VoltageLevel < 2 ?
3336dda4fb85SAurabindo Pillai soc->pct_ideal_dram_bw_after_urgent_strobe :
3337dda4fb85SAurabindo Pillai soc->pct_ideal_dram_sdp_bw_after_urgent_vm_only) / 100.0);
3338dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3339dda4fb85SAurabindo Pillai dml_print("DML::%s: VoltageLevel = %d\n", __func__, VoltageLevel);
3340dda4fb85SAurabindo Pillai dml_print("DML::%s: DCFCLK = %f\n", __func__, DCFCLK);
3341dda4fb85SAurabindo Pillai dml_print("DML::%s: FabricClock = %f\n", __func__, FabricClock);
3342dda4fb85SAurabindo Pillai dml_print("DML::%s: DRAMSpeed = %f\n", __func__, DRAMSpeed);
3343dda4fb85SAurabindo Pillai dml_print("DML::%s: VMDataOnlyReturnBW = %f\n", __func__, VMDataOnlyReturnBW);
3344dda4fb85SAurabindo Pillai #endif
3345dda4fb85SAurabindo Pillai return VMDataOnlyReturnBW;
3346dda4fb85SAurabindo Pillai }
3347dda4fb85SAurabindo Pillai
dml32_CalculateExtraLatency(unsigned int RoundTripPingLatencyCycles,unsigned int ReorderingBytes,double DCFCLK,unsigned int TotalNumberOfActiveDPP,unsigned int PixelChunkSizeInKByte,unsigned int TotalNumberOfDCCActiveDPP,unsigned int MetaChunkSize,double ReturnBW,bool GPUVMEnable,bool HostVMEnable,unsigned int NumberOfActiveSurfaces,unsigned int NumberOfDPP[],unsigned int dpte_group_bytes[],double HostVMInefficiencyFactor,double HostVMMinPageSize,unsigned int HostVMMaxNonCachedPageTableLevels)3348dda4fb85SAurabindo Pillai double dml32_CalculateExtraLatency(
3349dda4fb85SAurabindo Pillai unsigned int RoundTripPingLatencyCycles,
3350dda4fb85SAurabindo Pillai unsigned int ReorderingBytes,
3351dda4fb85SAurabindo Pillai double DCFCLK,
3352dda4fb85SAurabindo Pillai unsigned int TotalNumberOfActiveDPP,
3353dda4fb85SAurabindo Pillai unsigned int PixelChunkSizeInKByte,
3354dda4fb85SAurabindo Pillai unsigned int TotalNumberOfDCCActiveDPP,
3355dda4fb85SAurabindo Pillai unsigned int MetaChunkSize,
3356dda4fb85SAurabindo Pillai double ReturnBW,
3357dda4fb85SAurabindo Pillai bool GPUVMEnable,
3358dda4fb85SAurabindo Pillai bool HostVMEnable,
3359dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces,
3360dda4fb85SAurabindo Pillai unsigned int NumberOfDPP[],
3361dda4fb85SAurabindo Pillai unsigned int dpte_group_bytes[],
3362dda4fb85SAurabindo Pillai double HostVMInefficiencyFactor,
3363dda4fb85SAurabindo Pillai double HostVMMinPageSize,
3364dda4fb85SAurabindo Pillai unsigned int HostVMMaxNonCachedPageTableLevels)
3365dda4fb85SAurabindo Pillai {
3366dda4fb85SAurabindo Pillai double ExtraLatencyBytes;
3367dda4fb85SAurabindo Pillai double ExtraLatency;
3368dda4fb85SAurabindo Pillai
3369dda4fb85SAurabindo Pillai ExtraLatencyBytes = dml32_CalculateExtraLatencyBytes(
3370dda4fb85SAurabindo Pillai ReorderingBytes,
3371dda4fb85SAurabindo Pillai TotalNumberOfActiveDPP,
3372dda4fb85SAurabindo Pillai PixelChunkSizeInKByte,
3373dda4fb85SAurabindo Pillai TotalNumberOfDCCActiveDPP,
3374dda4fb85SAurabindo Pillai MetaChunkSize,
3375dda4fb85SAurabindo Pillai GPUVMEnable,
3376dda4fb85SAurabindo Pillai HostVMEnable,
3377dda4fb85SAurabindo Pillai NumberOfActiveSurfaces,
3378dda4fb85SAurabindo Pillai NumberOfDPP,
3379dda4fb85SAurabindo Pillai dpte_group_bytes,
3380dda4fb85SAurabindo Pillai HostVMInefficiencyFactor,
3381dda4fb85SAurabindo Pillai HostVMMinPageSize,
3382dda4fb85SAurabindo Pillai HostVMMaxNonCachedPageTableLevels);
3383dda4fb85SAurabindo Pillai
3384dda4fb85SAurabindo Pillai ExtraLatency = (RoundTripPingLatencyCycles + __DML_ARB_TO_RET_DELAY__) / DCFCLK + ExtraLatencyBytes / ReturnBW;
3385dda4fb85SAurabindo Pillai
3386dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3387dda4fb85SAurabindo Pillai dml_print("DML::%s: RoundTripPingLatencyCycles=%d\n", __func__, RoundTripPingLatencyCycles);
3388dda4fb85SAurabindo Pillai dml_print("DML::%s: DCFCLK=%f\n", __func__, DCFCLK);
3389dda4fb85SAurabindo Pillai dml_print("DML::%s: ExtraLatencyBytes=%f\n", __func__, ExtraLatencyBytes);
3390dda4fb85SAurabindo Pillai dml_print("DML::%s: ReturnBW=%f\n", __func__, ReturnBW);
3391dda4fb85SAurabindo Pillai dml_print("DML::%s: ExtraLatency=%f\n", __func__, ExtraLatency);
3392dda4fb85SAurabindo Pillai #endif
3393dda4fb85SAurabindo Pillai
3394dda4fb85SAurabindo Pillai return ExtraLatency;
3395dda4fb85SAurabindo Pillai } // CalculateExtraLatency
3396dda4fb85SAurabindo Pillai
dml32_CalculatePrefetchSchedule(struct vba_vars_st * v,unsigned int k,double HostVMInefficiencyFactor,DmlPipe * myPipe,unsigned int DSCDelay,unsigned int DPP_RECOUT_WIDTH,unsigned int VStartup,unsigned int MaxVStartup,double UrgentLatency,double UrgentExtraLatency,double TCalc,unsigned int PDEAndMetaPTEBytesFrame,unsigned int MetaRowByte,unsigned int PixelPTEBytesPerRow,double PrefetchSourceLinesY,unsigned int SwathWidthY,unsigned int VInitPreFillY,unsigned int MaxNumSwathY,double PrefetchSourceLinesC,unsigned int SwathWidthC,unsigned int VInitPreFillC,unsigned int MaxNumSwathC,unsigned int swath_width_luma_ub,unsigned int swath_width_chroma_ub,unsigned int SwathHeightY,unsigned int SwathHeightC,double TWait,double TPreReq,bool ExtendPrefetchIfPossible,double * DSTXAfterScaler,double * DSTYAfterScaler,double * DestinationLinesForPrefetch,double * PrefetchBandwidth,double * DestinationLinesToRequestVMInVBlank,double * DestinationLinesToRequestRowInVBlank,double * VRatioPrefetchY,double * VRatioPrefetchC,double * RequiredPrefetchPixDataBWLuma,double * RequiredPrefetchPixDataBWChroma,bool * NotEnoughTimeForDynamicMetadata,double * Tno_bw,double * prefetch_vmrow_bw,double * Tdmdl_vm,double * Tdmdl,double * TSetup,unsigned int * VUpdateOffsetPix,double * VUpdateWidthPix,double * VReadyOffsetPix)3397dda4fb85SAurabindo Pillai bool dml32_CalculatePrefetchSchedule(
33983b4e83a2SNathan Chancellor struct vba_vars_st *v,
33993b4e83a2SNathan Chancellor unsigned int k,
3400dda4fb85SAurabindo Pillai double HostVMInefficiencyFactor,
3401dda4fb85SAurabindo Pillai DmlPipe *myPipe,
3402dda4fb85SAurabindo Pillai unsigned int DSCDelay,
3403dda4fb85SAurabindo Pillai unsigned int DPP_RECOUT_WIDTH,
3404dda4fb85SAurabindo Pillai unsigned int VStartup,
3405dda4fb85SAurabindo Pillai unsigned int MaxVStartup,
3406dda4fb85SAurabindo Pillai double UrgentLatency,
3407dda4fb85SAurabindo Pillai double UrgentExtraLatency,
3408dda4fb85SAurabindo Pillai double TCalc,
3409dda4fb85SAurabindo Pillai unsigned int PDEAndMetaPTEBytesFrame,
3410dda4fb85SAurabindo Pillai unsigned int MetaRowByte,
3411dda4fb85SAurabindo Pillai unsigned int PixelPTEBytesPerRow,
3412dda4fb85SAurabindo Pillai double PrefetchSourceLinesY,
3413dda4fb85SAurabindo Pillai unsigned int SwathWidthY,
3414dda4fb85SAurabindo Pillai unsigned int VInitPreFillY,
3415dda4fb85SAurabindo Pillai unsigned int MaxNumSwathY,
3416dda4fb85SAurabindo Pillai double PrefetchSourceLinesC,
3417dda4fb85SAurabindo Pillai unsigned int SwathWidthC,
3418dda4fb85SAurabindo Pillai unsigned int VInitPreFillC,
3419dda4fb85SAurabindo Pillai unsigned int MaxNumSwathC,
3420dda4fb85SAurabindo Pillai unsigned int swath_width_luma_ub,
3421dda4fb85SAurabindo Pillai unsigned int swath_width_chroma_ub,
3422dda4fb85SAurabindo Pillai unsigned int SwathHeightY,
3423dda4fb85SAurabindo Pillai unsigned int SwathHeightC,
3424dda4fb85SAurabindo Pillai double TWait,
342501c0c124SDillon Varone double TPreReq,
3426*6750d1deSAlvin Lee bool ExtendPrefetchIfPossible,
3427dda4fb85SAurabindo Pillai /* Output */
3428dda4fb85SAurabindo Pillai double *DSTXAfterScaler,
3429dda4fb85SAurabindo Pillai double *DSTYAfterScaler,
3430dda4fb85SAurabindo Pillai double *DestinationLinesForPrefetch,
3431dda4fb85SAurabindo Pillai double *PrefetchBandwidth,
3432dda4fb85SAurabindo Pillai double *DestinationLinesToRequestVMInVBlank,
3433dda4fb85SAurabindo Pillai double *DestinationLinesToRequestRowInVBlank,
3434dda4fb85SAurabindo Pillai double *VRatioPrefetchY,
3435dda4fb85SAurabindo Pillai double *VRatioPrefetchC,
3436dda4fb85SAurabindo Pillai double *RequiredPrefetchPixDataBWLuma,
3437dda4fb85SAurabindo Pillai double *RequiredPrefetchPixDataBWChroma,
3438dda4fb85SAurabindo Pillai bool *NotEnoughTimeForDynamicMetadata,
3439dda4fb85SAurabindo Pillai double *Tno_bw,
3440dda4fb85SAurabindo Pillai double *prefetch_vmrow_bw,
3441dda4fb85SAurabindo Pillai double *Tdmdl_vm,
3442dda4fb85SAurabindo Pillai double *Tdmdl,
3443dda4fb85SAurabindo Pillai double *TSetup,
3444dda4fb85SAurabindo Pillai unsigned int *VUpdateOffsetPix,
3445dda4fb85SAurabindo Pillai double *VUpdateWidthPix,
3446dda4fb85SAurabindo Pillai double *VReadyOffsetPix)
3447dda4fb85SAurabindo Pillai {
34483b4e83a2SNathan Chancellor double DPPCLKDelaySubtotalPlusCNVCFormater = v->DPPCLKDelaySubtotal + v->DPPCLKDelayCNVCFormater;
3449dda4fb85SAurabindo Pillai bool MyError = false;
3450efcc9706SRodrigo Siqueira unsigned int DPPCycles, DISPCLKCycles;
3451efcc9706SRodrigo Siqueira double DSTTotalPixelsAfterScaler;
3452efcc9706SRodrigo Siqueira double LineTime;
3453efcc9706SRodrigo Siqueira double dst_y_prefetch_equ;
3454efcc9706SRodrigo Siqueira double prefetch_bw_oto;
3455efcc9706SRodrigo Siqueira double Tvm_oto;
3456efcc9706SRodrigo Siqueira double Tr0_oto;
3457efcc9706SRodrigo Siqueira double Tvm_oto_lines;
3458efcc9706SRodrigo Siqueira double Tr0_oto_lines;
3459efcc9706SRodrigo Siqueira double dst_y_prefetch_oto;
3460efcc9706SRodrigo Siqueira double TimeForFetchingMetaPTE = 0;
3461efcc9706SRodrigo Siqueira double TimeForFetchingRowInVBlank = 0;
3462efcc9706SRodrigo Siqueira double LinesToRequestPrefetchPixelData = 0;
3463735688ebSLeo Ma double LinesForPrefetchBandwidth = 0;
3464efcc9706SRodrigo Siqueira unsigned int HostVMDynamicLevelsTrips;
3465efcc9706SRodrigo Siqueira double trip_to_mem;
3466efcc9706SRodrigo Siqueira double Tvm_trips;
3467efcc9706SRodrigo Siqueira double Tr0_trips;
3468efcc9706SRodrigo Siqueira double Tvm_trips_rounded;
3469efcc9706SRodrigo Siqueira double Tr0_trips_rounded;
3470efcc9706SRodrigo Siqueira double Lsw_oto;
3471efcc9706SRodrigo Siqueira double Tpre_rounded;
3472efcc9706SRodrigo Siqueira double prefetch_bw_equ;
3473efcc9706SRodrigo Siqueira double Tvm_equ;
3474efcc9706SRodrigo Siqueira double Tr0_equ;
3475efcc9706SRodrigo Siqueira double Tdmbf;
3476efcc9706SRodrigo Siqueira double Tdmec;
3477efcc9706SRodrigo Siqueira double Tdmsks;
3478efcc9706SRodrigo Siqueira double prefetch_sw_bytes;
3479efcc9706SRodrigo Siqueira double bytes_pp;
3480efcc9706SRodrigo Siqueira double dep_bytes;
34817cd07d9dSAlvin Lee unsigned int max_vratio_pre = v->MaxVRatioPre;
3482efcc9706SRodrigo Siqueira double min_Lsw;
3483efcc9706SRodrigo Siqueira double Tsw_est1 = 0;
3484efcc9706SRodrigo Siqueira double Tsw_est3 = 0;
3485dda4fb85SAurabindo Pillai
34863b4e83a2SNathan Chancellor if (v->GPUVMEnable == true && v->HostVMEnable == true)
34873b4e83a2SNathan Chancellor HostVMDynamicLevelsTrips = v->HostVMMaxNonCachedPageTableLevels;
3488dda4fb85SAurabindo Pillai else
3489efcc9706SRodrigo Siqueira HostVMDynamicLevelsTrips = 0;
3490dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
34913b4e83a2SNathan Chancellor dml_print("DML::%s: v->GPUVMEnable = %d\n", __func__, v->GPUVMEnable);
34923b4e83a2SNathan Chancellor dml_print("DML::%s: v->GPUVMMaxPageTableLevels = %d\n", __func__, v->GPUVMMaxPageTableLevels);
3493dda4fb85SAurabindo Pillai dml_print("DML::%s: DCCEnable = %d\n", __func__, myPipe->DCCEnable);
34943b4e83a2SNathan Chancellor dml_print("DML::%s: v->HostVMEnable=%d HostVMInefficiencyFactor=%f\n",
34953b4e83a2SNathan Chancellor __func__, v->HostVMEnable, HostVMInefficiencyFactor);
3496dda4fb85SAurabindo Pillai #endif
3497dda4fb85SAurabindo Pillai dml32_CalculateVUpdateAndDynamicMetadataParameters(
34983b4e83a2SNathan Chancellor v->MaxInterDCNTileRepeaters,
3499dda4fb85SAurabindo Pillai myPipe->Dppclk,
3500dda4fb85SAurabindo Pillai myPipe->Dispclk,
3501dda4fb85SAurabindo Pillai myPipe->DCFClkDeepSleep,
3502dda4fb85SAurabindo Pillai myPipe->PixelClock,
3503dda4fb85SAurabindo Pillai myPipe->HTotal,
3504dda4fb85SAurabindo Pillai myPipe->VBlank,
35053b4e83a2SNathan Chancellor v->DynamicMetadataTransmittedBytes[k],
35063b4e83a2SNathan Chancellor v->DynamicMetadataLinesBeforeActiveRequired[k],
3507dda4fb85SAurabindo Pillai myPipe->InterlaceEnable,
3508dda4fb85SAurabindo Pillai myPipe->ProgressiveToInterlaceUnitInOPP,
3509dda4fb85SAurabindo Pillai TSetup,
3510dda4fb85SAurabindo Pillai
3511dda4fb85SAurabindo Pillai /* output */
3512efcc9706SRodrigo Siqueira &Tdmbf,
3513efcc9706SRodrigo Siqueira &Tdmec,
3514efcc9706SRodrigo Siqueira &Tdmsks,
3515dda4fb85SAurabindo Pillai VUpdateOffsetPix,
3516dda4fb85SAurabindo Pillai VUpdateWidthPix,
3517dda4fb85SAurabindo Pillai VReadyOffsetPix);
3518dda4fb85SAurabindo Pillai
3519efcc9706SRodrigo Siqueira LineTime = myPipe->HTotal / myPipe->PixelClock;
3520efcc9706SRodrigo Siqueira trip_to_mem = UrgentLatency;
35213b4e83a2SNathan Chancellor Tvm_trips = UrgentExtraLatency + trip_to_mem * (v->GPUVMMaxPageTableLevels * (HostVMDynamicLevelsTrips + 1) - 1);
3522dda4fb85SAurabindo Pillai
35233b4e83a2SNathan Chancellor if (v->DynamicMetadataVMEnabled == true)
3524efcc9706SRodrigo Siqueira *Tdmdl = TWait + Tvm_trips + trip_to_mem;
3525dda4fb85SAurabindo Pillai else
3526dda4fb85SAurabindo Pillai *Tdmdl = TWait + UrgentExtraLatency;
3527dda4fb85SAurabindo Pillai
3528dda4fb85SAurabindo Pillai #ifdef __DML_VBA_ALLOW_DELTA__
35293b4e83a2SNathan Chancellor if (v->DynamicMetadataEnable[k] == false)
3530dda4fb85SAurabindo Pillai *Tdmdl = 0.0;
3531dda4fb85SAurabindo Pillai #endif
3532dda4fb85SAurabindo Pillai
35333b4e83a2SNathan Chancellor if (v->DynamicMetadataEnable[k] == true) {
3534efcc9706SRodrigo Siqueira if (VStartup * LineTime < *TSetup + *Tdmdl + Tdmbf + Tdmec + Tdmsks) {
3535dda4fb85SAurabindo Pillai *NotEnoughTimeForDynamicMetadata = true;
3536dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3537dda4fb85SAurabindo Pillai dml_print("DML::%s: Not Enough Time for Dynamic Meta!\n", __func__);
3538dda4fb85SAurabindo Pillai dml_print("DML::%s: Tdmbf: %fus - time for dmd transfer from dchub to dio output buffer\n",
3539efcc9706SRodrigo Siqueira __func__, Tdmbf);
3540efcc9706SRodrigo Siqueira dml_print("DML::%s: Tdmec: %fus - time dio takes to transfer dmd\n", __func__, Tdmec);
3541dda4fb85SAurabindo Pillai dml_print("DML::%s: Tdmsks: %fus - time before active dmd must complete transmission at dio\n",
3542efcc9706SRodrigo Siqueira __func__, Tdmsks);
3543dda4fb85SAurabindo Pillai dml_print("DML::%s: Tdmdl: %fus - time for fabric to become ready and fetch dmd\n",
3544dda4fb85SAurabindo Pillai __func__, *Tdmdl);
3545dda4fb85SAurabindo Pillai #endif
3546dda4fb85SAurabindo Pillai } else {
3547dda4fb85SAurabindo Pillai *NotEnoughTimeForDynamicMetadata = false;
3548dda4fb85SAurabindo Pillai }
3549dda4fb85SAurabindo Pillai } else {
3550dda4fb85SAurabindo Pillai *NotEnoughTimeForDynamicMetadata = false;
3551dda4fb85SAurabindo Pillai }
3552dda4fb85SAurabindo Pillai
35533b4e83a2SNathan Chancellor *Tdmdl_vm = (v->DynamicMetadataEnable[k] == true && v->DynamicMetadataVMEnabled == true &&
35543b4e83a2SNathan Chancellor v->GPUVMEnable == true ? TWait + Tvm_trips : 0);
3555dda4fb85SAurabindo Pillai
3556dda4fb85SAurabindo Pillai if (myPipe->ScalerEnabled)
35573b4e83a2SNathan Chancellor DPPCycles = DPPCLKDelaySubtotalPlusCNVCFormater + v->DPPCLKDelaySCL;
3558dda4fb85SAurabindo Pillai else
35593b4e83a2SNathan Chancellor DPPCycles = DPPCLKDelaySubtotalPlusCNVCFormater + v->DPPCLKDelaySCLLBOnly;
3560dda4fb85SAurabindo Pillai
35613b4e83a2SNathan Chancellor DPPCycles = DPPCycles + myPipe->NumberOfCursors * v->DPPCLKDelayCNVCCursor;
3562dda4fb85SAurabindo Pillai
35633b4e83a2SNathan Chancellor DISPCLKCycles = v->DISPCLKDelaySubtotal;
3564dda4fb85SAurabindo Pillai
3565dda4fb85SAurabindo Pillai if (myPipe->Dppclk == 0.0 || myPipe->Dispclk == 0.0)
3566dda4fb85SAurabindo Pillai return true;
3567dda4fb85SAurabindo Pillai
3568efcc9706SRodrigo Siqueira *DSTXAfterScaler = DPPCycles * myPipe->PixelClock / myPipe->Dppclk + DISPCLKCycles *
3569dda4fb85SAurabindo Pillai myPipe->PixelClock / myPipe->Dispclk + DSCDelay;
3570dda4fb85SAurabindo Pillai
3571dda4fb85SAurabindo Pillai *DSTXAfterScaler = *DSTXAfterScaler + (myPipe->ODMMode != dm_odm_combine_mode_disabled ? 18 : 0)
3572dda4fb85SAurabindo Pillai + (myPipe->DPPPerSurface - 1) * DPP_RECOUT_WIDTH
3573dda4fb85SAurabindo Pillai + ((myPipe->ODMMode == dm_odm_split_mode_1to2 || myPipe->ODMMode == dm_odm_mode_mso_1to2) ?
3574dda4fb85SAurabindo Pillai myPipe->HActive / 2 : 0)
3575dda4fb85SAurabindo Pillai + ((myPipe->ODMMode == dm_odm_mode_mso_1to4) ? myPipe->HActive * 3 / 4 : 0);
3576dda4fb85SAurabindo Pillai
3577dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3578efcc9706SRodrigo Siqueira dml_print("DML::%s: DPPCycles: %d\n", __func__, DPPCycles);
3579dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelClock: %f\n", __func__, myPipe->PixelClock);
3580dda4fb85SAurabindo Pillai dml_print("DML::%s: Dppclk: %f\n", __func__, myPipe->Dppclk);
3581efcc9706SRodrigo Siqueira dml_print("DML::%s: DISPCLKCycles: %d\n", __func__, DISPCLKCycles);
3582dda4fb85SAurabindo Pillai dml_print("DML::%s: DISPCLK: %f\n", __func__, myPipe->Dispclk);
3583dda4fb85SAurabindo Pillai dml_print("DML::%s: DSCDelay: %d\n", __func__, DSCDelay);
3584dda4fb85SAurabindo Pillai dml_print("DML::%s: ODMMode: %d\n", __func__, myPipe->ODMMode);
3585dda4fb85SAurabindo Pillai dml_print("DML::%s: DPP_RECOUT_WIDTH: %d\n", __func__, DPP_RECOUT_WIDTH);
3586dda4fb85SAurabindo Pillai dml_print("DML::%s: DSTXAfterScaler: %d\n", __func__, *DSTXAfterScaler);
3587dda4fb85SAurabindo Pillai #endif
3588dda4fb85SAurabindo Pillai
35893b4e83a2SNathan Chancellor if (v->OutputFormat[k] == dm_420 || (myPipe->InterlaceEnable && myPipe->ProgressiveToInterlaceUnitInOPP))
3590dda4fb85SAurabindo Pillai *DSTYAfterScaler = 1;
3591dda4fb85SAurabindo Pillai else
3592dda4fb85SAurabindo Pillai *DSTYAfterScaler = 0;
3593dda4fb85SAurabindo Pillai
3594efcc9706SRodrigo Siqueira DSTTotalPixelsAfterScaler = *DSTYAfterScaler * myPipe->HTotal + *DSTXAfterScaler;
3595efcc9706SRodrigo Siqueira *DSTYAfterScaler = dml_floor(DSTTotalPixelsAfterScaler / myPipe->HTotal, 1);
3596efcc9706SRodrigo Siqueira *DSTXAfterScaler = DSTTotalPixelsAfterScaler - ((double) (*DSTYAfterScaler * myPipe->HTotal));
3597dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3598dda4fb85SAurabindo Pillai dml_print("DML::%s: DSTXAfterScaler: %d (final)\n", __func__, *DSTXAfterScaler);
3599dda4fb85SAurabindo Pillai dml_print("DML::%s: DSTYAfterScaler: %d (final)\n", __func__, *DSTYAfterScaler);
3600dda4fb85SAurabindo Pillai #endif
3601dda4fb85SAurabindo Pillai
3602dda4fb85SAurabindo Pillai MyError = false;
3603dda4fb85SAurabindo Pillai
3604efcc9706SRodrigo Siqueira Tr0_trips = trip_to_mem * (HostVMDynamicLevelsTrips + 1);
3605dda4fb85SAurabindo Pillai
36063b4e83a2SNathan Chancellor if (v->GPUVMEnable == true) {
3607efcc9706SRodrigo Siqueira Tvm_trips_rounded = dml_ceil(4.0 * Tvm_trips / LineTime, 1.0) / 4.0 * LineTime;
3608efcc9706SRodrigo Siqueira Tr0_trips_rounded = dml_ceil(4.0 * Tr0_trips / LineTime, 1.0) / 4.0 * LineTime;
36093b4e83a2SNathan Chancellor if (v->GPUVMMaxPageTableLevels >= 3) {
3610efcc9706SRodrigo Siqueira *Tno_bw = UrgentExtraLatency + trip_to_mem *
36113b4e83a2SNathan Chancellor (double) ((v->GPUVMMaxPageTableLevels - 2) * (HostVMDynamicLevelsTrips + 1) - 1);
36123b4e83a2SNathan Chancellor } else if (v->GPUVMMaxPageTableLevels == 1 && myPipe->DCCEnable != true) {
3613efcc9706SRodrigo Siqueira Tr0_trips_rounded = dml_ceil(4.0 * UrgentExtraLatency / LineTime, 1.0) /
3614efcc9706SRodrigo Siqueira 4.0 * LineTime; // VBA_ERROR
3615dda4fb85SAurabindo Pillai *Tno_bw = UrgentExtraLatency;
3616dda4fb85SAurabindo Pillai } else {
3617dda4fb85SAurabindo Pillai *Tno_bw = 0;
3618dda4fb85SAurabindo Pillai }
3619dda4fb85SAurabindo Pillai } else if (myPipe->DCCEnable == true) {
3620efcc9706SRodrigo Siqueira Tvm_trips_rounded = LineTime / 4.0;
3621efcc9706SRodrigo Siqueira Tr0_trips_rounded = dml_ceil(4.0 * Tr0_trips / LineTime, 1.0) / 4.0 * LineTime;
3622dda4fb85SAurabindo Pillai *Tno_bw = 0;
3623dda4fb85SAurabindo Pillai } else {
3624efcc9706SRodrigo Siqueira Tvm_trips_rounded = LineTime / 4.0;
3625efcc9706SRodrigo Siqueira Tr0_trips_rounded = LineTime / 2.0;
3626dda4fb85SAurabindo Pillai *Tno_bw = 0;
3627dda4fb85SAurabindo Pillai }
3628efcc9706SRodrigo Siqueira Tvm_trips_rounded = dml_max(Tvm_trips_rounded, LineTime / 4.0);
3629efcc9706SRodrigo Siqueira Tr0_trips_rounded = dml_max(Tr0_trips_rounded, LineTime / 4.0);
3630dda4fb85SAurabindo Pillai
3631dda4fb85SAurabindo Pillai if (myPipe->SourcePixelFormat == dm_420_8 || myPipe->SourcePixelFormat == dm_420_10
3632dda4fb85SAurabindo Pillai || myPipe->SourcePixelFormat == dm_420_12) {
3633efcc9706SRodrigo Siqueira bytes_pp = myPipe->BytePerPixelY + myPipe->BytePerPixelC / 4;
3634dda4fb85SAurabindo Pillai } else {
3635efcc9706SRodrigo Siqueira bytes_pp = myPipe->BytePerPixelY + myPipe->BytePerPixelC;
3636dda4fb85SAurabindo Pillai }
3637dda4fb85SAurabindo Pillai
3638efcc9706SRodrigo Siqueira prefetch_sw_bytes = PrefetchSourceLinesY * swath_width_luma_ub * myPipe->BytePerPixelY
3639dda4fb85SAurabindo Pillai + PrefetchSourceLinesC * swath_width_chroma_ub * myPipe->BytePerPixelC;
3640efcc9706SRodrigo Siqueira prefetch_bw_oto = dml_max(bytes_pp * myPipe->PixelClock / myPipe->DPPPerSurface,
3641efcc9706SRodrigo Siqueira prefetch_sw_bytes / (dml_max(PrefetchSourceLinesY, PrefetchSourceLinesC) * LineTime));
3642dda4fb85SAurabindo Pillai
3643efcc9706SRodrigo Siqueira min_Lsw = dml_max(PrefetchSourceLinesY, PrefetchSourceLinesC) / max_vratio_pre;
3644efcc9706SRodrigo Siqueira min_Lsw = dml_max(min_Lsw, 1.0);
3645efcc9706SRodrigo Siqueira Lsw_oto = dml_ceil(4.0 * dml_max(prefetch_sw_bytes / prefetch_bw_oto / LineTime, min_Lsw), 1.0) / 4.0;
3646dda4fb85SAurabindo Pillai
36473b4e83a2SNathan Chancellor if (v->GPUVMEnable == true) {
3648efcc9706SRodrigo Siqueira Tvm_oto = dml_max3(
3649efcc9706SRodrigo Siqueira Tvm_trips,
3650efcc9706SRodrigo Siqueira *Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / prefetch_bw_oto,
3651efcc9706SRodrigo Siqueira LineTime / 4.0);
3652dda4fb85SAurabindo Pillai } else
3653efcc9706SRodrigo Siqueira Tvm_oto = LineTime / 4.0;
3654dda4fb85SAurabindo Pillai
36553b4e83a2SNathan Chancellor if ((v->GPUVMEnable == true || myPipe->DCCEnable == true)) {
3656efcc9706SRodrigo Siqueira Tr0_oto = dml_max4(
3657efcc9706SRodrigo Siqueira Tr0_trips,
3658efcc9706SRodrigo Siqueira (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / prefetch_bw_oto,
3659efcc9706SRodrigo Siqueira (LineTime - Tvm_oto)/2.0,
3660efcc9706SRodrigo Siqueira LineTime / 4.0);
3661dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3662dda4fb85SAurabindo Pillai dml_print("DML::%s: Tr0_oto max0 = %f\n", __func__,
3663efcc9706SRodrigo Siqueira (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) / prefetch_bw_oto);
3664efcc9706SRodrigo Siqueira dml_print("DML::%s: Tr0_oto max1 = %f\n", __func__, Tr0_trips);
3665efcc9706SRodrigo Siqueira dml_print("DML::%s: Tr0_oto max2 = %f\n", __func__, LineTime - Tvm_oto);
3666efcc9706SRodrigo Siqueira dml_print("DML::%s: Tr0_oto max3 = %f\n", __func__, LineTime / 4);
3667dda4fb85SAurabindo Pillai #endif
3668dda4fb85SAurabindo Pillai } else
3669efcc9706SRodrigo Siqueira Tr0_oto = (LineTime - Tvm_oto) / 2.0;
3670dda4fb85SAurabindo Pillai
3671efcc9706SRodrigo Siqueira Tvm_oto_lines = dml_ceil(4.0 * Tvm_oto / LineTime, 1) / 4.0;
3672efcc9706SRodrigo Siqueira Tr0_oto_lines = dml_ceil(4.0 * Tr0_oto / LineTime, 1) / 4.0;
3673efcc9706SRodrigo Siqueira dst_y_prefetch_oto = Tvm_oto_lines + 2 * Tr0_oto_lines + Lsw_oto;
3674dda4fb85SAurabindo Pillai
3675efcc9706SRodrigo Siqueira dst_y_prefetch_equ = VStartup - (*TSetup + dml_max(TWait + TCalc, *Tdmdl)) / LineTime -
3676dda4fb85SAurabindo Pillai (*DSTYAfterScaler + (double) *DSTXAfterScaler / (double) myPipe->HTotal);
3677dda4fb85SAurabindo Pillai
3678bcdc9158SDillon Varone dst_y_prefetch_equ = dml_min(dst_y_prefetch_equ, __DML_VBA_MAX_DST_Y_PRE__);
3679dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3680dda4fb85SAurabindo Pillai dml_print("DML::%s: HTotal = %d\n", __func__, myPipe->HTotal);
3681efcc9706SRodrigo Siqueira dml_print("DML::%s: min_Lsw = %f\n", __func__, min_Lsw);
3682dda4fb85SAurabindo Pillai dml_print("DML::%s: *Tno_bw = %f\n", __func__, *Tno_bw);
3683dda4fb85SAurabindo Pillai dml_print("DML::%s: UrgentExtraLatency = %f\n", __func__, UrgentExtraLatency);
3684efcc9706SRodrigo Siqueira dml_print("DML::%s: trip_to_mem = %f\n", __func__, trip_to_mem);
3685dda4fb85SAurabindo Pillai dml_print("DML::%s: BytePerPixelY = %d\n", __func__, myPipe->BytePerPixelY);
3686dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchSourceLinesY = %f\n", __func__, PrefetchSourceLinesY);
3687dda4fb85SAurabindo Pillai dml_print("DML::%s: swath_width_luma_ub = %d\n", __func__, swath_width_luma_ub);
3688dda4fb85SAurabindo Pillai dml_print("DML::%s: BytePerPixelC = %d\n", __func__, myPipe->BytePerPixelC);
3689dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchSourceLinesC = %f\n", __func__, PrefetchSourceLinesC);
3690dda4fb85SAurabindo Pillai dml_print("DML::%s: swath_width_chroma_ub = %d\n", __func__, swath_width_chroma_ub);
3691efcc9706SRodrigo Siqueira dml_print("DML::%s: prefetch_sw_bytes = %f\n", __func__, prefetch_sw_bytes);
3692efcc9706SRodrigo Siqueira dml_print("DML::%s: bytes_pp = %f\n", __func__, bytes_pp);
3693dda4fb85SAurabindo Pillai dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %d\n", __func__, PDEAndMetaPTEBytesFrame);
3694dda4fb85SAurabindo Pillai dml_print("DML::%s: MetaRowByte = %d\n", __func__, MetaRowByte);
3695dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelPTEBytesPerRow = %d\n", __func__, PixelPTEBytesPerRow);
3696dda4fb85SAurabindo Pillai dml_print("DML::%s: HostVMInefficiencyFactor = %f\n", __func__, HostVMInefficiencyFactor);
3697efcc9706SRodrigo Siqueira dml_print("DML::%s: Tvm_trips = %f\n", __func__, Tvm_trips);
3698efcc9706SRodrigo Siqueira dml_print("DML::%s: Tr0_trips = %f\n", __func__, Tr0_trips);
3699efcc9706SRodrigo Siqueira dml_print("DML::%s: prefetch_bw_oto = %f\n", __func__, prefetch_bw_oto);
3700efcc9706SRodrigo Siqueira dml_print("DML::%s: Tr0_oto = %f\n", __func__, Tr0_oto);
3701efcc9706SRodrigo Siqueira dml_print("DML::%s: Tvm_oto = %f\n", __func__, Tvm_oto);
3702efcc9706SRodrigo Siqueira dml_print("DML::%s: Tvm_oto_lines = %f\n", __func__, Tvm_oto_lines);
3703efcc9706SRodrigo Siqueira dml_print("DML::%s: Tr0_oto_lines = %f\n", __func__, Tr0_oto_lines);
3704efcc9706SRodrigo Siqueira dml_print("DML::%s: Lsw_oto = %f\n", __func__, Lsw_oto);
3705efcc9706SRodrigo Siqueira dml_print("DML::%s: dst_y_prefetch_oto = %f\n", __func__, dst_y_prefetch_oto);
3706efcc9706SRodrigo Siqueira dml_print("DML::%s: dst_y_prefetch_equ = %f\n", __func__, dst_y_prefetch_equ);
3707dda4fb85SAurabindo Pillai #endif
3708dda4fb85SAurabindo Pillai
3709efcc9706SRodrigo Siqueira dst_y_prefetch_equ = dml_floor(4.0 * (dst_y_prefetch_equ + 0.125), 1) / 4.0;
3710efcc9706SRodrigo Siqueira Tpre_rounded = dst_y_prefetch_equ * LineTime;
3711dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3712efcc9706SRodrigo Siqueira dml_print("DML::%s: dst_y_prefetch_equ: %f (after round)\n", __func__, dst_y_prefetch_equ);
3713efcc9706SRodrigo Siqueira dml_print("DML::%s: LineTime: %f\n", __func__, LineTime);
3714dda4fb85SAurabindo Pillai dml_print("DML::%s: VStartup: %d\n", __func__, VStartup);
3715dda4fb85SAurabindo Pillai dml_print("DML::%s: Tvstartup: %fus - time between vstartup and first pixel of active\n",
3716efcc9706SRodrigo Siqueira __func__, VStartup * LineTime);
3717dda4fb85SAurabindo Pillai dml_print("DML::%s: TSetup: %fus - time from vstartup to vready\n", __func__, *TSetup);
3718dda4fb85SAurabindo Pillai dml_print("DML::%s: TCalc: %fus - time for calculations in dchub starting at vready\n", __func__, TCalc);
3719efcc9706SRodrigo Siqueira dml_print("DML::%s: Tdmbf: %fus - time for dmd transfer from dchub to dio output buffer\n", __func__, Tdmbf);
3720efcc9706SRodrigo Siqueira dml_print("DML::%s: Tdmec: %fus - time dio takes to transfer dmd\n", __func__, Tdmec);
3721dda4fb85SAurabindo Pillai dml_print("DML::%s: Tdmdl_vm: %fus - time for vm stages of dmd\n", __func__, *Tdmdl_vm);
3722dda4fb85SAurabindo Pillai dml_print("DML::%s: Tdmdl: %fus - time for fabric to become ready and fetch dmd\n", __func__, *Tdmdl);
3723dda4fb85SAurabindo Pillai dml_print("DML::%s: DSTYAfterScaler: %d lines - number of lines of pipeline and buffer delay after scaler\n",
3724dda4fb85SAurabindo Pillai __func__, *DSTYAfterScaler);
3725dda4fb85SAurabindo Pillai #endif
3726efcc9706SRodrigo Siqueira dep_bytes = dml_max(PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor,
3727dda4fb85SAurabindo Pillai MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor);
3728dda4fb85SAurabindo Pillai
3729efcc9706SRodrigo Siqueira if (prefetch_sw_bytes < dep_bytes)
3730efcc9706SRodrigo Siqueira prefetch_sw_bytes = 2 * dep_bytes;
3731dda4fb85SAurabindo Pillai
3732dda4fb85SAurabindo Pillai *PrefetchBandwidth = 0;
3733dda4fb85SAurabindo Pillai *DestinationLinesToRequestVMInVBlank = 0;
3734dda4fb85SAurabindo Pillai *DestinationLinesToRequestRowInVBlank = 0;
3735dda4fb85SAurabindo Pillai *VRatioPrefetchY = 0;
3736dda4fb85SAurabindo Pillai *VRatioPrefetchC = 0;
3737dda4fb85SAurabindo Pillai *RequiredPrefetchPixDataBWLuma = 0;
3738bcdc9158SDillon Varone if (dst_y_prefetch_equ > 1 &&
3739bcdc9158SDillon Varone (Tpre_rounded >= TPreReq || dst_y_prefetch_equ == __DML_VBA_MAX_DST_Y_PRE__)) {
3740dda4fb85SAurabindo Pillai double PrefetchBandwidth1;
3741dda4fb85SAurabindo Pillai double PrefetchBandwidth2;
3742dda4fb85SAurabindo Pillai double PrefetchBandwidth3;
3743dda4fb85SAurabindo Pillai double PrefetchBandwidth4;
3744dda4fb85SAurabindo Pillai
3745efcc9706SRodrigo Siqueira if (Tpre_rounded - *Tno_bw > 0) {
3746dda4fb85SAurabindo Pillai PrefetchBandwidth1 = (PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor + 2 * MetaRowByte
3747dda4fb85SAurabindo Pillai + 2 * PixelPTEBytesPerRow * HostVMInefficiencyFactor
3748efcc9706SRodrigo Siqueira + prefetch_sw_bytes) / (Tpre_rounded - *Tno_bw);
3749efcc9706SRodrigo Siqueira Tsw_est1 = prefetch_sw_bytes / PrefetchBandwidth1;
3750dda4fb85SAurabindo Pillai } else
3751dda4fb85SAurabindo Pillai PrefetchBandwidth1 = 0;
3752dda4fb85SAurabindo Pillai
3753efcc9706SRodrigo Siqueira if (VStartup == MaxVStartup && (Tsw_est1 / LineTime < min_Lsw)
3754efcc9706SRodrigo Siqueira && Tpre_rounded - min_Lsw * LineTime - 0.75 * LineTime - *Tno_bw > 0) {
3755dda4fb85SAurabindo Pillai PrefetchBandwidth1 = (PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor + 2 * MetaRowByte
3756dda4fb85SAurabindo Pillai + 2 * PixelPTEBytesPerRow * HostVMInefficiencyFactor)
3757efcc9706SRodrigo Siqueira / (Tpre_rounded - min_Lsw * LineTime - 0.75 * LineTime - *Tno_bw);
3758dda4fb85SAurabindo Pillai }
3759dda4fb85SAurabindo Pillai
3760efcc9706SRodrigo Siqueira if (Tpre_rounded - *Tno_bw - 2 * Tr0_trips_rounded > 0)
3761efcc9706SRodrigo Siqueira PrefetchBandwidth2 = (PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor + prefetch_sw_bytes) /
3762efcc9706SRodrigo Siqueira (Tpre_rounded - *Tno_bw - 2 * Tr0_trips_rounded);
3763dda4fb85SAurabindo Pillai else
3764dda4fb85SAurabindo Pillai PrefetchBandwidth2 = 0;
3765dda4fb85SAurabindo Pillai
3766efcc9706SRodrigo Siqueira if (Tpre_rounded - Tvm_trips_rounded > 0) {
3767dda4fb85SAurabindo Pillai PrefetchBandwidth3 = (2 * MetaRowByte + 2 * PixelPTEBytesPerRow * HostVMInefficiencyFactor
3768efcc9706SRodrigo Siqueira + prefetch_sw_bytes) / (Tpre_rounded - Tvm_trips_rounded);
3769efcc9706SRodrigo Siqueira Tsw_est3 = prefetch_sw_bytes / PrefetchBandwidth3;
3770dda4fb85SAurabindo Pillai } else
3771dda4fb85SAurabindo Pillai PrefetchBandwidth3 = 0;
3772dda4fb85SAurabindo Pillai
3773dda4fb85SAurabindo Pillai
3774dda4fb85SAurabindo Pillai if (VStartup == MaxVStartup &&
3775efcc9706SRodrigo Siqueira (Tsw_est3 / LineTime < min_Lsw) && Tpre_rounded - min_Lsw * LineTime - 0.75 *
3776efcc9706SRodrigo Siqueira LineTime - Tvm_trips_rounded > 0) {
3777dda4fb85SAurabindo Pillai PrefetchBandwidth3 = (2 * MetaRowByte + 2 * PixelPTEBytesPerRow * HostVMInefficiencyFactor)
3778efcc9706SRodrigo Siqueira / (Tpre_rounded - min_Lsw * LineTime - 0.75 * LineTime - Tvm_trips_rounded);
3779dda4fb85SAurabindo Pillai }
3780dda4fb85SAurabindo Pillai
3781efcc9706SRodrigo Siqueira if (Tpre_rounded - Tvm_trips_rounded - 2 * Tr0_trips_rounded > 0) {
3782efcc9706SRodrigo Siqueira PrefetchBandwidth4 = prefetch_sw_bytes /
3783efcc9706SRodrigo Siqueira (Tpre_rounded - Tvm_trips_rounded - 2 * Tr0_trips_rounded);
3784dda4fb85SAurabindo Pillai } else {
3785dda4fb85SAurabindo Pillai PrefetchBandwidth4 = 0;
3786dda4fb85SAurabindo Pillai }
3787dda4fb85SAurabindo Pillai
3788dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3789efcc9706SRodrigo Siqueira dml_print("DML::%s: Tpre_rounded: %f\n", __func__, Tpre_rounded);
3790dda4fb85SAurabindo Pillai dml_print("DML::%s: Tno_bw: %f\n", __func__, *Tno_bw);
3791efcc9706SRodrigo Siqueira dml_print("DML::%s: Tvm_trips_rounded: %f\n", __func__, Tvm_trips_rounded);
3792efcc9706SRodrigo Siqueira dml_print("DML::%s: Tsw_est1: %f\n", __func__, Tsw_est1);
3793efcc9706SRodrigo Siqueira dml_print("DML::%s: Tsw_est3: %f\n", __func__, Tsw_est3);
3794dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchBandwidth1: %f\n", __func__, PrefetchBandwidth1);
3795dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchBandwidth2: %f\n", __func__, PrefetchBandwidth2);
3796dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchBandwidth3: %f\n", __func__, PrefetchBandwidth3);
3797dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchBandwidth4: %f\n", __func__, PrefetchBandwidth4);
3798dda4fb85SAurabindo Pillai #endif
3799dda4fb85SAurabindo Pillai {
3800dda4fb85SAurabindo Pillai bool Case1OK;
3801dda4fb85SAurabindo Pillai bool Case2OK;
3802dda4fb85SAurabindo Pillai bool Case3OK;
3803dda4fb85SAurabindo Pillai
3804dda4fb85SAurabindo Pillai if (PrefetchBandwidth1 > 0) {
3805dda4fb85SAurabindo Pillai if (*Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / PrefetchBandwidth1
3806efcc9706SRodrigo Siqueira >= Tvm_trips_rounded
3807dda4fb85SAurabindo Pillai && (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor)
3808efcc9706SRodrigo Siqueira / PrefetchBandwidth1 >= Tr0_trips_rounded) {
3809dda4fb85SAurabindo Pillai Case1OK = true;
3810dda4fb85SAurabindo Pillai } else {
3811dda4fb85SAurabindo Pillai Case1OK = false;
3812dda4fb85SAurabindo Pillai }
3813dda4fb85SAurabindo Pillai } else {
3814dda4fb85SAurabindo Pillai Case1OK = false;
3815dda4fb85SAurabindo Pillai }
3816dda4fb85SAurabindo Pillai
3817dda4fb85SAurabindo Pillai if (PrefetchBandwidth2 > 0) {
3818dda4fb85SAurabindo Pillai if (*Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / PrefetchBandwidth2
3819efcc9706SRodrigo Siqueira >= Tvm_trips_rounded
3820dda4fb85SAurabindo Pillai && (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor)
3821efcc9706SRodrigo Siqueira / PrefetchBandwidth2 < Tr0_trips_rounded) {
3822dda4fb85SAurabindo Pillai Case2OK = true;
3823dda4fb85SAurabindo Pillai } else {
3824dda4fb85SAurabindo Pillai Case2OK = false;
3825dda4fb85SAurabindo Pillai }
3826dda4fb85SAurabindo Pillai } else {
3827dda4fb85SAurabindo Pillai Case2OK = false;
3828dda4fb85SAurabindo Pillai }
3829dda4fb85SAurabindo Pillai
3830dda4fb85SAurabindo Pillai if (PrefetchBandwidth3 > 0) {
3831dda4fb85SAurabindo Pillai if (*Tno_bw + PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor / PrefetchBandwidth3 <
3832efcc9706SRodrigo Siqueira Tvm_trips_rounded && (MetaRowByte + PixelPTEBytesPerRow *
3833dda4fb85SAurabindo Pillai HostVMInefficiencyFactor) / PrefetchBandwidth3 >=
3834efcc9706SRodrigo Siqueira Tr0_trips_rounded) {
3835dda4fb85SAurabindo Pillai Case3OK = true;
3836dda4fb85SAurabindo Pillai } else {
3837dda4fb85SAurabindo Pillai Case3OK = false;
3838dda4fb85SAurabindo Pillai }
3839dda4fb85SAurabindo Pillai } else {
3840dda4fb85SAurabindo Pillai Case3OK = false;
3841dda4fb85SAurabindo Pillai }
3842dda4fb85SAurabindo Pillai
3843dda4fb85SAurabindo Pillai if (Case1OK)
3844efcc9706SRodrigo Siqueira prefetch_bw_equ = PrefetchBandwidth1;
3845dda4fb85SAurabindo Pillai else if (Case2OK)
3846efcc9706SRodrigo Siqueira prefetch_bw_equ = PrefetchBandwidth2;
3847dda4fb85SAurabindo Pillai else if (Case3OK)
3848efcc9706SRodrigo Siqueira prefetch_bw_equ = PrefetchBandwidth3;
3849dda4fb85SAurabindo Pillai else
3850efcc9706SRodrigo Siqueira prefetch_bw_equ = PrefetchBandwidth4;
3851dda4fb85SAurabindo Pillai
3852dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3853dda4fb85SAurabindo Pillai dml_print("DML::%s: Case1OK: %d\n", __func__, Case1OK);
3854dda4fb85SAurabindo Pillai dml_print("DML::%s: Case2OK: %d\n", __func__, Case2OK);
3855dda4fb85SAurabindo Pillai dml_print("DML::%s: Case3OK: %d\n", __func__, Case3OK);
3856efcc9706SRodrigo Siqueira dml_print("DML::%s: prefetch_bw_equ: %f\n", __func__, prefetch_bw_equ);
3857dda4fb85SAurabindo Pillai #endif
3858dda4fb85SAurabindo Pillai
3859efcc9706SRodrigo Siqueira if (prefetch_bw_equ > 0) {
38603b4e83a2SNathan Chancellor if (v->GPUVMEnable == true) {
3861efcc9706SRodrigo Siqueira Tvm_equ = dml_max3(*Tno_bw + PDEAndMetaPTEBytesFrame *
3862efcc9706SRodrigo Siqueira HostVMInefficiencyFactor / prefetch_bw_equ,
3863efcc9706SRodrigo Siqueira Tvm_trips, LineTime / 4);
3864dda4fb85SAurabindo Pillai } else {
3865efcc9706SRodrigo Siqueira Tvm_equ = LineTime / 4;
3866dda4fb85SAurabindo Pillai }
3867dda4fb85SAurabindo Pillai
38683b4e83a2SNathan Chancellor if ((v->GPUVMEnable == true || myPipe->DCCEnable == true)) {
3869efcc9706SRodrigo Siqueira Tr0_equ = dml_max4((MetaRowByte + PixelPTEBytesPerRow *
3870efcc9706SRodrigo Siqueira HostVMInefficiencyFactor) / prefetch_bw_equ, Tr0_trips,
3871efcc9706SRodrigo Siqueira (LineTime - Tvm_equ) / 2, LineTime / 4);
3872dda4fb85SAurabindo Pillai } else {
3873efcc9706SRodrigo Siqueira Tr0_equ = (LineTime - Tvm_equ) / 2;
3874dda4fb85SAurabindo Pillai }
3875dda4fb85SAurabindo Pillai } else {
3876efcc9706SRodrigo Siqueira Tvm_equ = 0;
3877efcc9706SRodrigo Siqueira Tr0_equ = 0;
3878dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3879dda4fb85SAurabindo Pillai dml_print("DML: prefetch_bw_equ equals 0! %s:%d\n", __FILE__, __LINE__);
3880dda4fb85SAurabindo Pillai #endif
3881dda4fb85SAurabindo Pillai }
3882dda4fb85SAurabindo Pillai }
3883dda4fb85SAurabindo Pillai
3884efcc9706SRodrigo Siqueira if (dst_y_prefetch_oto < dst_y_prefetch_equ) {
388501c0c124SDillon Varone if (dst_y_prefetch_oto * LineTime < TPreReq) {
388601c0c124SDillon Varone *DestinationLinesForPrefetch = dst_y_prefetch_equ;
388701c0c124SDillon Varone } else {
3888efcc9706SRodrigo Siqueira *DestinationLinesForPrefetch = dst_y_prefetch_oto;
388901c0c124SDillon Varone }
3890efcc9706SRodrigo Siqueira TimeForFetchingMetaPTE = Tvm_oto;
3891efcc9706SRodrigo Siqueira TimeForFetchingRowInVBlank = Tr0_oto;
3892efcc9706SRodrigo Siqueira *PrefetchBandwidth = prefetch_bw_oto;
3893735688ebSLeo Ma /* Clamp to oto for bandwidth calculation */
3894735688ebSLeo Ma LinesForPrefetchBandwidth = dst_y_prefetch_oto;
3895dda4fb85SAurabindo Pillai } else {
3896*6750d1deSAlvin Lee /* For mode programming we want to extend the prefetch as much as possible
3897*6750d1deSAlvin Lee * (up to oto, or as long as we can for equ) if we're not already applying
3898*6750d1deSAlvin Lee * the 60us prefetch requirement. This is to avoid intermittent underflow
3899*6750d1deSAlvin Lee * issues during prefetch.
3900*6750d1deSAlvin Lee *
3901*6750d1deSAlvin Lee * The prefetch extension is applied under the following scenarios:
3902*6750d1deSAlvin Lee * 1. We're in prefetch mode > 0 (i.e. we don't support MCLK switch in blank)
3903*6750d1deSAlvin Lee * 2. We're using subvp or drr methods of p-state switch, in which case we
3904*6750d1deSAlvin Lee * we don't care if prefetch takes up more of the blanking time
3905*6750d1deSAlvin Lee *
3906*6750d1deSAlvin Lee * Mode programming typically chooses the smallest prefetch time possible
3907*6750d1deSAlvin Lee * (i.e. highest bandwidth during prefetch) presumably to create margin between
3908*6750d1deSAlvin Lee * p-states / c-states that happen in vblank and prefetch. Therefore we only
3909*6750d1deSAlvin Lee * apply this prefetch extension when p-state in vblank is not required (UCLK
3910*6750d1deSAlvin Lee * p-states take up the most vblank time).
3911*6750d1deSAlvin Lee */
3912*6750d1deSAlvin Lee if (ExtendPrefetchIfPossible && TPreReq == 0 && VStartup < MaxVStartup) {
3913*6750d1deSAlvin Lee MyError = true;
3914*6750d1deSAlvin Lee } else {
3915efcc9706SRodrigo Siqueira *DestinationLinesForPrefetch = dst_y_prefetch_equ;
3916efcc9706SRodrigo Siqueira TimeForFetchingMetaPTE = Tvm_equ;
3917efcc9706SRodrigo Siqueira TimeForFetchingRowInVBlank = Tr0_equ;
3918efcc9706SRodrigo Siqueira *PrefetchBandwidth = prefetch_bw_equ;
3919735688ebSLeo Ma /* Clamp to equ for bandwidth calculation */
3920735688ebSLeo Ma LinesForPrefetchBandwidth = dst_y_prefetch_equ;
3921dda4fb85SAurabindo Pillai }
3922*6750d1deSAlvin Lee }
3923dda4fb85SAurabindo Pillai
3924efcc9706SRodrigo Siqueira *DestinationLinesToRequestVMInVBlank = dml_ceil(4.0 * TimeForFetchingMetaPTE / LineTime, 1.0) / 4.0;
3925dda4fb85SAurabindo Pillai
3926dda4fb85SAurabindo Pillai *DestinationLinesToRequestRowInVBlank =
3927efcc9706SRodrigo Siqueira dml_ceil(4.0 * TimeForFetchingRowInVBlank / LineTime, 1.0) / 4.0;
3928dda4fb85SAurabindo Pillai
3929735688ebSLeo Ma LinesToRequestPrefetchPixelData = LinesForPrefetchBandwidth -
3930dda4fb85SAurabindo Pillai *DestinationLinesToRequestVMInVBlank - 2 * *DestinationLinesToRequestRowInVBlank;
3931dda4fb85SAurabindo Pillai
3932dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3933dda4fb85SAurabindo Pillai dml_print("DML::%s: DestinationLinesForPrefetch = %f\n", __func__, *DestinationLinesForPrefetch);
3934dda4fb85SAurabindo Pillai dml_print("DML::%s: DestinationLinesToRequestVMInVBlank = %f\n",
3935dda4fb85SAurabindo Pillai __func__, *DestinationLinesToRequestVMInVBlank);
3936efcc9706SRodrigo Siqueira dml_print("DML::%s: TimeForFetchingRowInVBlank = %f\n", __func__, TimeForFetchingRowInVBlank);
3937efcc9706SRodrigo Siqueira dml_print("DML::%s: LineTime = %f\n", __func__, LineTime);
3938dda4fb85SAurabindo Pillai dml_print("DML::%s: DestinationLinesToRequestRowInVBlank = %f\n",
3939dda4fb85SAurabindo Pillai __func__, *DestinationLinesToRequestRowInVBlank);
3940dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchSourceLinesY = %f\n", __func__, PrefetchSourceLinesY);
3941efcc9706SRodrigo Siqueira dml_print("DML::%s: LinesToRequestPrefetchPixelData = %f\n", __func__, LinesToRequestPrefetchPixelData);
3942dda4fb85SAurabindo Pillai #endif
3943dda4fb85SAurabindo Pillai
3944efcc9706SRodrigo Siqueira if (LinesToRequestPrefetchPixelData >= 1 && prefetch_bw_equ > 0) {
3945efcc9706SRodrigo Siqueira *VRatioPrefetchY = (double) PrefetchSourceLinesY / LinesToRequestPrefetchPixelData;
3946dda4fb85SAurabindo Pillai *VRatioPrefetchY = dml_max(*VRatioPrefetchY, 1.0);
3947dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3948dda4fb85SAurabindo Pillai dml_print("DML::%s: VRatioPrefetchY = %f\n", __func__, *VRatioPrefetchY);
3949dda4fb85SAurabindo Pillai dml_print("DML::%s: SwathHeightY = %d\n", __func__, SwathHeightY);
3950dda4fb85SAurabindo Pillai dml_print("DML::%s: VInitPreFillY = %d\n", __func__, VInitPreFillY);
3951dda4fb85SAurabindo Pillai #endif
3952dda4fb85SAurabindo Pillai if ((SwathHeightY > 4) && (VInitPreFillY > 3)) {
3953efcc9706SRodrigo Siqueira if (LinesToRequestPrefetchPixelData > (VInitPreFillY - 3.0) / 2.0) {
3954dda4fb85SAurabindo Pillai *VRatioPrefetchY =
3955dda4fb85SAurabindo Pillai dml_max((double) PrefetchSourceLinesY /
3956efcc9706SRodrigo Siqueira LinesToRequestPrefetchPixelData,
3957dda4fb85SAurabindo Pillai (double) MaxNumSwathY * SwathHeightY /
3958efcc9706SRodrigo Siqueira (LinesToRequestPrefetchPixelData -
3959dda4fb85SAurabindo Pillai (VInitPreFillY - 3.0) / 2.0));
3960dda4fb85SAurabindo Pillai *VRatioPrefetchY = dml_max(*VRatioPrefetchY, 1.0);
3961dda4fb85SAurabindo Pillai } else {
3962dda4fb85SAurabindo Pillai MyError = true;
3963dda4fb85SAurabindo Pillai *VRatioPrefetchY = 0;
3964dda4fb85SAurabindo Pillai }
3965dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3966dda4fb85SAurabindo Pillai dml_print("DML::%s: VRatioPrefetchY = %f\n", __func__, *VRatioPrefetchY);
3967dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchSourceLinesY = %f\n", __func__, PrefetchSourceLinesY);
3968dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxNumSwathY = %d\n", __func__, MaxNumSwathY);
3969dda4fb85SAurabindo Pillai #endif
3970dda4fb85SAurabindo Pillai }
3971dda4fb85SAurabindo Pillai
3972efcc9706SRodrigo Siqueira *VRatioPrefetchC = (double) PrefetchSourceLinesC / LinesToRequestPrefetchPixelData;
3973dda4fb85SAurabindo Pillai *VRatioPrefetchC = dml_max(*VRatioPrefetchC, 1.0);
3974dda4fb85SAurabindo Pillai
3975dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3976dda4fb85SAurabindo Pillai dml_print("DML::%s: VRatioPrefetchC = %f\n", __func__, *VRatioPrefetchC);
3977dda4fb85SAurabindo Pillai dml_print("DML::%s: SwathHeightC = %d\n", __func__, SwathHeightC);
3978dda4fb85SAurabindo Pillai dml_print("DML::%s: VInitPreFillC = %d\n", __func__, VInitPreFillC);
3979dda4fb85SAurabindo Pillai #endif
3980dda4fb85SAurabindo Pillai if ((SwathHeightC > 4)) {
3981efcc9706SRodrigo Siqueira if (LinesToRequestPrefetchPixelData > (VInitPreFillC - 3.0) / 2.0) {
3982dda4fb85SAurabindo Pillai *VRatioPrefetchC =
3983dda4fb85SAurabindo Pillai dml_max(*VRatioPrefetchC,
3984dda4fb85SAurabindo Pillai (double) MaxNumSwathC * SwathHeightC /
3985efcc9706SRodrigo Siqueira (LinesToRequestPrefetchPixelData -
3986dda4fb85SAurabindo Pillai (VInitPreFillC - 3.0) / 2.0));
3987dda4fb85SAurabindo Pillai *VRatioPrefetchC = dml_max(*VRatioPrefetchC, 1.0);
3988dda4fb85SAurabindo Pillai } else {
3989dda4fb85SAurabindo Pillai MyError = true;
3990dda4fb85SAurabindo Pillai *VRatioPrefetchC = 0;
3991dda4fb85SAurabindo Pillai }
3992dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
3993dda4fb85SAurabindo Pillai dml_print("DML::%s: VRatioPrefetchC = %f\n", __func__, *VRatioPrefetchC);
3994dda4fb85SAurabindo Pillai dml_print("DML::%s: PrefetchSourceLinesC = %f\n", __func__, PrefetchSourceLinesC);
3995dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxNumSwathC = %d\n", __func__, MaxNumSwathC);
3996dda4fb85SAurabindo Pillai #endif
3997dda4fb85SAurabindo Pillai }
3998dda4fb85SAurabindo Pillai
3999dda4fb85SAurabindo Pillai *RequiredPrefetchPixDataBWLuma = (double) PrefetchSourceLinesY
4000efcc9706SRodrigo Siqueira / LinesToRequestPrefetchPixelData * myPipe->BytePerPixelY * swath_width_luma_ub
4001efcc9706SRodrigo Siqueira / LineTime;
4002dda4fb85SAurabindo Pillai
4003dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4004dda4fb85SAurabindo Pillai dml_print("DML::%s: BytePerPixelY = %d\n", __func__, myPipe->BytePerPixelY);
4005dda4fb85SAurabindo Pillai dml_print("DML::%s: swath_width_luma_ub = %d\n", __func__, swath_width_luma_ub);
4006efcc9706SRodrigo Siqueira dml_print("DML::%s: LineTime = %f\n", __func__, LineTime);
4007dda4fb85SAurabindo Pillai dml_print("DML::%s: RequiredPrefetchPixDataBWLuma = %f\n",
4008dda4fb85SAurabindo Pillai __func__, *RequiredPrefetchPixDataBWLuma);
4009dda4fb85SAurabindo Pillai #endif
4010dda4fb85SAurabindo Pillai *RequiredPrefetchPixDataBWChroma = (double) PrefetchSourceLinesC /
4011efcc9706SRodrigo Siqueira LinesToRequestPrefetchPixelData
4012dda4fb85SAurabindo Pillai * myPipe->BytePerPixelC
4013efcc9706SRodrigo Siqueira * swath_width_chroma_ub / LineTime;
4014dda4fb85SAurabindo Pillai } else {
4015dda4fb85SAurabindo Pillai MyError = true;
4016dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4017dda4fb85SAurabindo Pillai dml_print("DML:%s: MyErr set. LinesToRequestPrefetchPixelData: %f, should be > 0\n",
4018efcc9706SRodrigo Siqueira __func__, LinesToRequestPrefetchPixelData);
4019dda4fb85SAurabindo Pillai #endif
4020dda4fb85SAurabindo Pillai *VRatioPrefetchY = 0;
4021dda4fb85SAurabindo Pillai *VRatioPrefetchC = 0;
4022dda4fb85SAurabindo Pillai *RequiredPrefetchPixDataBWLuma = 0;
4023dda4fb85SAurabindo Pillai *RequiredPrefetchPixDataBWChroma = 0;
4024dda4fb85SAurabindo Pillai }
4025dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4026dda4fb85SAurabindo Pillai dml_print("DML: Tpre: %fus - sum of time to request meta pte, 2 x data pte + meta data, swaths\n",
4027efcc9706SRodrigo Siqueira (double)LinesToRequestPrefetchPixelData * LineTime +
4028efcc9706SRodrigo Siqueira 2.0*TimeForFetchingRowInVBlank + TimeForFetchingMetaPTE);
4029efcc9706SRodrigo Siqueira dml_print("DML: Tvm: %fus - time to fetch page tables for meta surface\n", TimeForFetchingMetaPTE);
4030dda4fb85SAurabindo Pillai dml_print("DML: To: %fus - time for propagation from scaler to optc\n",
4031efcc9706SRodrigo Siqueira (*DSTYAfterScaler + ((double) (*DSTXAfterScaler) / (double) myPipe->HTotal)) * LineTime);
4032dda4fb85SAurabindo Pillai dml_print("DML: Tvstartup - TSetup - Tcalc - Twait - Tpre - To > 0\n");
4033efcc9706SRodrigo Siqueira dml_print("DML: Tslack(pre): %fus - time left over in schedule\n", VStartup * LineTime -
4034efcc9706SRodrigo Siqueira TimeForFetchingMetaPTE - 2*TimeForFetchingRowInVBlank - (*DSTYAfterScaler +
4035efcc9706SRodrigo Siqueira ((double) (*DSTXAfterScaler) / (double) myPipe->HTotal)) * LineTime - TWait - TCalc - *TSetup);
4036dda4fb85SAurabindo Pillai dml_print("DML: row_bytes = dpte_row_bytes (per_pipe) = PixelPTEBytesPerRow = : %d\n",
4037dda4fb85SAurabindo Pillai PixelPTEBytesPerRow);
4038dda4fb85SAurabindo Pillai #endif
4039dda4fb85SAurabindo Pillai } else {
4040dda4fb85SAurabindo Pillai MyError = true;
4041dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4042dda4fb85SAurabindo Pillai dml_print("DML::%s: MyErr set, dst_y_prefetch_equ = %f (should be > 1)\n",
4043efcc9706SRodrigo Siqueira __func__, dst_y_prefetch_equ);
4044dda4fb85SAurabindo Pillai #endif
4045dda4fb85SAurabindo Pillai }
4046dda4fb85SAurabindo Pillai
4047dda4fb85SAurabindo Pillai {
4048dda4fb85SAurabindo Pillai double prefetch_vm_bw;
4049dda4fb85SAurabindo Pillai double prefetch_row_bw;
4050dda4fb85SAurabindo Pillai
4051dda4fb85SAurabindo Pillai if (PDEAndMetaPTEBytesFrame == 0) {
4052dda4fb85SAurabindo Pillai prefetch_vm_bw = 0;
4053dda4fb85SAurabindo Pillai } else if (*DestinationLinesToRequestVMInVBlank > 0) {
4054dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4055dda4fb85SAurabindo Pillai dml_print("DML::%s: PDEAndMetaPTEBytesFrame = %d\n", __func__, PDEAndMetaPTEBytesFrame);
4056dda4fb85SAurabindo Pillai dml_print("DML::%s: HostVMInefficiencyFactor = %f\n", __func__, HostVMInefficiencyFactor);
4057dda4fb85SAurabindo Pillai dml_print("DML::%s: DestinationLinesToRequestVMInVBlank = %f\n",
4058dda4fb85SAurabindo Pillai __func__, *DestinationLinesToRequestVMInVBlank);
4059efcc9706SRodrigo Siqueira dml_print("DML::%s: LineTime = %f\n", __func__, LineTime);
4060dda4fb85SAurabindo Pillai #endif
4061dda4fb85SAurabindo Pillai prefetch_vm_bw = PDEAndMetaPTEBytesFrame * HostVMInefficiencyFactor /
4062efcc9706SRodrigo Siqueira (*DestinationLinesToRequestVMInVBlank * LineTime);
4063dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4064dda4fb85SAurabindo Pillai dml_print("DML::%s: prefetch_vm_bw = %f\n", __func__, prefetch_vm_bw);
4065dda4fb85SAurabindo Pillai #endif
4066dda4fb85SAurabindo Pillai } else {
4067dda4fb85SAurabindo Pillai prefetch_vm_bw = 0;
4068dda4fb85SAurabindo Pillai MyError = true;
4069dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4070dda4fb85SAurabindo Pillai dml_print("DML::%s: MyErr set. DestinationLinesToRequestVMInVBlank=%f (should be > 0)\n",
4071dda4fb85SAurabindo Pillai __func__, *DestinationLinesToRequestVMInVBlank);
4072dda4fb85SAurabindo Pillai #endif
4073dda4fb85SAurabindo Pillai }
4074dda4fb85SAurabindo Pillai
4075dda4fb85SAurabindo Pillai if (MetaRowByte + PixelPTEBytesPerRow == 0) {
4076dda4fb85SAurabindo Pillai prefetch_row_bw = 0;
4077dda4fb85SAurabindo Pillai } else if (*DestinationLinesToRequestRowInVBlank > 0) {
4078dda4fb85SAurabindo Pillai prefetch_row_bw = (MetaRowByte + PixelPTEBytesPerRow * HostVMInefficiencyFactor) /
4079efcc9706SRodrigo Siqueira (*DestinationLinesToRequestRowInVBlank * LineTime);
4080dda4fb85SAurabindo Pillai
4081dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4082dda4fb85SAurabindo Pillai dml_print("DML::%s: MetaRowByte = %d\n", __func__, MetaRowByte);
4083dda4fb85SAurabindo Pillai dml_print("DML::%s: PixelPTEBytesPerRow = %d\n", __func__, PixelPTEBytesPerRow);
4084dda4fb85SAurabindo Pillai dml_print("DML::%s: DestinationLinesToRequestRowInVBlank = %f\n",
4085dda4fb85SAurabindo Pillai __func__, *DestinationLinesToRequestRowInVBlank);
4086dda4fb85SAurabindo Pillai dml_print("DML::%s: prefetch_row_bw = %f\n", __func__, prefetch_row_bw);
4087dda4fb85SAurabindo Pillai #endif
4088dda4fb85SAurabindo Pillai } else {
4089dda4fb85SAurabindo Pillai prefetch_row_bw = 0;
4090dda4fb85SAurabindo Pillai MyError = true;
4091dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4092dda4fb85SAurabindo Pillai dml_print("DML::%s: MyErr set. DestinationLinesToRequestRowInVBlank=%f (should be > 0)\n",
4093dda4fb85SAurabindo Pillai __func__, *DestinationLinesToRequestRowInVBlank);
4094dda4fb85SAurabindo Pillai #endif
4095dda4fb85SAurabindo Pillai }
4096dda4fb85SAurabindo Pillai
4097dda4fb85SAurabindo Pillai *prefetch_vmrow_bw = dml_max(prefetch_vm_bw, prefetch_row_bw);
4098dda4fb85SAurabindo Pillai }
4099dda4fb85SAurabindo Pillai
4100dda4fb85SAurabindo Pillai if (MyError) {
4101dda4fb85SAurabindo Pillai *PrefetchBandwidth = 0;
4102efcc9706SRodrigo Siqueira TimeForFetchingMetaPTE = 0;
4103efcc9706SRodrigo Siqueira TimeForFetchingRowInVBlank = 0;
4104dda4fb85SAurabindo Pillai *DestinationLinesToRequestVMInVBlank = 0;
4105dda4fb85SAurabindo Pillai *DestinationLinesToRequestRowInVBlank = 0;
4106dda4fb85SAurabindo Pillai *DestinationLinesForPrefetch = 0;
4107efcc9706SRodrigo Siqueira LinesToRequestPrefetchPixelData = 0;
4108dda4fb85SAurabindo Pillai *VRatioPrefetchY = 0;
4109dda4fb85SAurabindo Pillai *VRatioPrefetchC = 0;
4110dda4fb85SAurabindo Pillai *RequiredPrefetchPixDataBWLuma = 0;
4111dda4fb85SAurabindo Pillai *RequiredPrefetchPixDataBWChroma = 0;
4112dda4fb85SAurabindo Pillai }
4113dda4fb85SAurabindo Pillai
4114dda4fb85SAurabindo Pillai return MyError;
4115dda4fb85SAurabindo Pillai } // CalculatePrefetchSchedule
4116dda4fb85SAurabindo Pillai
dml32_CalculateFlipSchedule(double HostVMInefficiencyFactor,double UrgentExtraLatency,double UrgentLatency,unsigned int GPUVMMaxPageTableLevels,bool HostVMEnable,unsigned int HostVMMaxNonCachedPageTableLevels,bool GPUVMEnable,double HostVMMinPageSize,double PDEAndMetaPTEBytesPerFrame,double MetaRowBytes,double DPTEBytesPerRow,double BandwidthAvailableForImmediateFlip,unsigned int TotImmediateFlipBytes,enum source_format_class SourcePixelFormat,double LineTime,double VRatio,double VRatioChroma,double Tno_bw,bool DCCEnable,unsigned int dpte_row_height,unsigned int meta_row_height,unsigned int dpte_row_height_chroma,unsigned int meta_row_height_chroma,bool use_one_row_for_frame_flip,double * DestinationLinesToRequestVMInImmediateFlip,double * DestinationLinesToRequestRowInImmediateFlip,double * final_flip_bw,bool * ImmediateFlipSupportedForPipe)4117dda4fb85SAurabindo Pillai void dml32_CalculateFlipSchedule(
4118dda4fb85SAurabindo Pillai double HostVMInefficiencyFactor,
4119dda4fb85SAurabindo Pillai double UrgentExtraLatency,
4120dda4fb85SAurabindo Pillai double UrgentLatency,
4121dda4fb85SAurabindo Pillai unsigned int GPUVMMaxPageTableLevels,
4122dda4fb85SAurabindo Pillai bool HostVMEnable,
4123dda4fb85SAurabindo Pillai unsigned int HostVMMaxNonCachedPageTableLevels,
4124dda4fb85SAurabindo Pillai bool GPUVMEnable,
4125dda4fb85SAurabindo Pillai double HostVMMinPageSize,
4126dda4fb85SAurabindo Pillai double PDEAndMetaPTEBytesPerFrame,
4127dda4fb85SAurabindo Pillai double MetaRowBytes,
4128dda4fb85SAurabindo Pillai double DPTEBytesPerRow,
4129dda4fb85SAurabindo Pillai double BandwidthAvailableForImmediateFlip,
4130dda4fb85SAurabindo Pillai unsigned int TotImmediateFlipBytes,
4131dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat,
4132dda4fb85SAurabindo Pillai double LineTime,
4133dda4fb85SAurabindo Pillai double VRatio,
4134dda4fb85SAurabindo Pillai double VRatioChroma,
4135dda4fb85SAurabindo Pillai double Tno_bw,
4136dda4fb85SAurabindo Pillai bool DCCEnable,
4137dda4fb85SAurabindo Pillai unsigned int dpte_row_height,
4138dda4fb85SAurabindo Pillai unsigned int meta_row_height,
4139dda4fb85SAurabindo Pillai unsigned int dpte_row_height_chroma,
4140dda4fb85SAurabindo Pillai unsigned int meta_row_height_chroma,
4141dda4fb85SAurabindo Pillai bool use_one_row_for_frame_flip,
4142dda4fb85SAurabindo Pillai
4143dda4fb85SAurabindo Pillai /* Output */
4144dda4fb85SAurabindo Pillai double *DestinationLinesToRequestVMInImmediateFlip,
4145dda4fb85SAurabindo Pillai double *DestinationLinesToRequestRowInImmediateFlip,
4146dda4fb85SAurabindo Pillai double *final_flip_bw,
4147dda4fb85SAurabindo Pillai bool *ImmediateFlipSupportedForPipe)
4148dda4fb85SAurabindo Pillai {
4149dda4fb85SAurabindo Pillai double min_row_time = 0.0;
4150dda4fb85SAurabindo Pillai unsigned int HostVMDynamicLevelsTrips;
4151dda4fb85SAurabindo Pillai double TimeForFetchingMetaPTEImmediateFlip;
4152dda4fb85SAurabindo Pillai double TimeForFetchingRowInVBlankImmediateFlip;
41533999edf8SMeera Patel double ImmediateFlipBW = 1.0;
4154dda4fb85SAurabindo Pillai
4155dda4fb85SAurabindo Pillai if (GPUVMEnable == true && HostVMEnable == true)
4156dda4fb85SAurabindo Pillai HostVMDynamicLevelsTrips = HostVMMaxNonCachedPageTableLevels;
4157dda4fb85SAurabindo Pillai else
4158dda4fb85SAurabindo Pillai HostVMDynamicLevelsTrips = 0;
4159dda4fb85SAurabindo Pillai
4160dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4161dda4fb85SAurabindo Pillai dml_print("DML::%s: TotImmediateFlipBytes = %d\n", __func__, TotImmediateFlipBytes);
4162dda4fb85SAurabindo Pillai dml_print("DML::%s: BandwidthAvailableForImmediateFlip = %f\n", __func__, BandwidthAvailableForImmediateFlip);
4163dda4fb85SAurabindo Pillai #endif
4164dda4fb85SAurabindo Pillai
4165dda4fb85SAurabindo Pillai if (TotImmediateFlipBytes > 0) {
4166dda4fb85SAurabindo Pillai if (use_one_row_for_frame_flip) {
4167dda4fb85SAurabindo Pillai ImmediateFlipBW = (PDEAndMetaPTEBytesPerFrame + MetaRowBytes + 2 * DPTEBytesPerRow) *
4168dda4fb85SAurabindo Pillai BandwidthAvailableForImmediateFlip / TotImmediateFlipBytes;
4169dda4fb85SAurabindo Pillai } else {
4170dda4fb85SAurabindo Pillai ImmediateFlipBW = (PDEAndMetaPTEBytesPerFrame + MetaRowBytes + DPTEBytesPerRow) *
4171dda4fb85SAurabindo Pillai BandwidthAvailableForImmediateFlip / TotImmediateFlipBytes;
4172dda4fb85SAurabindo Pillai }
4173dda4fb85SAurabindo Pillai if (GPUVMEnable == true) {
4174dda4fb85SAurabindo Pillai TimeForFetchingMetaPTEImmediateFlip = dml_max3(Tno_bw + PDEAndMetaPTEBytesPerFrame *
4175dda4fb85SAurabindo Pillai HostVMInefficiencyFactor / ImmediateFlipBW,
4176dda4fb85SAurabindo Pillai UrgentExtraLatency + UrgentLatency *
4177dda4fb85SAurabindo Pillai (GPUVMMaxPageTableLevels * (HostVMDynamicLevelsTrips + 1) - 1),
4178dda4fb85SAurabindo Pillai LineTime / 4.0);
4179dda4fb85SAurabindo Pillai } else {
4180dda4fb85SAurabindo Pillai TimeForFetchingMetaPTEImmediateFlip = 0;
4181dda4fb85SAurabindo Pillai }
4182dda4fb85SAurabindo Pillai if ((GPUVMEnable == true || DCCEnable == true)) {
4183dda4fb85SAurabindo Pillai TimeForFetchingRowInVBlankImmediateFlip = dml_max3(
4184dda4fb85SAurabindo Pillai (MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) / ImmediateFlipBW,
4185dda4fb85SAurabindo Pillai UrgentLatency * (HostVMDynamicLevelsTrips + 1), LineTime / 4.0);
4186dda4fb85SAurabindo Pillai } else {
4187dda4fb85SAurabindo Pillai TimeForFetchingRowInVBlankImmediateFlip = 0;
4188dda4fb85SAurabindo Pillai }
4189dda4fb85SAurabindo Pillai
4190dda4fb85SAurabindo Pillai *DestinationLinesToRequestVMInImmediateFlip =
4191dda4fb85SAurabindo Pillai dml_ceil(4.0 * (TimeForFetchingMetaPTEImmediateFlip / LineTime), 1.0) / 4.0;
4192dda4fb85SAurabindo Pillai *DestinationLinesToRequestRowInImmediateFlip =
4193dda4fb85SAurabindo Pillai dml_ceil(4.0 * (TimeForFetchingRowInVBlankImmediateFlip / LineTime), 1.0) / 4.0;
4194dda4fb85SAurabindo Pillai
4195dda4fb85SAurabindo Pillai if (GPUVMEnable == true) {
4196dda4fb85SAurabindo Pillai *final_flip_bw = dml_max(PDEAndMetaPTEBytesPerFrame * HostVMInefficiencyFactor /
4197dda4fb85SAurabindo Pillai (*DestinationLinesToRequestVMInImmediateFlip * LineTime),
4198dda4fb85SAurabindo Pillai (MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) /
4199dda4fb85SAurabindo Pillai (*DestinationLinesToRequestRowInImmediateFlip * LineTime));
4200dda4fb85SAurabindo Pillai } else if ((GPUVMEnable == true || DCCEnable == true)) {
4201dda4fb85SAurabindo Pillai *final_flip_bw = (MetaRowBytes + DPTEBytesPerRow * HostVMInefficiencyFactor) /
4202dda4fb85SAurabindo Pillai (*DestinationLinesToRequestRowInImmediateFlip * LineTime);
4203dda4fb85SAurabindo Pillai } else {
4204dda4fb85SAurabindo Pillai *final_flip_bw = 0;
4205dda4fb85SAurabindo Pillai }
4206dda4fb85SAurabindo Pillai } else {
4207dda4fb85SAurabindo Pillai TimeForFetchingMetaPTEImmediateFlip = 0;
4208dda4fb85SAurabindo Pillai TimeForFetchingRowInVBlankImmediateFlip = 0;
4209dda4fb85SAurabindo Pillai *DestinationLinesToRequestVMInImmediateFlip = 0;
4210dda4fb85SAurabindo Pillai *DestinationLinesToRequestRowInImmediateFlip = 0;
4211dda4fb85SAurabindo Pillai *final_flip_bw = 0;
4212dda4fb85SAurabindo Pillai }
4213dda4fb85SAurabindo Pillai
4214dda4fb85SAurabindo Pillai if (SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10 || SourcePixelFormat == dm_rgbe_alpha) {
4215dda4fb85SAurabindo Pillai if (GPUVMEnable == true && DCCEnable != true) {
4216dda4fb85SAurabindo Pillai min_row_time = dml_min(dpte_row_height *
4217dda4fb85SAurabindo Pillai LineTime / VRatio, dpte_row_height_chroma * LineTime / VRatioChroma);
4218dda4fb85SAurabindo Pillai } else if (GPUVMEnable != true && DCCEnable == true) {
4219dda4fb85SAurabindo Pillai min_row_time = dml_min(meta_row_height *
4220dda4fb85SAurabindo Pillai LineTime / VRatio, meta_row_height_chroma * LineTime / VRatioChroma);
4221dda4fb85SAurabindo Pillai } else {
4222dda4fb85SAurabindo Pillai min_row_time = dml_min4(dpte_row_height * LineTime / VRatio, meta_row_height *
4223dda4fb85SAurabindo Pillai LineTime / VRatio, dpte_row_height_chroma * LineTime /
4224dda4fb85SAurabindo Pillai VRatioChroma, meta_row_height_chroma * LineTime / VRatioChroma);
4225dda4fb85SAurabindo Pillai }
4226dda4fb85SAurabindo Pillai } else {
4227dda4fb85SAurabindo Pillai if (GPUVMEnable == true && DCCEnable != true) {
4228dda4fb85SAurabindo Pillai min_row_time = dpte_row_height * LineTime / VRatio;
4229dda4fb85SAurabindo Pillai } else if (GPUVMEnable != true && DCCEnable == true) {
4230dda4fb85SAurabindo Pillai min_row_time = meta_row_height * LineTime / VRatio;
4231dda4fb85SAurabindo Pillai } else {
4232dda4fb85SAurabindo Pillai min_row_time =
4233dda4fb85SAurabindo Pillai dml_min(dpte_row_height * LineTime / VRatio, meta_row_height * LineTime / VRatio);
4234dda4fb85SAurabindo Pillai }
4235dda4fb85SAurabindo Pillai }
4236dda4fb85SAurabindo Pillai
4237dda4fb85SAurabindo Pillai if (*DestinationLinesToRequestVMInImmediateFlip >= 32 || *DestinationLinesToRequestRowInImmediateFlip >= 16
4238dda4fb85SAurabindo Pillai || TimeForFetchingMetaPTEImmediateFlip + 2 * TimeForFetchingRowInVBlankImmediateFlip
4239dda4fb85SAurabindo Pillai > min_row_time) {
4240dda4fb85SAurabindo Pillai *ImmediateFlipSupportedForPipe = false;
4241dda4fb85SAurabindo Pillai } else {
4242dda4fb85SAurabindo Pillai *ImmediateFlipSupportedForPipe = true;
4243dda4fb85SAurabindo Pillai }
4244dda4fb85SAurabindo Pillai
4245dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4246dda4fb85SAurabindo Pillai dml_print("DML::%s: GPUVMEnable = %d\n", __func__, GPUVMEnable);
4247dda4fb85SAurabindo Pillai dml_print("DML::%s: DCCEnable = %d\n", __func__, DCCEnable);
4248dda4fb85SAurabindo Pillai dml_print("DML::%s: DestinationLinesToRequestVMInImmediateFlip = %f\n",
4249dda4fb85SAurabindo Pillai __func__, *DestinationLinesToRequestVMInImmediateFlip);
4250dda4fb85SAurabindo Pillai dml_print("DML::%s: DestinationLinesToRequestRowInImmediateFlip = %f\n",
4251dda4fb85SAurabindo Pillai __func__, *DestinationLinesToRequestRowInImmediateFlip);
4252dda4fb85SAurabindo Pillai dml_print("DML::%s: TimeForFetchingMetaPTEImmediateFlip = %f\n", __func__, TimeForFetchingMetaPTEImmediateFlip);
4253dda4fb85SAurabindo Pillai dml_print("DML::%s: TimeForFetchingRowInVBlankImmediateFlip = %f\n",
4254dda4fb85SAurabindo Pillai __func__, TimeForFetchingRowInVBlankImmediateFlip);
4255dda4fb85SAurabindo Pillai dml_print("DML::%s: min_row_time = %f\n", __func__, min_row_time);
4256dda4fb85SAurabindo Pillai dml_print("DML::%s: ImmediateFlipSupportedForPipe = %d\n", __func__, *ImmediateFlipSupportedForPipe);
4257dda4fb85SAurabindo Pillai #endif
4258dda4fb85SAurabindo Pillai } // CalculateFlipSchedule
4259dda4fb85SAurabindo Pillai
dml32_CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(struct vba_vars_st * v,unsigned int PrefetchMode,double DCFCLK,double ReturnBW,SOCParametersList mmSOCParameters,double SOCCLK,double DCFClkDeepSleep,unsigned int DETBufferSizeY[],unsigned int DETBufferSizeC[],unsigned int SwathHeightY[],unsigned int SwathHeightC[],double SwathWidthY[],double SwathWidthC[],unsigned int DPPPerSurface[],double BytePerPixelDETY[],double BytePerPixelDETC[],double DSTXAfterScaler[],double DSTYAfterScaler[],bool UnboundedRequestEnabled,unsigned int CompressedBufferSizeInkByte,enum clock_change_support * DRAMClockChangeSupport,double MaxActiveDRAMClockChangeLatencySupported[],unsigned int SubViewportLinesNeededInMALL[],enum dm_fclock_change_support * FCLKChangeSupport,double * MinActiveFCLKChangeLatencySupported,bool * USRRetrainingSupport,double ActiveDRAMClockChangeLatencyMargin[])4260dda4fb85SAurabindo Pillai void dml32_CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport(
42611df7e569SNathan Chancellor struct vba_vars_st *v,
4262dda4fb85SAurabindo Pillai unsigned int PrefetchMode,
4263dda4fb85SAurabindo Pillai double DCFCLK,
4264dda4fb85SAurabindo Pillai double ReturnBW,
4265dda4fb85SAurabindo Pillai SOCParametersList mmSOCParameters,
4266dda4fb85SAurabindo Pillai double SOCCLK,
4267dda4fb85SAurabindo Pillai double DCFClkDeepSleep,
4268dda4fb85SAurabindo Pillai unsigned int DETBufferSizeY[],
4269dda4fb85SAurabindo Pillai unsigned int DETBufferSizeC[],
4270dda4fb85SAurabindo Pillai unsigned int SwathHeightY[],
4271dda4fb85SAurabindo Pillai unsigned int SwathHeightC[],
4272dda4fb85SAurabindo Pillai double SwathWidthY[],
4273dda4fb85SAurabindo Pillai double SwathWidthC[],
4274dda4fb85SAurabindo Pillai unsigned int DPPPerSurface[],
4275dda4fb85SAurabindo Pillai double BytePerPixelDETY[],
4276dda4fb85SAurabindo Pillai double BytePerPixelDETC[],
4277dda4fb85SAurabindo Pillai double DSTXAfterScaler[],
4278dda4fb85SAurabindo Pillai double DSTYAfterScaler[],
4279dda4fb85SAurabindo Pillai bool UnboundedRequestEnabled,
4280dda4fb85SAurabindo Pillai unsigned int CompressedBufferSizeInkByte,
4281dda4fb85SAurabindo Pillai
4282dda4fb85SAurabindo Pillai /* Output */
4283dda4fb85SAurabindo Pillai enum clock_change_support *DRAMClockChangeSupport,
4284dda4fb85SAurabindo Pillai double MaxActiveDRAMClockChangeLatencySupported[],
4285dda4fb85SAurabindo Pillai unsigned int SubViewportLinesNeededInMALL[],
4286dda4fb85SAurabindo Pillai enum dm_fclock_change_support *FCLKChangeSupport,
4287dda4fb85SAurabindo Pillai double *MinActiveFCLKChangeLatencySupported,
4288dda4fb85SAurabindo Pillai bool *USRRetrainingSupport,
4289dda4fb85SAurabindo Pillai double ActiveDRAMClockChangeLatencyMargin[])
4290dda4fb85SAurabindo Pillai {
4291dda4fb85SAurabindo Pillai unsigned int i, j, k;
42920ee7cc80SRodrigo Siqueira unsigned int SurfaceWithMinActiveFCLKChangeMargin = 0;
42930ee7cc80SRodrigo Siqueira unsigned int DRAMClockChangeSupportNumber = 0;
42940ee7cc80SRodrigo Siqueira unsigned int LastSurfaceWithoutMargin;
42950ee7cc80SRodrigo Siqueira unsigned int DRAMClockChangeMethod = 0;
42960ee7cc80SRodrigo Siqueira bool FoundFirstSurfaceWithMinActiveFCLKChangeMargin = false;
42970ee7cc80SRodrigo Siqueira double MinActiveFCLKChangeMargin = 0.;
42980ee7cc80SRodrigo Siqueira double SecondMinActiveFCLKChangeMarginOneDisplayInVBLank = 0.;
42990ee7cc80SRodrigo Siqueira double ActiveClockChangeLatencyHidingY;
43000ee7cc80SRodrigo Siqueira double ActiveClockChangeLatencyHidingC;
43010ee7cc80SRodrigo Siqueira double ActiveClockChangeLatencyHiding;
43020ee7cc80SRodrigo Siqueira double EffectiveDETBufferSizeY;
43030ee7cc80SRodrigo Siqueira double ActiveFCLKChangeLatencyMargin[DC__NUM_DPP__MAX];
43040ee7cc80SRodrigo Siqueira double USRRetrainingLatencyMargin[DC__NUM_DPP__MAX];
43050ee7cc80SRodrigo Siqueira double TotalPixelBW = 0.0;
43060ee7cc80SRodrigo Siqueira bool SynchronizedSurfaces[DC__NUM_DPP__MAX][DC__NUM_DPP__MAX];
43070ee7cc80SRodrigo Siqueira double EffectiveLBLatencyHidingY;
43080ee7cc80SRodrigo Siqueira double EffectiveLBLatencyHidingC;
43090ee7cc80SRodrigo Siqueira double LinesInDETY[DC__NUM_DPP__MAX];
43100ee7cc80SRodrigo Siqueira double LinesInDETC[DC__NUM_DPP__MAX];
43110ee7cc80SRodrigo Siqueira unsigned int LinesInDETYRoundedDownToSwath[DC__NUM_DPP__MAX];
43120ee7cc80SRodrigo Siqueira unsigned int LinesInDETCRoundedDownToSwath[DC__NUM_DPP__MAX];
43130ee7cc80SRodrigo Siqueira double FullDETBufferingTimeY;
43140ee7cc80SRodrigo Siqueira double FullDETBufferingTimeC;
43150ee7cc80SRodrigo Siqueira double WritebackDRAMClockChangeLatencyMargin;
43160ee7cc80SRodrigo Siqueira double WritebackFCLKChangeLatencyMargin;
43170ee7cc80SRodrigo Siqueira double WritebackLatencyHiding;
43180ee7cc80SRodrigo Siqueira bool SameTimingForFCLKChange;
4319dda4fb85SAurabindo Pillai
43200ee7cc80SRodrigo Siqueira unsigned int TotalActiveWriteback = 0;
43210ee7cc80SRodrigo Siqueira unsigned int LBLatencyHidingSourceLinesY[DC__NUM_DPP__MAX];
43220ee7cc80SRodrigo Siqueira unsigned int LBLatencyHidingSourceLinesC[DC__NUM_DPP__MAX];
4323dda4fb85SAurabindo Pillai
43241df7e569SNathan Chancellor v->Watermark.UrgentWatermark = mmSOCParameters.UrgentLatency + mmSOCParameters.ExtraLatency;
43251df7e569SNathan Chancellor v->Watermark.USRRetrainingWatermark = mmSOCParameters.UrgentLatency + mmSOCParameters.ExtraLatency
4326dda4fb85SAurabindo Pillai + mmSOCParameters.USRRetrainingLatency + mmSOCParameters.SMNLatency;
43271df7e569SNathan Chancellor v->Watermark.DRAMClockChangeWatermark = mmSOCParameters.DRAMClockChangeLatency + v->Watermark.UrgentWatermark;
43281df7e569SNathan Chancellor v->Watermark.FCLKChangeWatermark = mmSOCParameters.FCLKChangeLatency + v->Watermark.UrgentWatermark;
43291df7e569SNathan Chancellor v->Watermark.StutterExitWatermark = mmSOCParameters.SRExitTime + mmSOCParameters.ExtraLatency
4330dda4fb85SAurabindo Pillai + 10 / DCFClkDeepSleep;
43311df7e569SNathan Chancellor v->Watermark.StutterEnterPlusExitWatermark = mmSOCParameters.SREnterPlusExitTime + mmSOCParameters.ExtraLatency
4332dda4fb85SAurabindo Pillai + 10 / DCFClkDeepSleep;
43331df7e569SNathan Chancellor v->Watermark.Z8StutterExitWatermark = mmSOCParameters.SRExitZ8Time + mmSOCParameters.ExtraLatency
4334dda4fb85SAurabindo Pillai + 10 / DCFClkDeepSleep;
43351df7e569SNathan Chancellor v->Watermark.Z8StutterEnterPlusExitWatermark = mmSOCParameters.SREnterPlusExitZ8Time
4336dda4fb85SAurabindo Pillai + mmSOCParameters.ExtraLatency + 10 / DCFClkDeepSleep;
4337dda4fb85SAurabindo Pillai
4338dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4339dda4fb85SAurabindo Pillai dml_print("DML::%s: UrgentLatency = %f\n", __func__, mmSOCParameters.UrgentLatency);
4340dda4fb85SAurabindo Pillai dml_print("DML::%s: ExtraLatency = %f\n", __func__, mmSOCParameters.ExtraLatency);
4341dda4fb85SAurabindo Pillai dml_print("DML::%s: DRAMClockChangeLatency = %f\n", __func__, mmSOCParameters.DRAMClockChangeLatency);
43421df7e569SNathan Chancellor dml_print("DML::%s: UrgentWatermark = %f\n", __func__, v->Watermark.UrgentWatermark);
43431df7e569SNathan Chancellor dml_print("DML::%s: USRRetrainingWatermark = %f\n", __func__, v->Watermark.USRRetrainingWatermark);
43441df7e569SNathan Chancellor dml_print("DML::%s: DRAMClockChangeWatermark = %f\n", __func__, v->Watermark.DRAMClockChangeWatermark);
43451df7e569SNathan Chancellor dml_print("DML::%s: FCLKChangeWatermark = %f\n", __func__, v->Watermark.FCLKChangeWatermark);
43461df7e569SNathan Chancellor dml_print("DML::%s: StutterExitWatermark = %f\n", __func__, v->Watermark.StutterExitWatermark);
43471df7e569SNathan Chancellor dml_print("DML::%s: StutterEnterPlusExitWatermark = %f\n", __func__, v->Watermark.StutterEnterPlusExitWatermark);
43481df7e569SNathan Chancellor dml_print("DML::%s: Z8StutterExitWatermark = %f\n", __func__, v->Watermark.Z8StutterExitWatermark);
4349dda4fb85SAurabindo Pillai dml_print("DML::%s: Z8StutterEnterPlusExitWatermark = %f\n",
43501df7e569SNathan Chancellor __func__, v->Watermark.Z8StutterEnterPlusExitWatermark);
4351dda4fb85SAurabindo Pillai #endif
4352dda4fb85SAurabindo Pillai
4353dda4fb85SAurabindo Pillai
43540ee7cc80SRodrigo Siqueira TotalActiveWriteback = 0;
43551df7e569SNathan Chancellor for (k = 0; k < v->NumberOfActiveSurfaces; ++k) {
43561df7e569SNathan Chancellor if (v->WritebackEnable[k] == true)
43570ee7cc80SRodrigo Siqueira TotalActiveWriteback = TotalActiveWriteback + 1;
4358dda4fb85SAurabindo Pillai }
4359dda4fb85SAurabindo Pillai
43600ee7cc80SRodrigo Siqueira if (TotalActiveWriteback <= 1) {
43611df7e569SNathan Chancellor v->Watermark.WritebackUrgentWatermark = mmSOCParameters.WritebackLatency;
4362dda4fb85SAurabindo Pillai } else {
43631df7e569SNathan Chancellor v->Watermark.WritebackUrgentWatermark = mmSOCParameters.WritebackLatency
43641df7e569SNathan Chancellor + v->WritebackChunkSize * 1024.0 / 32.0 / SOCCLK;
4365dda4fb85SAurabindo Pillai }
43661df7e569SNathan Chancellor if (v->USRRetrainingRequiredFinal)
4367a1f1fecdSAurabindo Pillai v->Watermark.WritebackDRAMClockChangeWatermark = v->Watermark.WritebackDRAMClockChangeWatermark
4368dda4fb85SAurabindo Pillai + mmSOCParameters.USRRetrainingLatency;
4369dda4fb85SAurabindo Pillai
43700ee7cc80SRodrigo Siqueira if (TotalActiveWriteback <= 1) {
43711df7e569SNathan Chancellor v->Watermark.WritebackDRAMClockChangeWatermark = mmSOCParameters.DRAMClockChangeLatency
4372dda4fb85SAurabindo Pillai + mmSOCParameters.WritebackLatency;
43731df7e569SNathan Chancellor v->Watermark.WritebackFCLKChangeWatermark = mmSOCParameters.FCLKChangeLatency
4374dda4fb85SAurabindo Pillai + mmSOCParameters.WritebackLatency;
4375dda4fb85SAurabindo Pillai } else {
43761df7e569SNathan Chancellor v->Watermark.WritebackDRAMClockChangeWatermark = mmSOCParameters.DRAMClockChangeLatency
43771df7e569SNathan Chancellor + mmSOCParameters.WritebackLatency + v->WritebackChunkSize * 1024.0 / 32.0 / SOCCLK;
43781df7e569SNathan Chancellor v->Watermark.WritebackFCLKChangeWatermark = mmSOCParameters.FCLKChangeLatency
43791df7e569SNathan Chancellor + mmSOCParameters.WritebackLatency + v->WritebackChunkSize * 1024 / 32 / SOCCLK;
4380dda4fb85SAurabindo Pillai }
4381dda4fb85SAurabindo Pillai
43821df7e569SNathan Chancellor if (v->USRRetrainingRequiredFinal)
43831df7e569SNathan Chancellor v->Watermark.WritebackDRAMClockChangeWatermark = v->Watermark.WritebackDRAMClockChangeWatermark
4384dda4fb85SAurabindo Pillai + mmSOCParameters.USRRetrainingLatency;
4385dda4fb85SAurabindo Pillai
43861df7e569SNathan Chancellor if (v->USRRetrainingRequiredFinal)
43871df7e569SNathan Chancellor v->Watermark.WritebackFCLKChangeWatermark = v->Watermark.WritebackFCLKChangeWatermark
4388dda4fb85SAurabindo Pillai + mmSOCParameters.USRRetrainingLatency;
4389dda4fb85SAurabindo Pillai
4390dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4391dda4fb85SAurabindo Pillai dml_print("DML::%s: WritebackDRAMClockChangeWatermark = %f\n",
43921df7e569SNathan Chancellor __func__, v->Watermark.WritebackDRAMClockChangeWatermark);
43931df7e569SNathan Chancellor dml_print("DML::%s: WritebackFCLKChangeWatermark = %f\n", __func__, v->Watermark.WritebackFCLKChangeWatermark);
43941df7e569SNathan Chancellor dml_print("DML::%s: WritebackUrgentWatermark = %f\n", __func__, v->Watermark.WritebackUrgentWatermark);
43951df7e569SNathan Chancellor dml_print("DML::%s: v->USRRetrainingRequiredFinal = %d\n", __func__, v->USRRetrainingRequiredFinal);
4396dda4fb85SAurabindo Pillai dml_print("DML::%s: USRRetrainingLatency = %f\n", __func__, mmSOCParameters.USRRetrainingLatency);
4397dda4fb85SAurabindo Pillai #endif
4398dda4fb85SAurabindo Pillai
43991df7e569SNathan Chancellor for (k = 0; k < v->NumberOfActiveSurfaces; ++k) {
44001df7e569SNathan Chancellor TotalPixelBW = TotalPixelBW + DPPPerSurface[k] * (SwathWidthY[k] * BytePerPixelDETY[k] * v->VRatio[k] +
44011df7e569SNathan Chancellor SwathWidthC[k] * BytePerPixelDETC[k] * v->VRatioChroma[k]) / (v->HTotal[k] / v->PixelClock[k]);
4402dda4fb85SAurabindo Pillai }
4403dda4fb85SAurabindo Pillai
44041df7e569SNathan Chancellor for (k = 0; k < v->NumberOfActiveSurfaces; ++k) {
4405dda4fb85SAurabindo Pillai
44061df7e569SNathan Chancellor LBLatencyHidingSourceLinesY[k] = dml_min((double) v->MaxLineBufferLines, dml_floor(v->LineBufferSizeFinal / v->LBBitPerPixel[k] / (SwathWidthY[k] / dml_max(v->HRatio[k], 1.0)), 1)) - (v->vtaps[k] - 1);
44071df7e569SNathan Chancellor LBLatencyHidingSourceLinesC[k] = dml_min((double) v->MaxLineBufferLines, dml_floor(v->LineBufferSizeFinal / v->LBBitPerPixel[k] / (SwathWidthC[k] / dml_max(v->HRatioChroma[k], 1.0)), 1)) - (v->VTAPsChroma[k] - 1);
4408dda4fb85SAurabindo Pillai
4409dda4fb85SAurabindo Pillai
4410dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
44111df7e569SNathan Chancellor dml_print("DML::%s: k=%d, v->MaxLineBufferLines = %d\n", __func__, k, v->MaxLineBufferLines);
44121df7e569SNathan Chancellor dml_print("DML::%s: k=%d, v->LineBufferSizeFinal = %d\n", __func__, k, v->LineBufferSizeFinal);
44131df7e569SNathan Chancellor dml_print("DML::%s: k=%d, v->LBBitPerPixel = %d\n", __func__, k, v->LBBitPerPixel[k]);
44141df7e569SNathan Chancellor dml_print("DML::%s: k=%d, v->HRatio = %f\n", __func__, k, v->HRatio[k]);
44151df7e569SNathan Chancellor dml_print("DML::%s: k=%d, v->vtaps = %d\n", __func__, k, v->vtaps[k]);
4416dda4fb85SAurabindo Pillai #endif
4417dda4fb85SAurabindo Pillai
44181df7e569SNathan Chancellor EffectiveLBLatencyHidingY = LBLatencyHidingSourceLinesY[k] / v->VRatio[k] * (v->HTotal[k] / v->PixelClock[k]);
44191df7e569SNathan Chancellor EffectiveLBLatencyHidingC = LBLatencyHidingSourceLinesC[k] / v->VRatioChroma[k] * (v->HTotal[k] / v->PixelClock[k]);
44200ee7cc80SRodrigo Siqueira EffectiveDETBufferSizeY = DETBufferSizeY[k];
4421dda4fb85SAurabindo Pillai
4422dda4fb85SAurabindo Pillai if (UnboundedRequestEnabled) {
44230ee7cc80SRodrigo Siqueira EffectiveDETBufferSizeY = EffectiveDETBufferSizeY
4424dda4fb85SAurabindo Pillai + CompressedBufferSizeInkByte * 1024
44251df7e569SNathan Chancellor * (SwathWidthY[k] * BytePerPixelDETY[k] * v->VRatio[k])
44261df7e569SNathan Chancellor / (v->HTotal[k] / v->PixelClock[k]) / TotalPixelBW;
4427dda4fb85SAurabindo Pillai }
4428dda4fb85SAurabindo Pillai
44290ee7cc80SRodrigo Siqueira LinesInDETY[k] = (double) EffectiveDETBufferSizeY / BytePerPixelDETY[k] / SwathWidthY[k];
44300ee7cc80SRodrigo Siqueira LinesInDETYRoundedDownToSwath[k] = dml_floor(LinesInDETY[k], SwathHeightY[k]);
44311df7e569SNathan Chancellor FullDETBufferingTimeY = LinesInDETYRoundedDownToSwath[k] * (v->HTotal[k] / v->PixelClock[k]) / v->VRatio[k];
4432dda4fb85SAurabindo Pillai
44330ee7cc80SRodrigo Siqueira ActiveClockChangeLatencyHidingY = EffectiveLBLatencyHidingY + FullDETBufferingTimeY
44341df7e569SNathan Chancellor - (DSTXAfterScaler[k] / v->HTotal[k] + DSTYAfterScaler[k]) * v->HTotal[k] / v->PixelClock[k];
4435dda4fb85SAurabindo Pillai
44361df7e569SNathan Chancellor if (v->NumberOfActiveSurfaces > 1) {
44370ee7cc80SRodrigo Siqueira ActiveClockChangeLatencyHidingY = ActiveClockChangeLatencyHidingY
44382f8f9118SChaitanya Dhere - (1.0 - 1.0 / v->NumberOfActiveSurfaces) * SwathHeightY[k] * v->HTotal[k]
44391df7e569SNathan Chancellor / v->PixelClock[k] / v->VRatio[k];
4440dda4fb85SAurabindo Pillai }
4441dda4fb85SAurabindo Pillai
4442dda4fb85SAurabindo Pillai if (BytePerPixelDETC[k] > 0) {
44430ee7cc80SRodrigo Siqueira LinesInDETC[k] = DETBufferSizeC[k] / BytePerPixelDETC[k] / SwathWidthC[k];
44440ee7cc80SRodrigo Siqueira LinesInDETCRoundedDownToSwath[k] = dml_floor(LinesInDETC[k], SwathHeightC[k]);
44451df7e569SNathan Chancellor FullDETBufferingTimeC = LinesInDETCRoundedDownToSwath[k] * (v->HTotal[k] / v->PixelClock[k])
44461df7e569SNathan Chancellor / v->VRatioChroma[k];
44470ee7cc80SRodrigo Siqueira ActiveClockChangeLatencyHidingC = EffectiveLBLatencyHidingC + FullDETBufferingTimeC
44481df7e569SNathan Chancellor - (DSTXAfterScaler[k] / v->HTotal[k] + DSTYAfterScaler[k]) * v->HTotal[k]
44491df7e569SNathan Chancellor / v->PixelClock[k];
44501df7e569SNathan Chancellor if (v->NumberOfActiveSurfaces > 1) {
44510ee7cc80SRodrigo Siqueira ActiveClockChangeLatencyHidingC = ActiveClockChangeLatencyHidingC
44521df7e569SNathan Chancellor - (1 - 1 / v->NumberOfActiveSurfaces) * SwathHeightC[k] * v->HTotal[k]
44531df7e569SNathan Chancellor / v->PixelClock[k] / v->VRatioChroma[k];
4454dda4fb85SAurabindo Pillai }
44550ee7cc80SRodrigo Siqueira ActiveClockChangeLatencyHiding = dml_min(ActiveClockChangeLatencyHidingY,
44560ee7cc80SRodrigo Siqueira ActiveClockChangeLatencyHidingC);
4457dda4fb85SAurabindo Pillai } else {
44580ee7cc80SRodrigo Siqueira ActiveClockChangeLatencyHiding = ActiveClockChangeLatencyHidingY;
4459dda4fb85SAurabindo Pillai }
4460dda4fb85SAurabindo Pillai
44611df7e569SNathan Chancellor ActiveDRAMClockChangeLatencyMargin[k] = ActiveClockChangeLatencyHiding - v->Watermark.UrgentWatermark
44621df7e569SNathan Chancellor - v->Watermark.DRAMClockChangeWatermark;
44631df7e569SNathan Chancellor ActiveFCLKChangeLatencyMargin[k] = ActiveClockChangeLatencyHiding - v->Watermark.UrgentWatermark
44641df7e569SNathan Chancellor - v->Watermark.FCLKChangeWatermark;
44651df7e569SNathan Chancellor USRRetrainingLatencyMargin[k] = ActiveClockChangeLatencyHiding - v->Watermark.USRRetrainingWatermark;
4466dda4fb85SAurabindo Pillai
44671df7e569SNathan Chancellor if (v->WritebackEnable[k]) {
44681df7e569SNathan Chancellor WritebackLatencyHiding = v->WritebackInterfaceBufferSize * 1024
44691df7e569SNathan Chancellor / (v->WritebackDestinationWidth[k] * v->WritebackDestinationHeight[k]
44701df7e569SNathan Chancellor / (v->WritebackSourceHeight[k] * v->HTotal[k] / v->PixelClock[k]) * 4);
44711df7e569SNathan Chancellor if (v->WritebackPixelFormat[k] == dm_444_64)
44720ee7cc80SRodrigo Siqueira WritebackLatencyHiding = WritebackLatencyHiding / 2;
4473dda4fb85SAurabindo Pillai
44740ee7cc80SRodrigo Siqueira WritebackDRAMClockChangeLatencyMargin = WritebackLatencyHiding
44751df7e569SNathan Chancellor - v->Watermark.WritebackDRAMClockChangeWatermark;
4476dda4fb85SAurabindo Pillai
44770ee7cc80SRodrigo Siqueira WritebackFCLKChangeLatencyMargin = WritebackLatencyHiding
44781df7e569SNathan Chancellor - v->Watermark.WritebackFCLKChangeWatermark;
4479dda4fb85SAurabindo Pillai
4480dda4fb85SAurabindo Pillai ActiveDRAMClockChangeLatencyMargin[k] = dml_min(ActiveDRAMClockChangeLatencyMargin[k],
44810ee7cc80SRodrigo Siqueira WritebackFCLKChangeLatencyMargin);
44820ee7cc80SRodrigo Siqueira ActiveFCLKChangeLatencyMargin[k] = dml_min(ActiveFCLKChangeLatencyMargin[k],
44830ee7cc80SRodrigo Siqueira WritebackDRAMClockChangeLatencyMargin);
4484dda4fb85SAurabindo Pillai }
4485dda4fb85SAurabindo Pillai MaxActiveDRAMClockChangeLatencySupported[k] =
44861df7e569SNathan Chancellor (v->UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_phantom_pipe) ?
4487dda4fb85SAurabindo Pillai 0 :
4488dda4fb85SAurabindo Pillai (ActiveDRAMClockChangeLatencyMargin[k]
4489dda4fb85SAurabindo Pillai + mmSOCParameters.DRAMClockChangeLatency);
4490dda4fb85SAurabindo Pillai }
4491dda4fb85SAurabindo Pillai
44921df7e569SNathan Chancellor for (i = 0; i < v->NumberOfActiveSurfaces; ++i) {
44931df7e569SNathan Chancellor for (j = 0; j < v->NumberOfActiveSurfaces; ++j) {
4494dda4fb85SAurabindo Pillai if (i == j ||
44951df7e569SNathan Chancellor (v->BlendingAndTiming[i] == i && v->BlendingAndTiming[j] == i) ||
44961df7e569SNathan Chancellor (v->BlendingAndTiming[j] == j && v->BlendingAndTiming[i] == j) ||
44971df7e569SNathan Chancellor (v->BlendingAndTiming[i] == v->BlendingAndTiming[j] && v->BlendingAndTiming[i] != i) ||
44981df7e569SNathan Chancellor (v->SynchronizeTimingsFinal && v->PixelClock[i] == v->PixelClock[j] &&
44991df7e569SNathan Chancellor v->HTotal[i] == v->HTotal[j] && v->VTotal[i] == v->VTotal[j] &&
45001df7e569SNathan Chancellor v->VActive[i] == v->VActive[j]) || (v->SynchronizeDRRDisplaysForUCLKPStateChangeFinal &&
45011df7e569SNathan Chancellor (v->DRRDisplay[i] || v->DRRDisplay[j]))) {
45020ee7cc80SRodrigo Siqueira SynchronizedSurfaces[i][j] = true;
4503dda4fb85SAurabindo Pillai } else {
45040ee7cc80SRodrigo Siqueira SynchronizedSurfaces[i][j] = false;
4505dda4fb85SAurabindo Pillai }
4506dda4fb85SAurabindo Pillai }
4507dda4fb85SAurabindo Pillai }
4508dda4fb85SAurabindo Pillai
45091df7e569SNathan Chancellor for (k = 0; k < v->NumberOfActiveSurfaces; ++k) {
45101df7e569SNathan Chancellor if ((v->UsesMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe) &&
45110ee7cc80SRodrigo Siqueira (!FoundFirstSurfaceWithMinActiveFCLKChangeMargin ||
45120ee7cc80SRodrigo Siqueira ActiveFCLKChangeLatencyMargin[k] < MinActiveFCLKChangeMargin)) {
45130ee7cc80SRodrigo Siqueira FoundFirstSurfaceWithMinActiveFCLKChangeMargin = true;
45140ee7cc80SRodrigo Siqueira MinActiveFCLKChangeMargin = ActiveFCLKChangeLatencyMargin[k];
45150ee7cc80SRodrigo Siqueira SurfaceWithMinActiveFCLKChangeMargin = k;
4516dda4fb85SAurabindo Pillai }
4517dda4fb85SAurabindo Pillai }
4518dda4fb85SAurabindo Pillai
45190ee7cc80SRodrigo Siqueira *MinActiveFCLKChangeLatencySupported = MinActiveFCLKChangeMargin + mmSOCParameters.FCLKChangeLatency;
4520dda4fb85SAurabindo Pillai
45210ee7cc80SRodrigo Siqueira SameTimingForFCLKChange = true;
45221df7e569SNathan Chancellor for (k = 0; k < v->NumberOfActiveSurfaces; ++k) {
45230ee7cc80SRodrigo Siqueira if (!SynchronizedSurfaces[k][SurfaceWithMinActiveFCLKChangeMargin]) {
45241df7e569SNathan Chancellor if ((v->UsesMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe) &&
45250ee7cc80SRodrigo Siqueira (SameTimingForFCLKChange ||
45260ee7cc80SRodrigo Siqueira ActiveFCLKChangeLatencyMargin[k] <
45270ee7cc80SRodrigo Siqueira SecondMinActiveFCLKChangeMarginOneDisplayInVBLank)) {
45280ee7cc80SRodrigo Siqueira SecondMinActiveFCLKChangeMarginOneDisplayInVBLank = ActiveFCLKChangeLatencyMargin[k];
4529dda4fb85SAurabindo Pillai }
45300ee7cc80SRodrigo Siqueira SameTimingForFCLKChange = false;
4531dda4fb85SAurabindo Pillai }
4532dda4fb85SAurabindo Pillai }
4533dda4fb85SAurabindo Pillai
45340ee7cc80SRodrigo Siqueira if (MinActiveFCLKChangeMargin > 0) {
4535dda4fb85SAurabindo Pillai *FCLKChangeSupport = dm_fclock_change_vactive;
45360ee7cc80SRodrigo Siqueira } else if ((SameTimingForFCLKChange || SecondMinActiveFCLKChangeMarginOneDisplayInVBLank > 0) &&
4537dda4fb85SAurabindo Pillai (PrefetchMode <= 1)) {
4538dda4fb85SAurabindo Pillai *FCLKChangeSupport = dm_fclock_change_vblank;
4539dda4fb85SAurabindo Pillai } else {
4540dda4fb85SAurabindo Pillai *FCLKChangeSupport = dm_fclock_change_unsupported;
4541dda4fb85SAurabindo Pillai }
4542dda4fb85SAurabindo Pillai
4543dda4fb85SAurabindo Pillai *USRRetrainingSupport = true;
45441df7e569SNathan Chancellor for (k = 0; k < v->NumberOfActiveSurfaces; ++k) {
45451df7e569SNathan Chancellor if ((v->UsesMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe) &&
45460ee7cc80SRodrigo Siqueira (USRRetrainingLatencyMargin[k] < 0)) {
4547dda4fb85SAurabindo Pillai *USRRetrainingSupport = false;
4548dda4fb85SAurabindo Pillai }
4549dda4fb85SAurabindo Pillai }
4550dda4fb85SAurabindo Pillai
45511df7e569SNathan Chancellor for (k = 0; k < v->NumberOfActiveSurfaces; ++k) {
45521df7e569SNathan Chancellor if (v->UsesMALLForPStateChange[k] != dm_use_mall_pstate_change_full_frame &&
45531df7e569SNathan Chancellor v->UsesMALLForPStateChange[k] != dm_use_mall_pstate_change_sub_viewport &&
45541df7e569SNathan Chancellor v->UsesMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe &&
4555dda4fb85SAurabindo Pillai ActiveDRAMClockChangeLatencyMargin[k] < 0) {
4556dda4fb85SAurabindo Pillai if (PrefetchMode > 0) {
45570ee7cc80SRodrigo Siqueira DRAMClockChangeSupportNumber = 2;
45580ee7cc80SRodrigo Siqueira } else if (DRAMClockChangeSupportNumber == 0) {
45590ee7cc80SRodrigo Siqueira DRAMClockChangeSupportNumber = 1;
45600ee7cc80SRodrigo Siqueira LastSurfaceWithoutMargin = k;
45610ee7cc80SRodrigo Siqueira } else if (DRAMClockChangeSupportNumber == 1 &&
45620ee7cc80SRodrigo Siqueira !SynchronizedSurfaces[LastSurfaceWithoutMargin][k]) {
45630ee7cc80SRodrigo Siqueira DRAMClockChangeSupportNumber = 2;
4564dda4fb85SAurabindo Pillai }
4565dda4fb85SAurabindo Pillai }
4566dda4fb85SAurabindo Pillai }
4567dda4fb85SAurabindo Pillai
45681df7e569SNathan Chancellor for (k = 0; k < v->NumberOfActiveSurfaces; ++k) {
45691df7e569SNathan Chancellor if (v->UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_full_frame)
45700ee7cc80SRodrigo Siqueira DRAMClockChangeMethod = 1;
45711df7e569SNathan Chancellor else if (v->UsesMALLForPStateChange[k] == dm_use_mall_pstate_change_sub_viewport)
45720ee7cc80SRodrigo Siqueira DRAMClockChangeMethod = 2;
4573dda4fb85SAurabindo Pillai }
4574dda4fb85SAurabindo Pillai
45750ee7cc80SRodrigo Siqueira if (DRAMClockChangeMethod == 0) {
45760ee7cc80SRodrigo Siqueira if (DRAMClockChangeSupportNumber == 0)
4577dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_vactive;
45780ee7cc80SRodrigo Siqueira else if (DRAMClockChangeSupportNumber == 1)
4579dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_vblank;
4580dda4fb85SAurabindo Pillai else
4581dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_unsupported;
45820ee7cc80SRodrigo Siqueira } else if (DRAMClockChangeMethod == 1) {
45830ee7cc80SRodrigo Siqueira if (DRAMClockChangeSupportNumber == 0)
4584dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_vactive_w_mall_full_frame;
45850ee7cc80SRodrigo Siqueira else if (DRAMClockChangeSupportNumber == 1)
4586dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_vblank_w_mall_full_frame;
4587dda4fb85SAurabindo Pillai else
4588dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_unsupported;
4589dda4fb85SAurabindo Pillai } else {
45900ee7cc80SRodrigo Siqueira if (DRAMClockChangeSupportNumber == 0)
4591dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_vactive_w_mall_sub_vp;
45920ee7cc80SRodrigo Siqueira else if (DRAMClockChangeSupportNumber == 1)
4593dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_vblank_w_mall_sub_vp;
4594dda4fb85SAurabindo Pillai else
4595dda4fb85SAurabindo Pillai *DRAMClockChangeSupport = dm_dram_clock_change_unsupported;
4596dda4fb85SAurabindo Pillai }
4597dda4fb85SAurabindo Pillai
45981df7e569SNathan Chancellor for (k = 0; k < v->NumberOfActiveSurfaces; ++k) {
4599dda4fb85SAurabindo Pillai unsigned int dst_y_pstate;
4600dda4fb85SAurabindo Pillai unsigned int src_y_pstate_l;
4601dda4fb85SAurabindo Pillai unsigned int src_y_pstate_c;
4602dda4fb85SAurabindo Pillai unsigned int src_y_ahead_l, src_y_ahead_c, sub_vp_lines_l, sub_vp_lines_c;
4603dda4fb85SAurabindo Pillai
46041df7e569SNathan Chancellor dst_y_pstate = dml_ceil((mmSOCParameters.DRAMClockChangeLatency + mmSOCParameters.UrgentLatency) / (v->HTotal[k] / v->PixelClock[k]), 1);
46051df7e569SNathan Chancellor src_y_pstate_l = dml_ceil(dst_y_pstate * v->VRatio[k], SwathHeightY[k]);
46060ee7cc80SRodrigo Siqueira src_y_ahead_l = dml_floor(DETBufferSizeY[k] / BytePerPixelDETY[k] / SwathWidthY[k], SwathHeightY[k]) + LBLatencyHidingSourceLinesY[k];
46071df7e569SNathan Chancellor sub_vp_lines_l = src_y_pstate_l + src_y_ahead_l + v->meta_row_height[k];
4608dda4fb85SAurabindo Pillai
4609dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4610dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, DETBufferSizeY = %d\n", __func__, k, DETBufferSizeY[k]);
4611dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, BytePerPixelDETY = %f\n", __func__, k, BytePerPixelDETY[k]);
4612dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, SwathWidthY = %d\n", __func__, k, SwathWidthY[k]);
4613dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, SwathHeightY = %d\n", __func__, k, SwathHeightY[k]);
46140ee7cc80SRodrigo Siqueira dml_print("DML::%s: k=%d, LBLatencyHidingSourceLinesY = %d\n", __func__, k, LBLatencyHidingSourceLinesY[k]);
4615dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, dst_y_pstate = %d\n", __func__, k, dst_y_pstate);
4616dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, src_y_pstate_l = %d\n", __func__, k, src_y_pstate_l);
4617dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, src_y_ahead_l = %d\n", __func__, k, src_y_ahead_l);
46181df7e569SNathan Chancellor dml_print("DML::%s: k=%d, v->meta_row_height = %d\n", __func__, k, v->meta_row_height[k]);
4619dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, sub_vp_lines_l = %d\n", __func__, k, sub_vp_lines_l);
4620dda4fb85SAurabindo Pillai #endif
4621dda4fb85SAurabindo Pillai SubViewportLinesNeededInMALL[k] = sub_vp_lines_l;
4622dda4fb85SAurabindo Pillai
4623dda4fb85SAurabindo Pillai if (BytePerPixelDETC[k] > 0) {
46241df7e569SNathan Chancellor src_y_pstate_c = dml_ceil(dst_y_pstate * v->VRatioChroma[k], SwathHeightC[k]);
46250ee7cc80SRodrigo Siqueira src_y_ahead_c = dml_floor(DETBufferSizeC[k] / BytePerPixelDETC[k] / SwathWidthC[k], SwathHeightC[k]) + LBLatencyHidingSourceLinesC[k];
46261df7e569SNathan Chancellor sub_vp_lines_c = src_y_pstate_c + src_y_ahead_c + v->meta_row_height_chroma[k];
4627dda4fb85SAurabindo Pillai SubViewportLinesNeededInMALL[k] = dml_max(sub_vp_lines_l, sub_vp_lines_c);
4628dda4fb85SAurabindo Pillai
4629dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4630dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, src_y_pstate_c = %d\n", __func__, k, src_y_pstate_c);
4631dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, src_y_ahead_c = %d\n", __func__, k, src_y_ahead_c);
46321df7e569SNathan Chancellor dml_print("DML::%s: k=%d, v->meta_row_height_chroma = %d\n", __func__, k, v->meta_row_height_chroma[k]);
4633dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d, sub_vp_lines_c = %d\n", __func__, k, sub_vp_lines_c);
4634dda4fb85SAurabindo Pillai #endif
4635dda4fb85SAurabindo Pillai }
4636dda4fb85SAurabindo Pillai }
4637dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4638dda4fb85SAurabindo Pillai dml_print("DML::%s: DRAMClockChangeSupport = %d\n", __func__, *DRAMClockChangeSupport);
4639dda4fb85SAurabindo Pillai dml_print("DML::%s: FCLKChangeSupport = %d\n", __func__, *FCLKChangeSupport);
4640dda4fb85SAurabindo Pillai dml_print("DML::%s: MinActiveFCLKChangeLatencySupported = %f\n",
4641dda4fb85SAurabindo Pillai __func__, *MinActiveFCLKChangeLatencySupported);
4642dda4fb85SAurabindo Pillai dml_print("DML::%s: USRRetrainingSupport = %d\n", __func__, *USRRetrainingSupport);
4643dda4fb85SAurabindo Pillai #endif
4644dda4fb85SAurabindo Pillai } // CalculateWatermarksMALLUseAndDRAMSpeedChangeSupport
4645dda4fb85SAurabindo Pillai
dml32_CalculateWriteBackDISPCLK(enum source_format_class WritebackPixelFormat,double PixelClock,double WritebackHRatio,double WritebackVRatio,unsigned int WritebackHTaps,unsigned int WritebackVTaps,unsigned int WritebackSourceWidth,unsigned int WritebackDestinationWidth,unsigned int HTotal,unsigned int WritebackLineBufferSize,double DISPCLKDPPCLKVCOSpeed)4646dda4fb85SAurabindo Pillai double dml32_CalculateWriteBackDISPCLK(
4647dda4fb85SAurabindo Pillai enum source_format_class WritebackPixelFormat,
4648dda4fb85SAurabindo Pillai double PixelClock,
4649dda4fb85SAurabindo Pillai double WritebackHRatio,
4650dda4fb85SAurabindo Pillai double WritebackVRatio,
4651dda4fb85SAurabindo Pillai unsigned int WritebackHTaps,
4652dda4fb85SAurabindo Pillai unsigned int WritebackVTaps,
4653dda4fb85SAurabindo Pillai unsigned int WritebackSourceWidth,
4654dda4fb85SAurabindo Pillai unsigned int WritebackDestinationWidth,
4655dda4fb85SAurabindo Pillai unsigned int HTotal,
4656dda4fb85SAurabindo Pillai unsigned int WritebackLineBufferSize,
4657dda4fb85SAurabindo Pillai double DISPCLKDPPCLKVCOSpeed)
4658dda4fb85SAurabindo Pillai {
4659dda4fb85SAurabindo Pillai double DISPCLK_H, DISPCLK_V, DISPCLK_HB;
4660dda4fb85SAurabindo Pillai
4661dda4fb85SAurabindo Pillai DISPCLK_H = PixelClock * dml_ceil(WritebackHTaps / 8.0, 1) / WritebackHRatio;
4662dda4fb85SAurabindo Pillai DISPCLK_V = PixelClock * (WritebackVTaps * dml_ceil(WritebackDestinationWidth / 6.0, 1) + 8.0) / HTotal;
4663dda4fb85SAurabindo Pillai DISPCLK_HB = PixelClock * WritebackVTaps * (WritebackDestinationWidth *
4664dda4fb85SAurabindo Pillai WritebackVTaps - WritebackLineBufferSize / 57.0) / 6.0 / WritebackSourceWidth;
4665dda4fb85SAurabindo Pillai return dml32_RoundToDFSGranularity(dml_max3(DISPCLK_H, DISPCLK_V, DISPCLK_HB), 1, DISPCLKDPPCLKVCOSpeed);
4666dda4fb85SAurabindo Pillai }
4667dda4fb85SAurabindo Pillai
dml32_CalculateMinAndMaxPrefetchMode(enum dm_prefetch_modes AllowForPStateChangeOrStutterInVBlankFinal,unsigned int * MinPrefetchMode,unsigned int * MaxPrefetchMode)4668dda4fb85SAurabindo Pillai void dml32_CalculateMinAndMaxPrefetchMode(
4669dda4fb85SAurabindo Pillai enum dm_prefetch_modes AllowForPStateChangeOrStutterInVBlankFinal,
4670dda4fb85SAurabindo Pillai unsigned int *MinPrefetchMode,
4671dda4fb85SAurabindo Pillai unsigned int *MaxPrefetchMode)
4672dda4fb85SAurabindo Pillai {
4673dda4fb85SAurabindo Pillai if (AllowForPStateChangeOrStutterInVBlankFinal == dm_prefetch_support_none) {
4674dda4fb85SAurabindo Pillai *MinPrefetchMode = 3;
4675dda4fb85SAurabindo Pillai *MaxPrefetchMode = 3;
4676dda4fb85SAurabindo Pillai } else if (AllowForPStateChangeOrStutterInVBlankFinal == dm_prefetch_support_stutter) {
4677dda4fb85SAurabindo Pillai *MinPrefetchMode = 2;
4678dda4fb85SAurabindo Pillai *MaxPrefetchMode = 2;
4679dda4fb85SAurabindo Pillai } else if (AllowForPStateChangeOrStutterInVBlankFinal == dm_prefetch_support_fclk_and_stutter) {
4680dda4fb85SAurabindo Pillai *MinPrefetchMode = 1;
4681dda4fb85SAurabindo Pillai *MaxPrefetchMode = 1;
4682dda4fb85SAurabindo Pillai } else if (AllowForPStateChangeOrStutterInVBlankFinal == dm_prefetch_support_uclk_fclk_and_stutter) {
4683dda4fb85SAurabindo Pillai *MinPrefetchMode = 0;
4684dda4fb85SAurabindo Pillai *MaxPrefetchMode = 0;
4685974ce181SAurabindo Pillai } else if (AllowForPStateChangeOrStutterInVBlankFinal ==
4686974ce181SAurabindo Pillai dm_prefetch_support_uclk_fclk_and_stutter_if_possible) {
4687974ce181SAurabindo Pillai *MinPrefetchMode = 0;
4688974ce181SAurabindo Pillai *MaxPrefetchMode = 3;
4689dda4fb85SAurabindo Pillai } else {
4690dda4fb85SAurabindo Pillai *MinPrefetchMode = 0;
4691dda4fb85SAurabindo Pillai *MaxPrefetchMode = 3;
4692dda4fb85SAurabindo Pillai }
4693dda4fb85SAurabindo Pillai } // CalculateMinAndMaxPrefetchMode
4694dda4fb85SAurabindo Pillai
dml32_CalculatePixelDeliveryTimes(unsigned int NumberOfActiveSurfaces,double VRatio[],double VRatioChroma[],double VRatioPrefetchY[],double VRatioPrefetchC[],unsigned int swath_width_luma_ub[],unsigned int swath_width_chroma_ub[],unsigned int DPPPerSurface[],double HRatio[],double HRatioChroma[],double PixelClock[],double PSCL_THROUGHPUT[],double PSCL_THROUGHPUT_CHROMA[],double Dppclk[],unsigned int BytePerPixelC[],enum dm_rotation_angle SourceRotation[],unsigned int NumberOfCursors[],unsigned int CursorWidth[][DC__NUM_CURSOR__MAX],unsigned int CursorBPP[][DC__NUM_CURSOR__MAX],unsigned int BlockWidth256BytesY[],unsigned int BlockHeight256BytesY[],unsigned int BlockWidth256BytesC[],unsigned int BlockHeight256BytesC[],double DisplayPipeLineDeliveryTimeLuma[],double DisplayPipeLineDeliveryTimeChroma[],double DisplayPipeLineDeliveryTimeLumaPrefetch[],double DisplayPipeLineDeliveryTimeChromaPrefetch[],double DisplayPipeRequestDeliveryTimeLuma[],double DisplayPipeRequestDeliveryTimeChroma[],double DisplayPipeRequestDeliveryTimeLumaPrefetch[],double DisplayPipeRequestDeliveryTimeChromaPrefetch[],double CursorRequestDeliveryTime[],double CursorRequestDeliveryTimePrefetch[])4695dda4fb85SAurabindo Pillai void dml32_CalculatePixelDeliveryTimes(
4696dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces,
4697dda4fb85SAurabindo Pillai double VRatio[],
4698dda4fb85SAurabindo Pillai double VRatioChroma[],
4699dda4fb85SAurabindo Pillai double VRatioPrefetchY[],
4700dda4fb85SAurabindo Pillai double VRatioPrefetchC[],
4701dda4fb85SAurabindo Pillai unsigned int swath_width_luma_ub[],
4702dda4fb85SAurabindo Pillai unsigned int swath_width_chroma_ub[],
4703dda4fb85SAurabindo Pillai unsigned int DPPPerSurface[],
4704dda4fb85SAurabindo Pillai double HRatio[],
4705dda4fb85SAurabindo Pillai double HRatioChroma[],
4706dda4fb85SAurabindo Pillai double PixelClock[],
4707dda4fb85SAurabindo Pillai double PSCL_THROUGHPUT[],
4708dda4fb85SAurabindo Pillai double PSCL_THROUGHPUT_CHROMA[],
4709dda4fb85SAurabindo Pillai double Dppclk[],
4710dda4fb85SAurabindo Pillai unsigned int BytePerPixelC[],
4711dda4fb85SAurabindo Pillai enum dm_rotation_angle SourceRotation[],
4712dda4fb85SAurabindo Pillai unsigned int NumberOfCursors[],
4713dda4fb85SAurabindo Pillai unsigned int CursorWidth[][DC__NUM_CURSOR__MAX],
4714dda4fb85SAurabindo Pillai unsigned int CursorBPP[][DC__NUM_CURSOR__MAX],
4715dda4fb85SAurabindo Pillai unsigned int BlockWidth256BytesY[],
4716dda4fb85SAurabindo Pillai unsigned int BlockHeight256BytesY[],
4717dda4fb85SAurabindo Pillai unsigned int BlockWidth256BytesC[],
4718dda4fb85SAurabindo Pillai unsigned int BlockHeight256BytesC[],
4719dda4fb85SAurabindo Pillai
4720dda4fb85SAurabindo Pillai /* Output */
4721dda4fb85SAurabindo Pillai double DisplayPipeLineDeliveryTimeLuma[],
4722dda4fb85SAurabindo Pillai double DisplayPipeLineDeliveryTimeChroma[],
4723dda4fb85SAurabindo Pillai double DisplayPipeLineDeliveryTimeLumaPrefetch[],
4724dda4fb85SAurabindo Pillai double DisplayPipeLineDeliveryTimeChromaPrefetch[],
4725dda4fb85SAurabindo Pillai double DisplayPipeRequestDeliveryTimeLuma[],
4726dda4fb85SAurabindo Pillai double DisplayPipeRequestDeliveryTimeChroma[],
4727dda4fb85SAurabindo Pillai double DisplayPipeRequestDeliveryTimeLumaPrefetch[],
4728dda4fb85SAurabindo Pillai double DisplayPipeRequestDeliveryTimeChromaPrefetch[],
4729dda4fb85SAurabindo Pillai double CursorRequestDeliveryTime[],
4730dda4fb85SAurabindo Pillai double CursorRequestDeliveryTimePrefetch[])
4731dda4fb85SAurabindo Pillai {
4732dda4fb85SAurabindo Pillai double req_per_swath_ub;
4733dda4fb85SAurabindo Pillai unsigned int k;
4734dda4fb85SAurabindo Pillai
4735dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
4736dda4fb85SAurabindo Pillai
4737dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4738dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : HRatio = %f\n", __func__, k, HRatio[k]);
4739dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : VRatio = %f\n", __func__, k, VRatio[k]);
4740dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : HRatioChroma = %f\n", __func__, k, HRatioChroma[k]);
4741dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : VRatioChroma = %f\n", __func__, k, VRatioChroma[k]);
4742dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : swath_width_luma_ub = %d\n", __func__, k, swath_width_luma_ub[k]);
4743dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : swath_width_chroma_ub = %d\n", __func__, k, swath_width_chroma_ub[k]);
4744dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : PSCL_THROUGHPUT = %f\n", __func__, k, PSCL_THROUGHPUT[k]);
4745dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : PSCL_THROUGHPUT_CHROMA = %f\n", __func__, k, PSCL_THROUGHPUT_CHROMA[k]);
4746dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DPPPerSurface = %d\n", __func__, k, DPPPerSurface[k]);
4747dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : PixelClock = %f\n", __func__, k, PixelClock[k]);
4748dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : Dppclk = %f\n", __func__, k, Dppclk[k]);
4749dda4fb85SAurabindo Pillai #endif
4750dda4fb85SAurabindo Pillai
4751dda4fb85SAurabindo Pillai if (VRatio[k] <= 1) {
4752dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeLuma[k] =
4753dda4fb85SAurabindo Pillai swath_width_luma_ub[k] * DPPPerSurface[k] / HRatio[k] / PixelClock[k];
4754dda4fb85SAurabindo Pillai } else {
4755dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeLuma[k] = swath_width_luma_ub[k] / PSCL_THROUGHPUT[k] / Dppclk[k];
4756dda4fb85SAurabindo Pillai }
4757dda4fb85SAurabindo Pillai
4758dda4fb85SAurabindo Pillai if (BytePerPixelC[k] == 0) {
4759dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChroma[k] = 0;
4760dda4fb85SAurabindo Pillai } else {
4761dda4fb85SAurabindo Pillai if (VRatioChroma[k] <= 1) {
4762dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChroma[k] =
4763dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] * DPPPerSurface[k] / HRatioChroma[k] / PixelClock[k];
4764dda4fb85SAurabindo Pillai } else {
4765dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChroma[k] =
4766dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] / PSCL_THROUGHPUT_CHROMA[k] / Dppclk[k];
4767dda4fb85SAurabindo Pillai }
4768dda4fb85SAurabindo Pillai }
4769dda4fb85SAurabindo Pillai
4770dda4fb85SAurabindo Pillai if (VRatioPrefetchY[k] <= 1) {
4771dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeLumaPrefetch[k] =
4772dda4fb85SAurabindo Pillai swath_width_luma_ub[k] * DPPPerSurface[k] / HRatio[k] / PixelClock[k];
4773dda4fb85SAurabindo Pillai } else {
4774dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeLumaPrefetch[k] =
4775dda4fb85SAurabindo Pillai swath_width_luma_ub[k] / PSCL_THROUGHPUT[k] / Dppclk[k];
4776dda4fb85SAurabindo Pillai }
4777dda4fb85SAurabindo Pillai
4778dda4fb85SAurabindo Pillai if (BytePerPixelC[k] == 0) {
4779dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChromaPrefetch[k] = 0;
4780dda4fb85SAurabindo Pillai } else {
4781dda4fb85SAurabindo Pillai if (VRatioPrefetchC[k] <= 1) {
4782dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChromaPrefetch[k] = swath_width_chroma_ub[k] *
4783dda4fb85SAurabindo Pillai DPPPerSurface[k] / HRatioChroma[k] / PixelClock[k];
4784dda4fb85SAurabindo Pillai } else {
4785dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChromaPrefetch[k] =
4786dda4fb85SAurabindo Pillai swath_width_chroma_ub[k] / PSCL_THROUGHPUT_CHROMA[k] / Dppclk[k];
4787dda4fb85SAurabindo Pillai }
4788dda4fb85SAurabindo Pillai }
4789dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4790dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DisplayPipeLineDeliveryTimeLuma = %f\n",
4791dda4fb85SAurabindo Pillai __func__, k, DisplayPipeLineDeliveryTimeLuma[k]);
4792dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DisplayPipeLineDeliveryTimeLumaPrefetch = %f\n",
4793dda4fb85SAurabindo Pillai __func__, k, DisplayPipeLineDeliveryTimeLumaPrefetch[k]);
4794dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DisplayPipeLineDeliveryTimeChroma = %f\n",
4795dda4fb85SAurabindo Pillai __func__, k, DisplayPipeLineDeliveryTimeChroma[k]);
4796dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DisplayPipeLineDeliveryTimeChromaPrefetch = %f\n",
4797dda4fb85SAurabindo Pillai __func__, k, DisplayPipeLineDeliveryTimeChromaPrefetch[k]);
4798dda4fb85SAurabindo Pillai #endif
4799dda4fb85SAurabindo Pillai }
4800dda4fb85SAurabindo Pillai
4801dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
4802dda4fb85SAurabindo Pillai if (!IsVertical(SourceRotation[k]))
4803dda4fb85SAurabindo Pillai req_per_swath_ub = swath_width_luma_ub[k] / BlockWidth256BytesY[k];
4804dda4fb85SAurabindo Pillai else
4805dda4fb85SAurabindo Pillai req_per_swath_ub = swath_width_luma_ub[k] / BlockHeight256BytesY[k];
4806dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4807dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : req_per_swath_ub = %f (Luma)\n", __func__, k, req_per_swath_ub);
4808dda4fb85SAurabindo Pillai #endif
4809dda4fb85SAurabindo Pillai
4810dda4fb85SAurabindo Pillai DisplayPipeRequestDeliveryTimeLuma[k] = DisplayPipeLineDeliveryTimeLuma[k] / req_per_swath_ub;
4811dda4fb85SAurabindo Pillai DisplayPipeRequestDeliveryTimeLumaPrefetch[k] =
4812dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeLumaPrefetch[k] / req_per_swath_ub;
4813dda4fb85SAurabindo Pillai if (BytePerPixelC[k] == 0) {
4814dda4fb85SAurabindo Pillai DisplayPipeRequestDeliveryTimeChroma[k] = 0;
4815dda4fb85SAurabindo Pillai DisplayPipeRequestDeliveryTimeChromaPrefetch[k] = 0;
4816dda4fb85SAurabindo Pillai } else {
4817dda4fb85SAurabindo Pillai if (!IsVertical(SourceRotation[k]))
4818dda4fb85SAurabindo Pillai req_per_swath_ub = swath_width_chroma_ub[k] / BlockWidth256BytesC[k];
4819dda4fb85SAurabindo Pillai else
4820dda4fb85SAurabindo Pillai req_per_swath_ub = swath_width_chroma_ub[k] / BlockHeight256BytesC[k];
4821dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4822dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : req_per_swath_ub = %f (Chroma)\n", __func__, k, req_per_swath_ub);
4823dda4fb85SAurabindo Pillai #endif
4824dda4fb85SAurabindo Pillai DisplayPipeRequestDeliveryTimeChroma[k] =
4825dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChroma[k] / req_per_swath_ub;
4826dda4fb85SAurabindo Pillai DisplayPipeRequestDeliveryTimeChromaPrefetch[k] =
4827dda4fb85SAurabindo Pillai DisplayPipeLineDeliveryTimeChromaPrefetch[k] / req_per_swath_ub;
4828dda4fb85SAurabindo Pillai }
4829dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4830dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DisplayPipeRequestDeliveryTimeLuma = %f\n",
4831dda4fb85SAurabindo Pillai __func__, k, DisplayPipeRequestDeliveryTimeLuma[k]);
4832dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DisplayPipeRequestDeliveryTimeLumaPrefetch = %f\n",
4833dda4fb85SAurabindo Pillai __func__, k, DisplayPipeRequestDeliveryTimeLumaPrefetch[k]);
4834dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DisplayPipeRequestDeliveryTimeChroma = %f\n",
4835dda4fb85SAurabindo Pillai __func__, k, DisplayPipeRequestDeliveryTimeChroma[k]);
4836dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : DisplayPipeRequestDeliveryTimeChromaPrefetch = %f\n",
4837dda4fb85SAurabindo Pillai __func__, k, DisplayPipeRequestDeliveryTimeChromaPrefetch[k]);
4838dda4fb85SAurabindo Pillai #endif
4839dda4fb85SAurabindo Pillai }
4840dda4fb85SAurabindo Pillai
4841dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
4842dda4fb85SAurabindo Pillai unsigned int cursor_req_per_width;
4843dda4fb85SAurabindo Pillai
4844dda4fb85SAurabindo Pillai cursor_req_per_width = dml_ceil((double) CursorWidth[k][0] * (double) CursorBPP[k][0] /
4845dda4fb85SAurabindo Pillai 256.0 / 8.0, 1.0);
4846dda4fb85SAurabindo Pillai if (NumberOfCursors[k] > 0) {
4847dda4fb85SAurabindo Pillai if (VRatio[k] <= 1) {
4848dda4fb85SAurabindo Pillai CursorRequestDeliveryTime[k] = (double) CursorWidth[k][0] /
4849dda4fb85SAurabindo Pillai HRatio[k] / PixelClock[k] / cursor_req_per_width;
4850dda4fb85SAurabindo Pillai } else {
4851dda4fb85SAurabindo Pillai CursorRequestDeliveryTime[k] = (double) CursorWidth[k][0] /
4852dda4fb85SAurabindo Pillai PSCL_THROUGHPUT[k] / Dppclk[k] / cursor_req_per_width;
4853dda4fb85SAurabindo Pillai }
4854dda4fb85SAurabindo Pillai if (VRatioPrefetchY[k] <= 1) {
4855dda4fb85SAurabindo Pillai CursorRequestDeliveryTimePrefetch[k] = (double) CursorWidth[k][0] /
4856dda4fb85SAurabindo Pillai HRatio[k] / PixelClock[k] / cursor_req_per_width;
4857dda4fb85SAurabindo Pillai } else {
4858dda4fb85SAurabindo Pillai CursorRequestDeliveryTimePrefetch[k] = (double) CursorWidth[k][0] /
4859dda4fb85SAurabindo Pillai PSCL_THROUGHPUT[k] / Dppclk[k] / cursor_req_per_width;
4860dda4fb85SAurabindo Pillai }
4861dda4fb85SAurabindo Pillai } else {
4862dda4fb85SAurabindo Pillai CursorRequestDeliveryTime[k] = 0;
4863dda4fb85SAurabindo Pillai CursorRequestDeliveryTimePrefetch[k] = 0;
4864dda4fb85SAurabindo Pillai }
4865dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
4866dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : NumberOfCursors = %d\n",
4867dda4fb85SAurabindo Pillai __func__, k, NumberOfCursors[k]);
4868dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : CursorRequestDeliveryTime = %f\n",
4869dda4fb85SAurabindo Pillai __func__, k, CursorRequestDeliveryTime[k]);
4870dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%d : CursorRequestDeliveryTimePrefetch = %f\n",
4871dda4fb85SAurabindo Pillai __func__, k, CursorRequestDeliveryTimePrefetch[k]);
4872dda4fb85SAurabindo Pillai #endif
4873dda4fb85SAurabindo Pillai }
4874dda4fb85SAurabindo Pillai } // CalculatePixelDeliveryTimes
4875dda4fb85SAurabindo Pillai
dml32_CalculateMetaAndPTETimes(bool use_one_row_for_frame[],unsigned int NumberOfActiveSurfaces,bool GPUVMEnable,unsigned int MetaChunkSize,unsigned int MinMetaChunkSizeBytes,unsigned int HTotal[],double VRatio[],double VRatioChroma[],double DestinationLinesToRequestRowInVBlank[],double DestinationLinesToRequestRowInImmediateFlip[],bool DCCEnable[],double PixelClock[],unsigned int BytePerPixelY[],unsigned int BytePerPixelC[],enum dm_rotation_angle SourceRotation[],unsigned int dpte_row_height[],unsigned int dpte_row_height_chroma[],unsigned int meta_row_width[],unsigned int meta_row_width_chroma[],unsigned int meta_row_height[],unsigned int meta_row_height_chroma[],unsigned int meta_req_width[],unsigned int meta_req_width_chroma[],unsigned int meta_req_height[],unsigned int meta_req_height_chroma[],unsigned int dpte_group_bytes[],unsigned int PTERequestSizeY[],unsigned int PTERequestSizeC[],unsigned int PixelPTEReqWidthY[],unsigned int PixelPTEReqHeightY[],unsigned int PixelPTEReqWidthC[],unsigned int PixelPTEReqHeightC[],unsigned int dpte_row_width_luma_ub[],unsigned int dpte_row_width_chroma_ub[],double DST_Y_PER_PTE_ROW_NOM_L[],double DST_Y_PER_PTE_ROW_NOM_C[],double DST_Y_PER_META_ROW_NOM_L[],double DST_Y_PER_META_ROW_NOM_C[],double TimePerMetaChunkNominal[],double TimePerChromaMetaChunkNominal[],double TimePerMetaChunkVBlank[],double TimePerChromaMetaChunkVBlank[],double TimePerMetaChunkFlip[],double TimePerChromaMetaChunkFlip[],double time_per_pte_group_nom_luma[],double time_per_pte_group_vblank_luma[],double time_per_pte_group_flip_luma[],double time_per_pte_group_nom_chroma[],double time_per_pte_group_vblank_chroma[],double time_per_pte_group_flip_chroma[])4876dda4fb85SAurabindo Pillai void dml32_CalculateMetaAndPTETimes(
4877dda4fb85SAurabindo Pillai bool use_one_row_for_frame[],
4878dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces,
4879dda4fb85SAurabindo Pillai bool GPUVMEnable,
4880dda4fb85SAurabindo Pillai unsigned int MetaChunkSize,
4881dda4fb85SAurabindo Pillai unsigned int MinMetaChunkSizeBytes,
4882dda4fb85SAurabindo Pillai unsigned int HTotal[],
4883dda4fb85SAurabindo Pillai double VRatio[],
4884dda4fb85SAurabindo Pillai double VRatioChroma[],
4885dda4fb85SAurabindo Pillai double DestinationLinesToRequestRowInVBlank[],
4886dda4fb85SAurabindo Pillai double DestinationLinesToRequestRowInImmediateFlip[],
4887dda4fb85SAurabindo Pillai bool DCCEnable[],
4888dda4fb85SAurabindo Pillai double PixelClock[],
4889dda4fb85SAurabindo Pillai unsigned int BytePerPixelY[],
4890dda4fb85SAurabindo Pillai unsigned int BytePerPixelC[],
4891dda4fb85SAurabindo Pillai enum dm_rotation_angle SourceRotation[],
4892dda4fb85SAurabindo Pillai unsigned int dpte_row_height[],
4893dda4fb85SAurabindo Pillai unsigned int dpte_row_height_chroma[],
4894dda4fb85SAurabindo Pillai unsigned int meta_row_width[],
4895dda4fb85SAurabindo Pillai unsigned int meta_row_width_chroma[],
4896dda4fb85SAurabindo Pillai unsigned int meta_row_height[],
4897dda4fb85SAurabindo Pillai unsigned int meta_row_height_chroma[],
4898dda4fb85SAurabindo Pillai unsigned int meta_req_width[],
4899dda4fb85SAurabindo Pillai unsigned int meta_req_width_chroma[],
4900dda4fb85SAurabindo Pillai unsigned int meta_req_height[],
4901dda4fb85SAurabindo Pillai unsigned int meta_req_height_chroma[],
4902dda4fb85SAurabindo Pillai unsigned int dpte_group_bytes[],
4903dda4fb85SAurabindo Pillai unsigned int PTERequestSizeY[],
4904dda4fb85SAurabindo Pillai unsigned int PTERequestSizeC[],
4905dda4fb85SAurabindo Pillai unsigned int PixelPTEReqWidthY[],
4906dda4fb85SAurabindo Pillai unsigned int PixelPTEReqHeightY[],
4907dda4fb85SAurabindo Pillai unsigned int PixelPTEReqWidthC[],
4908dda4fb85SAurabindo Pillai unsigned int PixelPTEReqHeightC[],
4909dda4fb85SAurabindo Pillai unsigned int dpte_row_width_luma_ub[],
4910dda4fb85SAurabindo Pillai unsigned int dpte_row_width_chroma_ub[],
4911dda4fb85SAurabindo Pillai
4912dda4fb85SAurabindo Pillai /* Output */
4913dda4fb85SAurabindo Pillai double DST_Y_PER_PTE_ROW_NOM_L[],
4914dda4fb85SAurabindo Pillai double DST_Y_PER_PTE_ROW_NOM_C[],
4915dda4fb85SAurabindo Pillai double DST_Y_PER_META_ROW_NOM_L[],
4916dda4fb85SAurabindo Pillai double DST_Y_PER_META_ROW_NOM_C[],
4917dda4fb85SAurabindo Pillai double TimePerMetaChunkNominal[],
4918dda4fb85SAurabindo Pillai double TimePerChromaMetaChunkNominal[],
4919dda4fb85SAurabindo Pillai double TimePerMetaChunkVBlank[],
4920dda4fb85SAurabindo Pillai double TimePerChromaMetaChunkVBlank[],
4921dda4fb85SAurabindo Pillai double TimePerMetaChunkFlip[],
4922dda4fb85SAurabindo Pillai double TimePerChromaMetaChunkFlip[],
4923dda4fb85SAurabindo Pillai double time_per_pte_group_nom_luma[],
4924dda4fb85SAurabindo Pillai double time_per_pte_group_vblank_luma[],
4925dda4fb85SAurabindo Pillai double time_per_pte_group_flip_luma[],
4926dda4fb85SAurabindo Pillai double time_per_pte_group_nom_chroma[],
4927dda4fb85SAurabindo Pillai double time_per_pte_group_vblank_chroma[],
4928dda4fb85SAurabindo Pillai double time_per_pte_group_flip_chroma[])
4929dda4fb85SAurabindo Pillai {
4930dda4fb85SAurabindo Pillai unsigned int meta_chunk_width;
4931dda4fb85SAurabindo Pillai unsigned int min_meta_chunk_width;
4932dda4fb85SAurabindo Pillai unsigned int meta_chunk_per_row_int;
4933dda4fb85SAurabindo Pillai unsigned int meta_row_remainder;
4934dda4fb85SAurabindo Pillai unsigned int meta_chunk_threshold;
4935dda4fb85SAurabindo Pillai unsigned int meta_chunks_per_row_ub;
4936dda4fb85SAurabindo Pillai unsigned int meta_chunk_width_chroma;
4937dda4fb85SAurabindo Pillai unsigned int min_meta_chunk_width_chroma;
4938dda4fb85SAurabindo Pillai unsigned int meta_chunk_per_row_int_chroma;
4939dda4fb85SAurabindo Pillai unsigned int meta_row_remainder_chroma;
4940dda4fb85SAurabindo Pillai unsigned int meta_chunk_threshold_chroma;
4941dda4fb85SAurabindo Pillai unsigned int meta_chunks_per_row_ub_chroma;
4942dda4fb85SAurabindo Pillai unsigned int dpte_group_width_luma;
4943dda4fb85SAurabindo Pillai unsigned int dpte_groups_per_row_luma_ub;
4944dda4fb85SAurabindo Pillai unsigned int dpte_group_width_chroma;
4945dda4fb85SAurabindo Pillai unsigned int dpte_groups_per_row_chroma_ub;
4946dda4fb85SAurabindo Pillai unsigned int k;
4947dda4fb85SAurabindo Pillai
4948dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
4949dda4fb85SAurabindo Pillai DST_Y_PER_PTE_ROW_NOM_L[k] = dpte_row_height[k] / VRatio[k];
4950dda4fb85SAurabindo Pillai if (BytePerPixelC[k] == 0)
4951dda4fb85SAurabindo Pillai DST_Y_PER_PTE_ROW_NOM_C[k] = 0;
4952dda4fb85SAurabindo Pillai else
4953dda4fb85SAurabindo Pillai DST_Y_PER_PTE_ROW_NOM_C[k] = dpte_row_height_chroma[k] / VRatioChroma[k];
4954dda4fb85SAurabindo Pillai DST_Y_PER_META_ROW_NOM_L[k] = meta_row_height[k] / VRatio[k];
4955dda4fb85SAurabindo Pillai if (BytePerPixelC[k] == 0)
4956dda4fb85SAurabindo Pillai DST_Y_PER_META_ROW_NOM_C[k] = 0;
4957dda4fb85SAurabindo Pillai else
4958dda4fb85SAurabindo Pillai DST_Y_PER_META_ROW_NOM_C[k] = meta_row_height_chroma[k] / VRatioChroma[k];
4959dda4fb85SAurabindo Pillai }
4960dda4fb85SAurabindo Pillai
4961dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
4962dda4fb85SAurabindo Pillai if (DCCEnable[k] == true) {
4963dda4fb85SAurabindo Pillai meta_chunk_width = MetaChunkSize * 1024 * 256 / BytePerPixelY[k] / meta_row_height[k];
4964dda4fb85SAurabindo Pillai min_meta_chunk_width = MinMetaChunkSizeBytes * 256 / BytePerPixelY[k] / meta_row_height[k];
4965dda4fb85SAurabindo Pillai meta_chunk_per_row_int = meta_row_width[k] / meta_chunk_width;
4966dda4fb85SAurabindo Pillai meta_row_remainder = meta_row_width[k] % meta_chunk_width;
4967dda4fb85SAurabindo Pillai if (!IsVertical(SourceRotation[k]))
4968dda4fb85SAurabindo Pillai meta_chunk_threshold = 2 * min_meta_chunk_width - meta_req_width[k];
4969dda4fb85SAurabindo Pillai else
4970dda4fb85SAurabindo Pillai meta_chunk_threshold = 2 * min_meta_chunk_width - meta_req_height[k];
4971dda4fb85SAurabindo Pillai
4972dda4fb85SAurabindo Pillai if (meta_row_remainder <= meta_chunk_threshold)
4973dda4fb85SAurabindo Pillai meta_chunks_per_row_ub = meta_chunk_per_row_int + 1;
4974dda4fb85SAurabindo Pillai else
4975dda4fb85SAurabindo Pillai meta_chunks_per_row_ub = meta_chunk_per_row_int + 2;
4976dda4fb85SAurabindo Pillai
4977dda4fb85SAurabindo Pillai TimePerMetaChunkNominal[k] = meta_row_height[k] / VRatio[k] *
4978dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub;
4979dda4fb85SAurabindo Pillai TimePerMetaChunkVBlank[k] = DestinationLinesToRequestRowInVBlank[k] *
4980dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub;
4981dda4fb85SAurabindo Pillai TimePerMetaChunkFlip[k] = DestinationLinesToRequestRowInImmediateFlip[k] *
4982dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub;
4983dda4fb85SAurabindo Pillai if (BytePerPixelC[k] == 0) {
4984dda4fb85SAurabindo Pillai TimePerChromaMetaChunkNominal[k] = 0;
4985dda4fb85SAurabindo Pillai TimePerChromaMetaChunkVBlank[k] = 0;
4986dda4fb85SAurabindo Pillai TimePerChromaMetaChunkFlip[k] = 0;
4987dda4fb85SAurabindo Pillai } else {
4988dda4fb85SAurabindo Pillai meta_chunk_width_chroma = MetaChunkSize * 1024 * 256 / BytePerPixelC[k] /
4989dda4fb85SAurabindo Pillai meta_row_height_chroma[k];
4990dda4fb85SAurabindo Pillai min_meta_chunk_width_chroma = MinMetaChunkSizeBytes * 256 / BytePerPixelC[k] /
4991dda4fb85SAurabindo Pillai meta_row_height_chroma[k];
4992dda4fb85SAurabindo Pillai meta_chunk_per_row_int_chroma = (double) meta_row_width_chroma[k] /
4993dda4fb85SAurabindo Pillai meta_chunk_width_chroma;
4994dda4fb85SAurabindo Pillai meta_row_remainder_chroma = meta_row_width_chroma[k] % meta_chunk_width_chroma;
4995dda4fb85SAurabindo Pillai if (!IsVertical(SourceRotation[k])) {
4996dda4fb85SAurabindo Pillai meta_chunk_threshold_chroma = 2 * min_meta_chunk_width_chroma -
4997dda4fb85SAurabindo Pillai meta_req_width_chroma[k];
4998dda4fb85SAurabindo Pillai } else {
4999dda4fb85SAurabindo Pillai meta_chunk_threshold_chroma = 2 * min_meta_chunk_width_chroma -
5000dda4fb85SAurabindo Pillai meta_req_height_chroma[k];
5001dda4fb85SAurabindo Pillai }
5002dda4fb85SAurabindo Pillai if (meta_row_remainder_chroma <= meta_chunk_threshold_chroma)
5003dda4fb85SAurabindo Pillai meta_chunks_per_row_ub_chroma = meta_chunk_per_row_int_chroma + 1;
5004dda4fb85SAurabindo Pillai else
5005dda4fb85SAurabindo Pillai meta_chunks_per_row_ub_chroma = meta_chunk_per_row_int_chroma + 2;
5006dda4fb85SAurabindo Pillai
5007dda4fb85SAurabindo Pillai TimePerChromaMetaChunkNominal[k] = meta_row_height_chroma[k] / VRatioChroma[k] *
5008dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma;
5009dda4fb85SAurabindo Pillai TimePerChromaMetaChunkVBlank[k] = DestinationLinesToRequestRowInVBlank[k] *
5010dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma;
5011dda4fb85SAurabindo Pillai TimePerChromaMetaChunkFlip[k] = DestinationLinesToRequestRowInImmediateFlip[k] *
5012dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / meta_chunks_per_row_ub_chroma;
5013dda4fb85SAurabindo Pillai }
5014dda4fb85SAurabindo Pillai } else {
5015dda4fb85SAurabindo Pillai TimePerMetaChunkNominal[k] = 0;
5016dda4fb85SAurabindo Pillai TimePerMetaChunkVBlank[k] = 0;
5017dda4fb85SAurabindo Pillai TimePerMetaChunkFlip[k] = 0;
5018dda4fb85SAurabindo Pillai TimePerChromaMetaChunkNominal[k] = 0;
5019dda4fb85SAurabindo Pillai TimePerChromaMetaChunkVBlank[k] = 0;
5020dda4fb85SAurabindo Pillai TimePerChromaMetaChunkFlip[k] = 0;
5021dda4fb85SAurabindo Pillai }
5022dda4fb85SAurabindo Pillai }
5023dda4fb85SAurabindo Pillai
5024dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
5025dda4fb85SAurabindo Pillai if (GPUVMEnable == true) {
5026dda4fb85SAurabindo Pillai if (!IsVertical(SourceRotation[k])) {
5027dda4fb85SAurabindo Pillai dpte_group_width_luma = (double) dpte_group_bytes[k] /
5028dda4fb85SAurabindo Pillai (double) PTERequestSizeY[k] * PixelPTEReqWidthY[k];
5029dda4fb85SAurabindo Pillai } else {
5030dda4fb85SAurabindo Pillai dpte_group_width_luma = (double) dpte_group_bytes[k] /
5031dda4fb85SAurabindo Pillai (double) PTERequestSizeY[k] * PixelPTEReqHeightY[k];
5032dda4fb85SAurabindo Pillai }
5033dda4fb85SAurabindo Pillai
5034dda4fb85SAurabindo Pillai if (use_one_row_for_frame[k]) {
5035dda4fb85SAurabindo Pillai dpte_groups_per_row_luma_ub = dml_ceil((double) dpte_row_width_luma_ub[k] /
5036dda4fb85SAurabindo Pillai (double) dpte_group_width_luma / 2.0, 1.0);
5037dda4fb85SAurabindo Pillai } else {
5038dda4fb85SAurabindo Pillai dpte_groups_per_row_luma_ub = dml_ceil((double) dpte_row_width_luma_ub[k] /
5039dda4fb85SAurabindo Pillai (double) dpte_group_width_luma, 1.0);
5040dda4fb85SAurabindo Pillai }
5041dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5042dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, use_one_row_for_frame = %d\n",
5043dda4fb85SAurabindo Pillai __func__, k, use_one_row_for_frame[k]);
5044dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpte_group_bytes = %d\n",
5045dda4fb85SAurabindo Pillai __func__, k, dpte_group_bytes[k]);
5046dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, PTERequestSizeY = %d\n",
5047dda4fb85SAurabindo Pillai __func__, k, PTERequestSizeY[k]);
5048dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, PixelPTEReqWidthY = %d\n",
5049dda4fb85SAurabindo Pillai __func__, k, PixelPTEReqWidthY[k]);
5050dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, PixelPTEReqHeightY = %d\n",
5051dda4fb85SAurabindo Pillai __func__, k, PixelPTEReqHeightY[k]);
5052dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpte_row_width_luma_ub = %d\n",
5053dda4fb85SAurabindo Pillai __func__, k, dpte_row_width_luma_ub[k]);
5054dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpte_group_width_luma = %d\n",
5055dda4fb85SAurabindo Pillai __func__, k, dpte_group_width_luma);
5056dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpte_groups_per_row_luma_ub = %d\n",
5057dda4fb85SAurabindo Pillai __func__, k, dpte_groups_per_row_luma_ub);
5058dda4fb85SAurabindo Pillai #endif
5059dda4fb85SAurabindo Pillai
5060dda4fb85SAurabindo Pillai time_per_pte_group_nom_luma[k] = DST_Y_PER_PTE_ROW_NOM_L[k] *
5061dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / dpte_groups_per_row_luma_ub;
5062dda4fb85SAurabindo Pillai time_per_pte_group_vblank_luma[k] = DestinationLinesToRequestRowInVBlank[k] *
5063dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / dpte_groups_per_row_luma_ub;
5064dda4fb85SAurabindo Pillai time_per_pte_group_flip_luma[k] = DestinationLinesToRequestRowInImmediateFlip[k] *
5065dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / dpte_groups_per_row_luma_ub;
5066dda4fb85SAurabindo Pillai if (BytePerPixelC[k] == 0) {
5067dda4fb85SAurabindo Pillai time_per_pte_group_nom_chroma[k] = 0;
5068dda4fb85SAurabindo Pillai time_per_pte_group_vblank_chroma[k] = 0;
5069dda4fb85SAurabindo Pillai time_per_pte_group_flip_chroma[k] = 0;
5070dda4fb85SAurabindo Pillai } else {
5071dda4fb85SAurabindo Pillai if (!IsVertical(SourceRotation[k])) {
5072dda4fb85SAurabindo Pillai dpte_group_width_chroma = (double) dpte_group_bytes[k] /
5073dda4fb85SAurabindo Pillai (double) PTERequestSizeC[k] * PixelPTEReqWidthC[k];
5074dda4fb85SAurabindo Pillai } else {
5075dda4fb85SAurabindo Pillai dpte_group_width_chroma = (double) dpte_group_bytes[k] /
5076dda4fb85SAurabindo Pillai (double) PTERequestSizeC[k] * PixelPTEReqHeightC[k];
5077dda4fb85SAurabindo Pillai }
5078dda4fb85SAurabindo Pillai
5079dda4fb85SAurabindo Pillai if (use_one_row_for_frame[k]) {
5080dda4fb85SAurabindo Pillai dpte_groups_per_row_chroma_ub = dml_ceil((double) dpte_row_width_chroma_ub[k] /
5081dda4fb85SAurabindo Pillai (double) dpte_group_width_chroma / 2.0, 1.0);
5082dda4fb85SAurabindo Pillai } else {
5083dda4fb85SAurabindo Pillai dpte_groups_per_row_chroma_ub = dml_ceil((double) dpte_row_width_chroma_ub[k] /
5084dda4fb85SAurabindo Pillai (double) dpte_group_width_chroma, 1.0);
5085dda4fb85SAurabindo Pillai }
5086dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5087dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpte_row_width_chroma_ub = %d\n",
5088dda4fb85SAurabindo Pillai __func__, k, dpte_row_width_chroma_ub[k]);
5089dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpte_group_width_chroma = %d\n",
5090dda4fb85SAurabindo Pillai __func__, k, dpte_group_width_chroma);
5091dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpte_groups_per_row_chroma_ub = %d\n",
5092dda4fb85SAurabindo Pillai __func__, k, dpte_groups_per_row_chroma_ub);
5093dda4fb85SAurabindo Pillai #endif
5094dda4fb85SAurabindo Pillai time_per_pte_group_nom_chroma[k] = DST_Y_PER_PTE_ROW_NOM_C[k] *
5095dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / dpte_groups_per_row_chroma_ub;
5096dda4fb85SAurabindo Pillai time_per_pte_group_vblank_chroma[k] = DestinationLinesToRequestRowInVBlank[k] *
5097dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / dpte_groups_per_row_chroma_ub;
5098dda4fb85SAurabindo Pillai time_per_pte_group_flip_chroma[k] = DestinationLinesToRequestRowInImmediateFlip[k] *
5099dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / dpte_groups_per_row_chroma_ub;
5100dda4fb85SAurabindo Pillai }
5101dda4fb85SAurabindo Pillai } else {
5102dda4fb85SAurabindo Pillai time_per_pte_group_nom_luma[k] = 0;
5103dda4fb85SAurabindo Pillai time_per_pte_group_vblank_luma[k] = 0;
5104dda4fb85SAurabindo Pillai time_per_pte_group_flip_luma[k] = 0;
5105dda4fb85SAurabindo Pillai time_per_pte_group_nom_chroma[k] = 0;
5106dda4fb85SAurabindo Pillai time_per_pte_group_vblank_chroma[k] = 0;
5107dda4fb85SAurabindo Pillai time_per_pte_group_flip_chroma[k] = 0;
5108dda4fb85SAurabindo Pillai }
5109dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5110dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DestinationLinesToRequestRowInVBlank = %f\n",
5111dda4fb85SAurabindo Pillai __func__, k, DestinationLinesToRequestRowInVBlank[k]);
5112dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DestinationLinesToRequestRowInImmediateFlip = %f\n",
5113dda4fb85SAurabindo Pillai __func__, k, DestinationLinesToRequestRowInImmediateFlip[k]);
5114dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DST_Y_PER_PTE_ROW_NOM_L = %f\n",
5115dda4fb85SAurabindo Pillai __func__, k, DST_Y_PER_PTE_ROW_NOM_L[k]);
5116dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DST_Y_PER_PTE_ROW_NOM_C = %f\n",
5117dda4fb85SAurabindo Pillai __func__, k, DST_Y_PER_PTE_ROW_NOM_C[k]);
5118dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DST_Y_PER_META_ROW_NOM_L = %f\n",
5119dda4fb85SAurabindo Pillai __func__, k, DST_Y_PER_META_ROW_NOM_L[k]);
5120dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DST_Y_PER_META_ROW_NOM_C = %f\n",
5121dda4fb85SAurabindo Pillai __func__, k, DST_Y_PER_META_ROW_NOM_C[k]);
5122dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerMetaChunkNominal = %f\n",
5123dda4fb85SAurabindo Pillai __func__, k, TimePerMetaChunkNominal[k]);
5124dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerMetaChunkVBlank = %f\n",
5125dda4fb85SAurabindo Pillai __func__, k, TimePerMetaChunkVBlank[k]);
5126dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerMetaChunkFlip = %f\n",
5127dda4fb85SAurabindo Pillai __func__, k, TimePerMetaChunkFlip[k]);
5128dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerChromaMetaChunkNominal = %f\n",
5129dda4fb85SAurabindo Pillai __func__, k, TimePerChromaMetaChunkNominal[k]);
5130dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerChromaMetaChunkVBlank = %f\n",
5131dda4fb85SAurabindo Pillai __func__, k, TimePerChromaMetaChunkVBlank[k]);
5132dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerChromaMetaChunkFlip = %f\n",
5133dda4fb85SAurabindo Pillai __func__, k, TimePerChromaMetaChunkFlip[k]);
5134dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, time_per_pte_group_nom_luma = %f\n",
5135dda4fb85SAurabindo Pillai __func__, k, time_per_pte_group_nom_luma[k]);
5136dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, time_per_pte_group_vblank_luma = %f\n",
5137dda4fb85SAurabindo Pillai __func__, k, time_per_pte_group_vblank_luma[k]);
5138dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, time_per_pte_group_flip_luma = %f\n",
5139dda4fb85SAurabindo Pillai __func__, k, time_per_pte_group_flip_luma[k]);
5140dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, time_per_pte_group_nom_chroma = %f\n",
5141dda4fb85SAurabindo Pillai __func__, k, time_per_pte_group_nom_chroma[k]);
5142dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, time_per_pte_group_vblank_chroma = %f\n",
5143dda4fb85SAurabindo Pillai __func__, k, time_per_pte_group_vblank_chroma[k]);
5144dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, time_per_pte_group_flip_chroma = %f\n",
5145dda4fb85SAurabindo Pillai __func__, k, time_per_pte_group_flip_chroma[k]);
5146dda4fb85SAurabindo Pillai #endif
5147dda4fb85SAurabindo Pillai }
5148dda4fb85SAurabindo Pillai } // CalculateMetaAndPTETimes
5149dda4fb85SAurabindo Pillai
dml32_CalculateVMGroupAndRequestTimes(unsigned int NumberOfActiveSurfaces,bool GPUVMEnable,unsigned int GPUVMMaxPageTableLevels,unsigned int HTotal[],unsigned int BytePerPixelC[],double DestinationLinesToRequestVMInVBlank[],double DestinationLinesToRequestVMInImmediateFlip[],bool DCCEnable[],double PixelClock[],unsigned int dpte_row_width_luma_ub[],unsigned int dpte_row_width_chroma_ub[],unsigned int vm_group_bytes[],unsigned int dpde0_bytes_per_frame_ub_l[],unsigned int dpde0_bytes_per_frame_ub_c[],unsigned int meta_pte_bytes_per_frame_ub_l[],unsigned int meta_pte_bytes_per_frame_ub_c[],double TimePerVMGroupVBlank[],double TimePerVMGroupFlip[],double TimePerVMRequestVBlank[],double TimePerVMRequestFlip[])5150dda4fb85SAurabindo Pillai void dml32_CalculateVMGroupAndRequestTimes(
5151dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces,
5152dda4fb85SAurabindo Pillai bool GPUVMEnable,
5153dda4fb85SAurabindo Pillai unsigned int GPUVMMaxPageTableLevels,
5154dda4fb85SAurabindo Pillai unsigned int HTotal[],
5155dda4fb85SAurabindo Pillai unsigned int BytePerPixelC[],
5156dda4fb85SAurabindo Pillai double DestinationLinesToRequestVMInVBlank[],
5157dda4fb85SAurabindo Pillai double DestinationLinesToRequestVMInImmediateFlip[],
5158dda4fb85SAurabindo Pillai bool DCCEnable[],
5159dda4fb85SAurabindo Pillai double PixelClock[],
5160dda4fb85SAurabindo Pillai unsigned int dpte_row_width_luma_ub[],
5161dda4fb85SAurabindo Pillai unsigned int dpte_row_width_chroma_ub[],
5162dda4fb85SAurabindo Pillai unsigned int vm_group_bytes[],
5163dda4fb85SAurabindo Pillai unsigned int dpde0_bytes_per_frame_ub_l[],
5164dda4fb85SAurabindo Pillai unsigned int dpde0_bytes_per_frame_ub_c[],
5165dda4fb85SAurabindo Pillai unsigned int meta_pte_bytes_per_frame_ub_l[],
5166dda4fb85SAurabindo Pillai unsigned int meta_pte_bytes_per_frame_ub_c[],
5167dda4fb85SAurabindo Pillai
5168dda4fb85SAurabindo Pillai /* Output */
5169dda4fb85SAurabindo Pillai double TimePerVMGroupVBlank[],
5170dda4fb85SAurabindo Pillai double TimePerVMGroupFlip[],
5171dda4fb85SAurabindo Pillai double TimePerVMRequestVBlank[],
5172dda4fb85SAurabindo Pillai double TimePerVMRequestFlip[])
5173dda4fb85SAurabindo Pillai {
5174dda4fb85SAurabindo Pillai unsigned int k;
5175dda4fb85SAurabindo Pillai unsigned int num_group_per_lower_vm_stage;
5176dda4fb85SAurabindo Pillai unsigned int num_req_per_lower_vm_stage;
5177dda4fb85SAurabindo Pillai
5178dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5179dda4fb85SAurabindo Pillai dml_print("DML::%s: NumberOfActiveSurfaces = %d\n", __func__, NumberOfActiveSurfaces);
5180dda4fb85SAurabindo Pillai dml_print("DML::%s: GPUVMEnable = %d\n", __func__, GPUVMEnable);
5181dda4fb85SAurabindo Pillai #endif
5182dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
5183dda4fb85SAurabindo Pillai
5184dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5185dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DCCEnable = %d\n", __func__, k, DCCEnable[k]);
5186dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, vm_group_bytes = %d\n", __func__, k, vm_group_bytes[k]);
5187dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpde0_bytes_per_frame_ub_l = %d\n",
5188dda4fb85SAurabindo Pillai __func__, k, dpde0_bytes_per_frame_ub_l[k]);
5189dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, dpde0_bytes_per_frame_ub_c = %d\n",
5190dda4fb85SAurabindo Pillai __func__, k, dpde0_bytes_per_frame_ub_c[k]);
5191dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, meta_pte_bytes_per_frame_ub_l = %d\n",
5192dda4fb85SAurabindo Pillai __func__, k, meta_pte_bytes_per_frame_ub_l[k]);
5193dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, meta_pte_bytes_per_frame_ub_c = %d\n",
5194dda4fb85SAurabindo Pillai __func__, k, meta_pte_bytes_per_frame_ub_c[k]);
5195dda4fb85SAurabindo Pillai #endif
5196dda4fb85SAurabindo Pillai
5197dda4fb85SAurabindo Pillai if (GPUVMEnable == true && (DCCEnable[k] == true || GPUVMMaxPageTableLevels > 1)) {
5198dda4fb85SAurabindo Pillai if (DCCEnable[k] == false) {
5199dda4fb85SAurabindo Pillai if (BytePerPixelC[k] > 0) {
5200dda4fb85SAurabindo Pillai num_group_per_lower_vm_stage = dml_ceil(
5201dda4fb85SAurabindo Pillai (double) (dpde0_bytes_per_frame_ub_l[k]) /
5202dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1.0) +
5203dda4fb85SAurabindo Pillai dml_ceil((double) (dpde0_bytes_per_frame_ub_c[k]) /
5204dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1.0);
5205dda4fb85SAurabindo Pillai } else {
5206dda4fb85SAurabindo Pillai num_group_per_lower_vm_stage = dml_ceil(
5207dda4fb85SAurabindo Pillai (double) (dpde0_bytes_per_frame_ub_l[k]) /
5208dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1.0);
5209dda4fb85SAurabindo Pillai }
5210dda4fb85SAurabindo Pillai } else {
5211dda4fb85SAurabindo Pillai if (GPUVMMaxPageTableLevels == 1) {
5212dda4fb85SAurabindo Pillai if (BytePerPixelC[k] > 0) {
5213dda4fb85SAurabindo Pillai num_group_per_lower_vm_stage = dml_ceil(
5214dda4fb85SAurabindo Pillai (double) (meta_pte_bytes_per_frame_ub_l[k]) /
5215dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1.0) +
5216dda4fb85SAurabindo Pillai dml_ceil((double) (meta_pte_bytes_per_frame_ub_c[k]) /
5217dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1.0);
5218dda4fb85SAurabindo Pillai } else {
5219dda4fb85SAurabindo Pillai num_group_per_lower_vm_stage = dml_ceil(
5220dda4fb85SAurabindo Pillai (double) (meta_pte_bytes_per_frame_ub_l[k]) /
5221dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1.0);
5222dda4fb85SAurabindo Pillai }
5223dda4fb85SAurabindo Pillai } else {
5224dda4fb85SAurabindo Pillai if (BytePerPixelC[k] > 0) {
5225dda4fb85SAurabindo Pillai num_group_per_lower_vm_stage = 2 + dml_ceil(
5226dda4fb85SAurabindo Pillai (double) (dpde0_bytes_per_frame_ub_l[k]) /
5227dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1) +
5228dda4fb85SAurabindo Pillai dml_ceil((double) (dpde0_bytes_per_frame_ub_c[k]) /
5229dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1) +
5230dda4fb85SAurabindo Pillai dml_ceil((double) (meta_pte_bytes_per_frame_ub_l[k]) /
5231dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1) +
5232dda4fb85SAurabindo Pillai dml_ceil((double) (meta_pte_bytes_per_frame_ub_c[k]) /
5233dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1);
5234dda4fb85SAurabindo Pillai } else {
5235dda4fb85SAurabindo Pillai num_group_per_lower_vm_stage = 1 + dml_ceil(
5236dda4fb85SAurabindo Pillai (double) (dpde0_bytes_per_frame_ub_l[k]) /
5237dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1) + dml_ceil(
5238dda4fb85SAurabindo Pillai (double) (meta_pte_bytes_per_frame_ub_l[k]) /
5239dda4fb85SAurabindo Pillai (double) (vm_group_bytes[k]), 1);
5240dda4fb85SAurabindo Pillai }
5241dda4fb85SAurabindo Pillai }
5242dda4fb85SAurabindo Pillai }
5243dda4fb85SAurabindo Pillai
5244dda4fb85SAurabindo Pillai if (DCCEnable[k] == false) {
5245dda4fb85SAurabindo Pillai if (BytePerPixelC[k] > 0) {
5246dda4fb85SAurabindo Pillai num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64 +
5247dda4fb85SAurabindo Pillai dpde0_bytes_per_frame_ub_c[k] / 64;
5248dda4fb85SAurabindo Pillai } else {
5249dda4fb85SAurabindo Pillai num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] / 64;
5250dda4fb85SAurabindo Pillai }
5251dda4fb85SAurabindo Pillai } else {
5252dda4fb85SAurabindo Pillai if (GPUVMMaxPageTableLevels == 1) {
5253dda4fb85SAurabindo Pillai if (BytePerPixelC[k] > 0) {
5254dda4fb85SAurabindo Pillai num_req_per_lower_vm_stage = meta_pte_bytes_per_frame_ub_l[k] / 64 +
5255dda4fb85SAurabindo Pillai meta_pte_bytes_per_frame_ub_c[k] / 64;
5256dda4fb85SAurabindo Pillai } else {
5257dda4fb85SAurabindo Pillai num_req_per_lower_vm_stage = meta_pte_bytes_per_frame_ub_l[k] / 64;
5258dda4fb85SAurabindo Pillai }
5259dda4fb85SAurabindo Pillai } else {
5260dda4fb85SAurabindo Pillai if (BytePerPixelC[k] > 0) {
5261dda4fb85SAurabindo Pillai num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] /
5262dda4fb85SAurabindo Pillai 64 + dpde0_bytes_per_frame_ub_c[k] / 64 +
5263dda4fb85SAurabindo Pillai meta_pte_bytes_per_frame_ub_l[k] / 64 +
5264dda4fb85SAurabindo Pillai meta_pte_bytes_per_frame_ub_c[k] / 64;
5265dda4fb85SAurabindo Pillai } else {
5266dda4fb85SAurabindo Pillai num_req_per_lower_vm_stage = dpde0_bytes_per_frame_ub_l[k] /
5267dda4fb85SAurabindo Pillai 64 + meta_pte_bytes_per_frame_ub_l[k] / 64;
5268dda4fb85SAurabindo Pillai }
5269dda4fb85SAurabindo Pillai }
5270dda4fb85SAurabindo Pillai }
5271dda4fb85SAurabindo Pillai
5272dda4fb85SAurabindo Pillai TimePerVMGroupVBlank[k] = DestinationLinesToRequestVMInVBlank[k] *
5273dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / num_group_per_lower_vm_stage;
5274dda4fb85SAurabindo Pillai TimePerVMGroupFlip[k] = DestinationLinesToRequestVMInImmediateFlip[k] *
5275dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / num_group_per_lower_vm_stage;
5276dda4fb85SAurabindo Pillai TimePerVMRequestVBlank[k] = DestinationLinesToRequestVMInVBlank[k] *
5277dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / num_req_per_lower_vm_stage;
5278dda4fb85SAurabindo Pillai TimePerVMRequestFlip[k] = DestinationLinesToRequestVMInImmediateFlip[k] *
5279dda4fb85SAurabindo Pillai HTotal[k] / PixelClock[k] / num_req_per_lower_vm_stage;
5280dda4fb85SAurabindo Pillai
5281dda4fb85SAurabindo Pillai if (GPUVMMaxPageTableLevels > 2) {
5282dda4fb85SAurabindo Pillai TimePerVMGroupVBlank[k] = TimePerVMGroupVBlank[k] / 2;
5283dda4fb85SAurabindo Pillai TimePerVMGroupFlip[k] = TimePerVMGroupFlip[k] / 2;
5284dda4fb85SAurabindo Pillai TimePerVMRequestVBlank[k] = TimePerVMRequestVBlank[k] / 2;
5285dda4fb85SAurabindo Pillai TimePerVMRequestFlip[k] = TimePerVMRequestFlip[k] / 2;
5286dda4fb85SAurabindo Pillai }
5287dda4fb85SAurabindo Pillai
5288dda4fb85SAurabindo Pillai } else {
5289dda4fb85SAurabindo Pillai TimePerVMGroupVBlank[k] = 0;
5290dda4fb85SAurabindo Pillai TimePerVMGroupFlip[k] = 0;
5291dda4fb85SAurabindo Pillai TimePerVMRequestVBlank[k] = 0;
5292dda4fb85SAurabindo Pillai TimePerVMRequestFlip[k] = 0;
5293dda4fb85SAurabindo Pillai }
5294dda4fb85SAurabindo Pillai
5295dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5296dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerVMGroupVBlank = %f\n", __func__, k, TimePerVMGroupVBlank[k]);
5297dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerVMGroupFlip = %f\n", __func__, k, TimePerVMGroupFlip[k]);
5298dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerVMRequestVBlank = %f\n", __func__, k, TimePerVMRequestVBlank[k]);
5299dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TimePerVMRequestFlip = %f\n", __func__, k, TimePerVMRequestFlip[k]);
5300dda4fb85SAurabindo Pillai #endif
5301dda4fb85SAurabindo Pillai }
5302dda4fb85SAurabindo Pillai } // CalculateVMGroupAndRequestTimes
5303dda4fb85SAurabindo Pillai
dml32_CalculateDCCConfiguration(bool DCCEnabled,bool DCCProgrammingAssumesScanDirectionUnknown,enum source_format_class SourcePixelFormat,unsigned int SurfaceWidthLuma,unsigned int SurfaceWidthChroma,unsigned int SurfaceHeightLuma,unsigned int SurfaceHeightChroma,unsigned int nomDETInKByte,unsigned int RequestHeight256ByteLuma,unsigned int RequestHeight256ByteChroma,enum dm_swizzle_mode TilingFormat,unsigned int BytePerPixelY,unsigned int BytePerPixelC,double BytePerPixelDETY,double BytePerPixelDETC,enum dm_rotation_angle SourceRotation,unsigned int * MaxUncompressedBlockLuma,unsigned int * MaxUncompressedBlockChroma,unsigned int * MaxCompressedBlockLuma,unsigned int * MaxCompressedBlockChroma,unsigned int * IndependentBlockLuma,unsigned int * IndependentBlockChroma)5304dda4fb85SAurabindo Pillai void dml32_CalculateDCCConfiguration(
5305dda4fb85SAurabindo Pillai bool DCCEnabled,
5306dda4fb85SAurabindo Pillai bool DCCProgrammingAssumesScanDirectionUnknown,
5307dda4fb85SAurabindo Pillai enum source_format_class SourcePixelFormat,
5308dda4fb85SAurabindo Pillai unsigned int SurfaceWidthLuma,
5309dda4fb85SAurabindo Pillai unsigned int SurfaceWidthChroma,
5310dda4fb85SAurabindo Pillai unsigned int SurfaceHeightLuma,
5311dda4fb85SAurabindo Pillai unsigned int SurfaceHeightChroma,
5312dda4fb85SAurabindo Pillai unsigned int nomDETInKByte,
5313dda4fb85SAurabindo Pillai unsigned int RequestHeight256ByteLuma,
5314dda4fb85SAurabindo Pillai unsigned int RequestHeight256ByteChroma,
5315dda4fb85SAurabindo Pillai enum dm_swizzle_mode TilingFormat,
5316dda4fb85SAurabindo Pillai unsigned int BytePerPixelY,
5317dda4fb85SAurabindo Pillai unsigned int BytePerPixelC,
5318dda4fb85SAurabindo Pillai double BytePerPixelDETY,
5319dda4fb85SAurabindo Pillai double BytePerPixelDETC,
5320dda4fb85SAurabindo Pillai enum dm_rotation_angle SourceRotation,
5321dda4fb85SAurabindo Pillai /* Output */
5322dda4fb85SAurabindo Pillai unsigned int *MaxUncompressedBlockLuma,
5323dda4fb85SAurabindo Pillai unsigned int *MaxUncompressedBlockChroma,
5324dda4fb85SAurabindo Pillai unsigned int *MaxCompressedBlockLuma,
5325dda4fb85SAurabindo Pillai unsigned int *MaxCompressedBlockChroma,
5326dda4fb85SAurabindo Pillai unsigned int *IndependentBlockLuma,
5327dda4fb85SAurabindo Pillai unsigned int *IndependentBlockChroma)
5328dda4fb85SAurabindo Pillai {
5329ce19bbe4SChandan Vurdigere Nataraj typedef enum {
5330ce19bbe4SChandan Vurdigere Nataraj REQ_256Bytes,
5331ce19bbe4SChandan Vurdigere Nataraj REQ_128BytesNonContiguous,
5332ce19bbe4SChandan Vurdigere Nataraj REQ_128BytesContiguous,
5333ce19bbe4SChandan Vurdigere Nataraj REQ_NA
5334ce19bbe4SChandan Vurdigere Nataraj } RequestType;
5335dda4fb85SAurabindo Pillai
5336ce19bbe4SChandan Vurdigere Nataraj RequestType RequestLuma;
5337ce19bbe4SChandan Vurdigere Nataraj RequestType RequestChroma;
5338dda4fb85SAurabindo Pillai
5339dda4fb85SAurabindo Pillai unsigned int segment_order_horz_contiguous_luma;
5340dda4fb85SAurabindo Pillai unsigned int segment_order_horz_contiguous_chroma;
5341dda4fb85SAurabindo Pillai unsigned int segment_order_vert_contiguous_luma;
5342dda4fb85SAurabindo Pillai unsigned int segment_order_vert_contiguous_chroma;
5343dda4fb85SAurabindo Pillai unsigned int req128_horz_wc_l;
5344dda4fb85SAurabindo Pillai unsigned int req128_horz_wc_c;
5345dda4fb85SAurabindo Pillai unsigned int req128_vert_wc_l;
5346dda4fb85SAurabindo Pillai unsigned int req128_vert_wc_c;
5347dda4fb85SAurabindo Pillai unsigned int MAS_vp_horz_limit;
5348dda4fb85SAurabindo Pillai unsigned int MAS_vp_vert_limit;
5349dda4fb85SAurabindo Pillai unsigned int max_vp_horz_width;
5350dda4fb85SAurabindo Pillai unsigned int max_vp_vert_height;
5351dda4fb85SAurabindo Pillai unsigned int eff_surf_width_l;
5352dda4fb85SAurabindo Pillai unsigned int eff_surf_width_c;
5353dda4fb85SAurabindo Pillai unsigned int eff_surf_height_l;
5354dda4fb85SAurabindo Pillai unsigned int eff_surf_height_c;
5355dda4fb85SAurabindo Pillai unsigned int full_swath_bytes_horz_wc_l;
5356dda4fb85SAurabindo Pillai unsigned int full_swath_bytes_horz_wc_c;
5357dda4fb85SAurabindo Pillai unsigned int full_swath_bytes_vert_wc_l;
5358dda4fb85SAurabindo Pillai unsigned int full_swath_bytes_vert_wc_c;
5359dda4fb85SAurabindo Pillai unsigned int DETBufferSizeForDCC = nomDETInKByte * 1024;
5360dda4fb85SAurabindo Pillai
5361dda4fb85SAurabindo Pillai unsigned int yuv420;
5362dda4fb85SAurabindo Pillai unsigned int horz_div_l;
5363dda4fb85SAurabindo Pillai unsigned int horz_div_c;
5364dda4fb85SAurabindo Pillai unsigned int vert_div_l;
5365dda4fb85SAurabindo Pillai unsigned int vert_div_c;
5366dda4fb85SAurabindo Pillai
5367dda4fb85SAurabindo Pillai unsigned int swath_buf_size;
5368dda4fb85SAurabindo Pillai double detile_buf_vp_horz_limit;
5369dda4fb85SAurabindo Pillai double detile_buf_vp_vert_limit;
5370dda4fb85SAurabindo Pillai
5371dda4fb85SAurabindo Pillai yuv420 = ((SourcePixelFormat == dm_420_8 || SourcePixelFormat == dm_420_10 ||
5372dda4fb85SAurabindo Pillai SourcePixelFormat == dm_420_12) ? 1 : 0);
5373dda4fb85SAurabindo Pillai horz_div_l = 1;
5374dda4fb85SAurabindo Pillai horz_div_c = 1;
5375dda4fb85SAurabindo Pillai vert_div_l = 1;
5376dda4fb85SAurabindo Pillai vert_div_c = 1;
5377dda4fb85SAurabindo Pillai
5378dda4fb85SAurabindo Pillai if (BytePerPixelY == 1)
5379dda4fb85SAurabindo Pillai vert_div_l = 0;
5380dda4fb85SAurabindo Pillai if (BytePerPixelC == 1)
5381dda4fb85SAurabindo Pillai vert_div_c = 0;
5382dda4fb85SAurabindo Pillai
5383dda4fb85SAurabindo Pillai if (BytePerPixelC == 0) {
5384dda4fb85SAurabindo Pillai swath_buf_size = DETBufferSizeForDCC / 2 - 2 * 256;
5385dda4fb85SAurabindo Pillai detile_buf_vp_horz_limit = (double) swath_buf_size / ((double) RequestHeight256ByteLuma *
5386dda4fb85SAurabindo Pillai BytePerPixelY / (1 + horz_div_l));
5387dda4fb85SAurabindo Pillai detile_buf_vp_vert_limit = (double) swath_buf_size / (256.0 / RequestHeight256ByteLuma /
5388dda4fb85SAurabindo Pillai (1 + vert_div_l));
5389dda4fb85SAurabindo Pillai } else {
5390dda4fb85SAurabindo Pillai swath_buf_size = DETBufferSizeForDCC / 2 - 2 * 2 * 256;
5391dda4fb85SAurabindo Pillai detile_buf_vp_horz_limit = (double) swath_buf_size / ((double) RequestHeight256ByteLuma *
5392dda4fb85SAurabindo Pillai BytePerPixelY / (1 + horz_div_l) + (double) RequestHeight256ByteChroma *
5393dda4fb85SAurabindo Pillai BytePerPixelC / (1 + horz_div_c) / (1 + yuv420));
5394dda4fb85SAurabindo Pillai detile_buf_vp_vert_limit = (double) swath_buf_size / (256.0 / RequestHeight256ByteLuma /
5395dda4fb85SAurabindo Pillai (1 + vert_div_l) + 256.0 / RequestHeight256ByteChroma /
5396dda4fb85SAurabindo Pillai (1 + vert_div_c) / (1 + yuv420));
5397dda4fb85SAurabindo Pillai }
5398dda4fb85SAurabindo Pillai
5399dda4fb85SAurabindo Pillai if (SourcePixelFormat == dm_420_10) {
5400dda4fb85SAurabindo Pillai detile_buf_vp_horz_limit = 1.5 * detile_buf_vp_horz_limit;
5401dda4fb85SAurabindo Pillai detile_buf_vp_vert_limit = 1.5 * detile_buf_vp_vert_limit;
5402dda4fb85SAurabindo Pillai }
5403dda4fb85SAurabindo Pillai
5404dda4fb85SAurabindo Pillai detile_buf_vp_horz_limit = dml_floor(detile_buf_vp_horz_limit - 1, 16);
5405dda4fb85SAurabindo Pillai detile_buf_vp_vert_limit = dml_floor(detile_buf_vp_vert_limit - 1, 16);
5406dda4fb85SAurabindo Pillai
5407dda4fb85SAurabindo Pillai MAS_vp_horz_limit = SourcePixelFormat == dm_rgbe_alpha ? 3840 : 6144;
5408dda4fb85SAurabindo Pillai MAS_vp_vert_limit = SourcePixelFormat == dm_rgbe_alpha ? 3840 : (BytePerPixelY == 8 ? 3072 : 6144);
5409dda4fb85SAurabindo Pillai max_vp_horz_width = dml_min((double) MAS_vp_horz_limit, detile_buf_vp_horz_limit);
5410dda4fb85SAurabindo Pillai max_vp_vert_height = dml_min((double) MAS_vp_vert_limit, detile_buf_vp_vert_limit);
5411dda4fb85SAurabindo Pillai eff_surf_width_l = (SurfaceWidthLuma > max_vp_horz_width ? max_vp_horz_width : SurfaceWidthLuma);
5412dda4fb85SAurabindo Pillai eff_surf_width_c = eff_surf_width_l / (1 + yuv420);
5413dda4fb85SAurabindo Pillai eff_surf_height_l = (SurfaceHeightLuma > max_vp_vert_height ? max_vp_vert_height : SurfaceHeightLuma);
5414dda4fb85SAurabindo Pillai eff_surf_height_c = eff_surf_height_l / (1 + yuv420);
5415dda4fb85SAurabindo Pillai
5416dda4fb85SAurabindo Pillai full_swath_bytes_horz_wc_l = eff_surf_width_l * RequestHeight256ByteLuma * BytePerPixelY;
5417dda4fb85SAurabindo Pillai full_swath_bytes_vert_wc_l = eff_surf_height_l * 256 / RequestHeight256ByteLuma;
5418dda4fb85SAurabindo Pillai if (BytePerPixelC > 0) {
5419dda4fb85SAurabindo Pillai full_swath_bytes_horz_wc_c = eff_surf_width_c * RequestHeight256ByteChroma * BytePerPixelC;
5420dda4fb85SAurabindo Pillai full_swath_bytes_vert_wc_c = eff_surf_height_c * 256 / RequestHeight256ByteChroma;
5421dda4fb85SAurabindo Pillai } else {
5422dda4fb85SAurabindo Pillai full_swath_bytes_horz_wc_c = 0;
5423dda4fb85SAurabindo Pillai full_swath_bytes_vert_wc_c = 0;
5424dda4fb85SAurabindo Pillai }
5425dda4fb85SAurabindo Pillai
5426dda4fb85SAurabindo Pillai if (SourcePixelFormat == dm_420_10) {
5427dda4fb85SAurabindo Pillai full_swath_bytes_horz_wc_l = dml_ceil((double) full_swath_bytes_horz_wc_l * 2.0 / 3.0, 256.0);
5428dda4fb85SAurabindo Pillai full_swath_bytes_horz_wc_c = dml_ceil((double) full_swath_bytes_horz_wc_c * 2.0 / 3.0, 256.0);
5429dda4fb85SAurabindo Pillai full_swath_bytes_vert_wc_l = dml_ceil((double) full_swath_bytes_vert_wc_l * 2.0 / 3.0, 256.0);
5430dda4fb85SAurabindo Pillai full_swath_bytes_vert_wc_c = dml_ceil((double) full_swath_bytes_vert_wc_c * 2.0 / 3.0, 256.0);
5431dda4fb85SAurabindo Pillai }
5432dda4fb85SAurabindo Pillai
5433dda4fb85SAurabindo Pillai if (2 * full_swath_bytes_horz_wc_l + 2 * full_swath_bytes_horz_wc_c <= DETBufferSizeForDCC) {
5434dda4fb85SAurabindo Pillai req128_horz_wc_l = 0;
5435dda4fb85SAurabindo Pillai req128_horz_wc_c = 0;
5436dda4fb85SAurabindo Pillai } else if (full_swath_bytes_horz_wc_l < 1.5 * full_swath_bytes_horz_wc_c && 2 * full_swath_bytes_horz_wc_l +
5437dda4fb85SAurabindo Pillai full_swath_bytes_horz_wc_c <= DETBufferSizeForDCC) {
5438dda4fb85SAurabindo Pillai req128_horz_wc_l = 0;
5439dda4fb85SAurabindo Pillai req128_horz_wc_c = 1;
5440dda4fb85SAurabindo Pillai } else if (full_swath_bytes_horz_wc_l >= 1.5 * full_swath_bytes_horz_wc_c && full_swath_bytes_horz_wc_l + 2 *
5441dda4fb85SAurabindo Pillai full_swath_bytes_horz_wc_c <= DETBufferSizeForDCC) {
5442dda4fb85SAurabindo Pillai req128_horz_wc_l = 1;
5443dda4fb85SAurabindo Pillai req128_horz_wc_c = 0;
5444dda4fb85SAurabindo Pillai } else {
5445dda4fb85SAurabindo Pillai req128_horz_wc_l = 1;
5446dda4fb85SAurabindo Pillai req128_horz_wc_c = 1;
5447dda4fb85SAurabindo Pillai }
5448dda4fb85SAurabindo Pillai
5449dda4fb85SAurabindo Pillai if (2 * full_swath_bytes_vert_wc_l + 2 * full_swath_bytes_vert_wc_c <= DETBufferSizeForDCC) {
5450dda4fb85SAurabindo Pillai req128_vert_wc_l = 0;
5451dda4fb85SAurabindo Pillai req128_vert_wc_c = 0;
5452dda4fb85SAurabindo Pillai } else if (full_swath_bytes_vert_wc_l < 1.5 * full_swath_bytes_vert_wc_c && 2 *
5453dda4fb85SAurabindo Pillai full_swath_bytes_vert_wc_l + full_swath_bytes_vert_wc_c <= DETBufferSizeForDCC) {
5454dda4fb85SAurabindo Pillai req128_vert_wc_l = 0;
5455dda4fb85SAurabindo Pillai req128_vert_wc_c = 1;
5456dda4fb85SAurabindo Pillai } else if (full_swath_bytes_vert_wc_l >= 1.5 * full_swath_bytes_vert_wc_c &&
5457dda4fb85SAurabindo Pillai full_swath_bytes_vert_wc_l + 2 * full_swath_bytes_vert_wc_c <= DETBufferSizeForDCC) {
5458dda4fb85SAurabindo Pillai req128_vert_wc_l = 1;
5459dda4fb85SAurabindo Pillai req128_vert_wc_c = 0;
5460dda4fb85SAurabindo Pillai } else {
5461dda4fb85SAurabindo Pillai req128_vert_wc_l = 1;
5462dda4fb85SAurabindo Pillai req128_vert_wc_c = 1;
5463dda4fb85SAurabindo Pillai }
5464dda4fb85SAurabindo Pillai
5465dda4fb85SAurabindo Pillai if (BytePerPixelY == 2) {
5466dda4fb85SAurabindo Pillai segment_order_horz_contiguous_luma = 0;
5467dda4fb85SAurabindo Pillai segment_order_vert_contiguous_luma = 1;
5468dda4fb85SAurabindo Pillai } else {
5469dda4fb85SAurabindo Pillai segment_order_horz_contiguous_luma = 1;
5470dda4fb85SAurabindo Pillai segment_order_vert_contiguous_luma = 0;
5471dda4fb85SAurabindo Pillai }
5472dda4fb85SAurabindo Pillai
5473dda4fb85SAurabindo Pillai if (BytePerPixelC == 2) {
5474dda4fb85SAurabindo Pillai segment_order_horz_contiguous_chroma = 0;
5475dda4fb85SAurabindo Pillai segment_order_vert_contiguous_chroma = 1;
5476dda4fb85SAurabindo Pillai } else {
5477dda4fb85SAurabindo Pillai segment_order_horz_contiguous_chroma = 1;
5478dda4fb85SAurabindo Pillai segment_order_vert_contiguous_chroma = 0;
5479dda4fb85SAurabindo Pillai }
5480dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5481dda4fb85SAurabindo Pillai dml_print("DML::%s: DCCEnabled = %d\n", __func__, DCCEnabled);
5482dda4fb85SAurabindo Pillai dml_print("DML::%s: nomDETInKByte = %d\n", __func__, nomDETInKByte);
5483dda4fb85SAurabindo Pillai dml_print("DML::%s: DETBufferSizeForDCC = %d\n", __func__, DETBufferSizeForDCC);
5484dda4fb85SAurabindo Pillai dml_print("DML::%s: req128_horz_wc_l = %d\n", __func__, req128_horz_wc_l);
5485dda4fb85SAurabindo Pillai dml_print("DML::%s: req128_horz_wc_c = %d\n", __func__, req128_horz_wc_c);
5486dda4fb85SAurabindo Pillai dml_print("DML::%s: full_swath_bytes_horz_wc_l = %d\n", __func__, full_swath_bytes_horz_wc_l);
5487dda4fb85SAurabindo Pillai dml_print("DML::%s: full_swath_bytes_vert_wc_c = %d\n", __func__, full_swath_bytes_vert_wc_c);
5488dda4fb85SAurabindo Pillai dml_print("DML::%s: segment_order_horz_contiguous_luma = %d\n", __func__, segment_order_horz_contiguous_luma);
5489dda4fb85SAurabindo Pillai dml_print("DML::%s: segment_order_horz_contiguous_chroma = %d\n",
5490dda4fb85SAurabindo Pillai __func__, segment_order_horz_contiguous_chroma);
5491dda4fb85SAurabindo Pillai #endif
5492dda4fb85SAurabindo Pillai
5493dda4fb85SAurabindo Pillai if (DCCProgrammingAssumesScanDirectionUnknown == true) {
5494dda4fb85SAurabindo Pillai if (req128_horz_wc_l == 0 && req128_vert_wc_l == 0)
5495dda4fb85SAurabindo Pillai RequestLuma = REQ_256Bytes;
5496dda4fb85SAurabindo Pillai else if ((req128_horz_wc_l == 1 && segment_order_horz_contiguous_luma == 0) ||
5497dda4fb85SAurabindo Pillai (req128_vert_wc_l == 1 && segment_order_vert_contiguous_luma == 0))
5498dda4fb85SAurabindo Pillai RequestLuma = REQ_128BytesNonContiguous;
5499dda4fb85SAurabindo Pillai else
5500dda4fb85SAurabindo Pillai RequestLuma = REQ_128BytesContiguous;
5501dda4fb85SAurabindo Pillai
5502dda4fb85SAurabindo Pillai if (req128_horz_wc_c == 0 && req128_vert_wc_c == 0)
5503dda4fb85SAurabindo Pillai RequestChroma = REQ_256Bytes;
5504dda4fb85SAurabindo Pillai else if ((req128_horz_wc_c == 1 && segment_order_horz_contiguous_chroma == 0) ||
5505dda4fb85SAurabindo Pillai (req128_vert_wc_c == 1 && segment_order_vert_contiguous_chroma == 0))
5506dda4fb85SAurabindo Pillai RequestChroma = REQ_128BytesNonContiguous;
5507dda4fb85SAurabindo Pillai else
5508dda4fb85SAurabindo Pillai RequestChroma = REQ_128BytesContiguous;
5509dda4fb85SAurabindo Pillai
5510dda4fb85SAurabindo Pillai } else if (!IsVertical(SourceRotation)) {
5511dda4fb85SAurabindo Pillai if (req128_horz_wc_l == 0)
5512dda4fb85SAurabindo Pillai RequestLuma = REQ_256Bytes;
5513dda4fb85SAurabindo Pillai else if (segment_order_horz_contiguous_luma == 0)
5514dda4fb85SAurabindo Pillai RequestLuma = REQ_128BytesNonContiguous;
5515dda4fb85SAurabindo Pillai else
5516dda4fb85SAurabindo Pillai RequestLuma = REQ_128BytesContiguous;
5517dda4fb85SAurabindo Pillai
5518dda4fb85SAurabindo Pillai if (req128_horz_wc_c == 0)
5519dda4fb85SAurabindo Pillai RequestChroma = REQ_256Bytes;
5520dda4fb85SAurabindo Pillai else if (segment_order_horz_contiguous_chroma == 0)
5521dda4fb85SAurabindo Pillai RequestChroma = REQ_128BytesNonContiguous;
5522dda4fb85SAurabindo Pillai else
5523dda4fb85SAurabindo Pillai RequestChroma = REQ_128BytesContiguous;
5524dda4fb85SAurabindo Pillai
5525dda4fb85SAurabindo Pillai } else {
5526dda4fb85SAurabindo Pillai if (req128_vert_wc_l == 0)
5527dda4fb85SAurabindo Pillai RequestLuma = REQ_256Bytes;
5528dda4fb85SAurabindo Pillai else if (segment_order_vert_contiguous_luma == 0)
5529dda4fb85SAurabindo Pillai RequestLuma = REQ_128BytesNonContiguous;
5530dda4fb85SAurabindo Pillai else
5531dda4fb85SAurabindo Pillai RequestLuma = REQ_128BytesContiguous;
5532dda4fb85SAurabindo Pillai
5533dda4fb85SAurabindo Pillai if (req128_vert_wc_c == 0)
5534dda4fb85SAurabindo Pillai RequestChroma = REQ_256Bytes;
5535dda4fb85SAurabindo Pillai else if (segment_order_vert_contiguous_chroma == 0)
5536dda4fb85SAurabindo Pillai RequestChroma = REQ_128BytesNonContiguous;
5537dda4fb85SAurabindo Pillai else
5538dda4fb85SAurabindo Pillai RequestChroma = REQ_128BytesContiguous;
5539dda4fb85SAurabindo Pillai }
5540dda4fb85SAurabindo Pillai
5541ce19bbe4SChandan Vurdigere Nataraj if (RequestLuma == REQ_256Bytes) {
5542dda4fb85SAurabindo Pillai *MaxUncompressedBlockLuma = 256;
5543dda4fb85SAurabindo Pillai *MaxCompressedBlockLuma = 256;
5544dda4fb85SAurabindo Pillai *IndependentBlockLuma = 0;
5545ce19bbe4SChandan Vurdigere Nataraj } else if (RequestLuma == REQ_128BytesContiguous) {
5546dda4fb85SAurabindo Pillai *MaxUncompressedBlockLuma = 256;
5547dda4fb85SAurabindo Pillai *MaxCompressedBlockLuma = 128;
5548dda4fb85SAurabindo Pillai *IndependentBlockLuma = 128;
5549dda4fb85SAurabindo Pillai } else {
5550dda4fb85SAurabindo Pillai *MaxUncompressedBlockLuma = 256;
5551dda4fb85SAurabindo Pillai *MaxCompressedBlockLuma = 64;
5552dda4fb85SAurabindo Pillai *IndependentBlockLuma = 64;
5553dda4fb85SAurabindo Pillai }
5554dda4fb85SAurabindo Pillai
5555ce19bbe4SChandan Vurdigere Nataraj if (RequestChroma == REQ_256Bytes) {
5556dda4fb85SAurabindo Pillai *MaxUncompressedBlockChroma = 256;
5557dda4fb85SAurabindo Pillai *MaxCompressedBlockChroma = 256;
5558dda4fb85SAurabindo Pillai *IndependentBlockChroma = 0;
5559ce19bbe4SChandan Vurdigere Nataraj } else if (RequestChroma == REQ_128BytesContiguous) {
5560dda4fb85SAurabindo Pillai *MaxUncompressedBlockChroma = 256;
5561dda4fb85SAurabindo Pillai *MaxCompressedBlockChroma = 128;
5562dda4fb85SAurabindo Pillai *IndependentBlockChroma = 128;
5563dda4fb85SAurabindo Pillai } else {
5564dda4fb85SAurabindo Pillai *MaxUncompressedBlockChroma = 256;
5565dda4fb85SAurabindo Pillai *MaxCompressedBlockChroma = 64;
5566dda4fb85SAurabindo Pillai *IndependentBlockChroma = 64;
5567dda4fb85SAurabindo Pillai }
5568dda4fb85SAurabindo Pillai
5569dda4fb85SAurabindo Pillai if (DCCEnabled != true || BytePerPixelC == 0) {
5570dda4fb85SAurabindo Pillai *MaxUncompressedBlockChroma = 0;
5571dda4fb85SAurabindo Pillai *MaxCompressedBlockChroma = 0;
5572dda4fb85SAurabindo Pillai *IndependentBlockChroma = 0;
5573dda4fb85SAurabindo Pillai }
5574dda4fb85SAurabindo Pillai
5575dda4fb85SAurabindo Pillai if (DCCEnabled != true) {
5576dda4fb85SAurabindo Pillai *MaxUncompressedBlockLuma = 0;
5577dda4fb85SAurabindo Pillai *MaxCompressedBlockLuma = 0;
5578dda4fb85SAurabindo Pillai *IndependentBlockLuma = 0;
5579dda4fb85SAurabindo Pillai }
5580dda4fb85SAurabindo Pillai
5581dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5582dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxUncompressedBlockLuma = %d\n", __func__, *MaxUncompressedBlockLuma);
5583dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxCompressedBlockLuma = %d\n", __func__, *MaxCompressedBlockLuma);
5584dda4fb85SAurabindo Pillai dml_print("DML::%s: IndependentBlockLuma = %d\n", __func__, *IndependentBlockLuma);
5585dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxUncompressedBlockChroma = %d\n", __func__, *MaxUncompressedBlockChroma);
5586dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxCompressedBlockChroma = %d\n", __func__, *MaxCompressedBlockChroma);
5587dda4fb85SAurabindo Pillai dml_print("DML::%s: IndependentBlockChroma = %d\n", __func__, *IndependentBlockChroma);
5588dda4fb85SAurabindo Pillai #endif
5589dda4fb85SAurabindo Pillai
5590dda4fb85SAurabindo Pillai } // CalculateDCCConfiguration
5591dda4fb85SAurabindo Pillai
dml32_CalculateStutterEfficiency(unsigned int CompressedBufferSizeInkByte,enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange[],bool UnboundedRequestEnabled,unsigned int MetaFIFOSizeInKEntries,unsigned int ZeroSizeBufferEntries,unsigned int PixelChunkSizeInKByte,unsigned int NumberOfActiveSurfaces,unsigned int ROBBufferSizeInKByte,double TotalDataReadBandwidth,double DCFCLK,double ReturnBW,unsigned int CompbufReservedSpace64B,unsigned int CompbufReservedSpaceZs,double SRExitTime,double SRExitZ8Time,bool SynchronizeTimingsFinal,unsigned int BlendingAndTiming[],double StutterEnterPlusExitWatermark,double Z8StutterEnterPlusExitWatermark,bool ProgressiveToInterlaceUnitInOPP,bool Interlace[],double MinTTUVBlank[],unsigned int DPPPerSurface[],unsigned int DETBufferSizeY[],unsigned int BytePerPixelY[],double BytePerPixelDETY[],double SwathWidthY[],unsigned int SwathHeightY[],unsigned int SwathHeightC[],double NetDCCRateLuma[],double NetDCCRateChroma[],double DCCFractionOfZeroSizeRequestsLuma[],double DCCFractionOfZeroSizeRequestsChroma[],unsigned int HTotal[],unsigned int VTotal[],double PixelClock[],double VRatio[],enum dm_rotation_angle SourceRotation[],unsigned int BlockHeight256BytesY[],unsigned int BlockWidth256BytesY[],unsigned int BlockHeight256BytesC[],unsigned int BlockWidth256BytesC[],unsigned int DCCYMaxUncompressedBlock[],unsigned int DCCCMaxUncompressedBlock[],unsigned int VActive[],bool DCCEnable[],bool WritebackEnable[],double ReadBandwidthSurfaceLuma[],double ReadBandwidthSurfaceChroma[],double meta_row_bw[],double dpte_row_bw[],double * StutterEfficiencyNotIncludingVBlank,double * StutterEfficiency,unsigned int * NumberOfStutterBurstsPerFrame,double * Z8StutterEfficiencyNotIncludingVBlank,double * Z8StutterEfficiency,unsigned int * Z8NumberOfStutterBurstsPerFrame,double * StutterPeriod,bool * DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE)5592dda4fb85SAurabindo Pillai void dml32_CalculateStutterEfficiency(
5593dda4fb85SAurabindo Pillai unsigned int CompressedBufferSizeInkByte,
5594dda4fb85SAurabindo Pillai enum dm_use_mall_for_pstate_change_mode UseMALLForPStateChange[],
5595dda4fb85SAurabindo Pillai bool UnboundedRequestEnabled,
5596dda4fb85SAurabindo Pillai unsigned int MetaFIFOSizeInKEntries,
5597dda4fb85SAurabindo Pillai unsigned int ZeroSizeBufferEntries,
5598dda4fb85SAurabindo Pillai unsigned int PixelChunkSizeInKByte,
5599dda4fb85SAurabindo Pillai unsigned int NumberOfActiveSurfaces,
5600dda4fb85SAurabindo Pillai unsigned int ROBBufferSizeInKByte,
5601dda4fb85SAurabindo Pillai double TotalDataReadBandwidth,
5602dda4fb85SAurabindo Pillai double DCFCLK,
5603dda4fb85SAurabindo Pillai double ReturnBW,
5604dda4fb85SAurabindo Pillai unsigned int CompbufReservedSpace64B,
5605dda4fb85SAurabindo Pillai unsigned int CompbufReservedSpaceZs,
5606dda4fb85SAurabindo Pillai double SRExitTime,
5607dda4fb85SAurabindo Pillai double SRExitZ8Time,
5608dda4fb85SAurabindo Pillai bool SynchronizeTimingsFinal,
5609dda4fb85SAurabindo Pillai unsigned int BlendingAndTiming[],
5610dda4fb85SAurabindo Pillai double StutterEnterPlusExitWatermark,
5611dda4fb85SAurabindo Pillai double Z8StutterEnterPlusExitWatermark,
5612dda4fb85SAurabindo Pillai bool ProgressiveToInterlaceUnitInOPP,
5613dda4fb85SAurabindo Pillai bool Interlace[],
5614dda4fb85SAurabindo Pillai double MinTTUVBlank[],
5615dda4fb85SAurabindo Pillai unsigned int DPPPerSurface[],
5616dda4fb85SAurabindo Pillai unsigned int DETBufferSizeY[],
5617dda4fb85SAurabindo Pillai unsigned int BytePerPixelY[],
5618dda4fb85SAurabindo Pillai double BytePerPixelDETY[],
5619dda4fb85SAurabindo Pillai double SwathWidthY[],
5620dda4fb85SAurabindo Pillai unsigned int SwathHeightY[],
5621dda4fb85SAurabindo Pillai unsigned int SwathHeightC[],
5622dda4fb85SAurabindo Pillai double NetDCCRateLuma[],
5623dda4fb85SAurabindo Pillai double NetDCCRateChroma[],
5624dda4fb85SAurabindo Pillai double DCCFractionOfZeroSizeRequestsLuma[],
5625dda4fb85SAurabindo Pillai double DCCFractionOfZeroSizeRequestsChroma[],
5626dda4fb85SAurabindo Pillai unsigned int HTotal[],
5627dda4fb85SAurabindo Pillai unsigned int VTotal[],
5628dda4fb85SAurabindo Pillai double PixelClock[],
5629dda4fb85SAurabindo Pillai double VRatio[],
5630dda4fb85SAurabindo Pillai enum dm_rotation_angle SourceRotation[],
5631dda4fb85SAurabindo Pillai unsigned int BlockHeight256BytesY[],
5632dda4fb85SAurabindo Pillai unsigned int BlockWidth256BytesY[],
5633dda4fb85SAurabindo Pillai unsigned int BlockHeight256BytesC[],
5634dda4fb85SAurabindo Pillai unsigned int BlockWidth256BytesC[],
5635dda4fb85SAurabindo Pillai unsigned int DCCYMaxUncompressedBlock[],
5636dda4fb85SAurabindo Pillai unsigned int DCCCMaxUncompressedBlock[],
5637dda4fb85SAurabindo Pillai unsigned int VActive[],
5638dda4fb85SAurabindo Pillai bool DCCEnable[],
5639dda4fb85SAurabindo Pillai bool WritebackEnable[],
5640dda4fb85SAurabindo Pillai double ReadBandwidthSurfaceLuma[],
5641dda4fb85SAurabindo Pillai double ReadBandwidthSurfaceChroma[],
5642dda4fb85SAurabindo Pillai double meta_row_bw[],
5643dda4fb85SAurabindo Pillai double dpte_row_bw[],
5644dda4fb85SAurabindo Pillai
5645dda4fb85SAurabindo Pillai /* Output */
5646dda4fb85SAurabindo Pillai double *StutterEfficiencyNotIncludingVBlank,
5647dda4fb85SAurabindo Pillai double *StutterEfficiency,
5648dda4fb85SAurabindo Pillai unsigned int *NumberOfStutterBurstsPerFrame,
5649dda4fb85SAurabindo Pillai double *Z8StutterEfficiencyNotIncludingVBlank,
5650dda4fb85SAurabindo Pillai double *Z8StutterEfficiency,
5651dda4fb85SAurabindo Pillai unsigned int *Z8NumberOfStutterBurstsPerFrame,
5652dda4fb85SAurabindo Pillai double *StutterPeriod,
5653dda4fb85SAurabindo Pillai bool *DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE)
5654dda4fb85SAurabindo Pillai {
5655dda4fb85SAurabindo Pillai
5656dda4fb85SAurabindo Pillai bool FoundCriticalSurface = false;
5657dda4fb85SAurabindo Pillai unsigned int SwathSizeCriticalSurface = 0;
5658dda4fb85SAurabindo Pillai unsigned int LastChunkOfSwathSize;
5659dda4fb85SAurabindo Pillai unsigned int MissingPartOfLastSwathOfDETSize;
5660dda4fb85SAurabindo Pillai double LastZ8StutterPeriod = 0.0;
5661dda4fb85SAurabindo Pillai double LastStutterPeriod = 0.0;
5662dda4fb85SAurabindo Pillai unsigned int TotalNumberOfActiveOTG = 0;
5663dda4fb85SAurabindo Pillai double doublePixelClock;
5664dda4fb85SAurabindo Pillai unsigned int doubleHTotal;
5665dda4fb85SAurabindo Pillai unsigned int doubleVTotal;
5666dda4fb85SAurabindo Pillai bool SameTiming = true;
5667dda4fb85SAurabindo Pillai double DETBufferingTimeY;
5668dda4fb85SAurabindo Pillai double SwathWidthYCriticalSurface = 0.0;
5669dda4fb85SAurabindo Pillai double SwathHeightYCriticalSurface = 0.0;
5670dda4fb85SAurabindo Pillai double VActiveTimeCriticalSurface = 0.0;
5671dda4fb85SAurabindo Pillai double FrameTimeCriticalSurface = 0.0;
5672dda4fb85SAurabindo Pillai unsigned int BytePerPixelYCriticalSurface = 0;
5673dda4fb85SAurabindo Pillai double LinesToFinishSwathTransferStutterCriticalSurface = 0.0;
5674dda4fb85SAurabindo Pillai unsigned int DETBufferSizeYCriticalSurface = 0;
5675dda4fb85SAurabindo Pillai double MinTTUVBlankCriticalSurface = 0.0;
5676dda4fb85SAurabindo Pillai unsigned int BlockWidth256BytesYCriticalSurface = 0;
5677dda4fb85SAurabindo Pillai bool doublePlaneCriticalSurface = 0;
5678dda4fb85SAurabindo Pillai bool doublePipeCriticalSurface = 0;
5679dda4fb85SAurabindo Pillai double TotalCompressedReadBandwidth;
5680dda4fb85SAurabindo Pillai double TotalRowReadBandwidth;
5681dda4fb85SAurabindo Pillai double AverageDCCCompressionRate;
5682dda4fb85SAurabindo Pillai double EffectiveCompressedBufferSize;
5683dda4fb85SAurabindo Pillai double PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer;
5684dda4fb85SAurabindo Pillai double StutterBurstTime;
5685dda4fb85SAurabindo Pillai unsigned int TotalActiveWriteback;
5686dda4fb85SAurabindo Pillai double LinesInDETY;
5687dda4fb85SAurabindo Pillai double LinesInDETYRoundedDownToSwath;
5688dda4fb85SAurabindo Pillai double MaximumEffectiveCompressionLuma;
5689dda4fb85SAurabindo Pillai double MaximumEffectiveCompressionChroma;
5690dda4fb85SAurabindo Pillai double TotalZeroSizeRequestReadBandwidth;
5691dda4fb85SAurabindo Pillai double TotalZeroSizeCompressedReadBandwidth;
5692dda4fb85SAurabindo Pillai double AverageDCCZeroSizeFraction;
5693dda4fb85SAurabindo Pillai double AverageZeroSizeCompressionRate;
5694dda4fb85SAurabindo Pillai unsigned int k;
5695dda4fb85SAurabindo Pillai
5696dda4fb85SAurabindo Pillai TotalZeroSizeRequestReadBandwidth = 0;
5697dda4fb85SAurabindo Pillai TotalZeroSizeCompressedReadBandwidth = 0;
5698dda4fb85SAurabindo Pillai TotalRowReadBandwidth = 0;
5699dda4fb85SAurabindo Pillai TotalCompressedReadBandwidth = 0;
5700dda4fb85SAurabindo Pillai
5701dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
5702dda4fb85SAurabindo Pillai if (UseMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe) {
5703dda4fb85SAurabindo Pillai if (DCCEnable[k] == true) {
5704dda4fb85SAurabindo Pillai if ((IsVertical(SourceRotation[k]) && BlockWidth256BytesY[k] > SwathHeightY[k])
5705dda4fb85SAurabindo Pillai || (!IsVertical(SourceRotation[k])
5706dda4fb85SAurabindo Pillai && BlockHeight256BytesY[k] > SwathHeightY[k])
5707dda4fb85SAurabindo Pillai || DCCYMaxUncompressedBlock[k] < 256) {
5708dda4fb85SAurabindo Pillai MaximumEffectiveCompressionLuma = 2;
5709dda4fb85SAurabindo Pillai } else {
5710dda4fb85SAurabindo Pillai MaximumEffectiveCompressionLuma = 4;
5711dda4fb85SAurabindo Pillai }
5712dda4fb85SAurabindo Pillai TotalCompressedReadBandwidth = TotalCompressedReadBandwidth
5713dda4fb85SAurabindo Pillai + ReadBandwidthSurfaceLuma[k]
5714dda4fb85SAurabindo Pillai / dml_min(NetDCCRateLuma[k],
5715dda4fb85SAurabindo Pillai MaximumEffectiveCompressionLuma);
5716dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5717dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, ReadBandwidthSurfaceLuma = %f\n",
5718dda4fb85SAurabindo Pillai __func__, k, ReadBandwidthSurfaceLuma[k]);
5719dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, NetDCCRateLuma = %f\n",
5720dda4fb85SAurabindo Pillai __func__, k, NetDCCRateLuma[k]);
5721dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, MaximumEffectiveCompressionLuma = %f\n",
5722dda4fb85SAurabindo Pillai __func__, k, MaximumEffectiveCompressionLuma);
5723dda4fb85SAurabindo Pillai #endif
5724dda4fb85SAurabindo Pillai TotalZeroSizeRequestReadBandwidth = TotalZeroSizeRequestReadBandwidth
5725dda4fb85SAurabindo Pillai + ReadBandwidthSurfaceLuma[k] * DCCFractionOfZeroSizeRequestsLuma[k];
5726dda4fb85SAurabindo Pillai TotalZeroSizeCompressedReadBandwidth = TotalZeroSizeCompressedReadBandwidth
5727dda4fb85SAurabindo Pillai + ReadBandwidthSurfaceLuma[k] * DCCFractionOfZeroSizeRequestsLuma[k]
5728dda4fb85SAurabindo Pillai / MaximumEffectiveCompressionLuma;
5729dda4fb85SAurabindo Pillai
5730dda4fb85SAurabindo Pillai if (ReadBandwidthSurfaceChroma[k] > 0) {
5731dda4fb85SAurabindo Pillai if ((IsVertical(SourceRotation[k]) && BlockWidth256BytesC[k] > SwathHeightC[k])
5732dda4fb85SAurabindo Pillai || (!IsVertical(SourceRotation[k])
5733dda4fb85SAurabindo Pillai && BlockHeight256BytesC[k] > SwathHeightC[k])
5734dda4fb85SAurabindo Pillai || DCCCMaxUncompressedBlock[k] < 256) {
5735dda4fb85SAurabindo Pillai MaximumEffectiveCompressionChroma = 2;
5736dda4fb85SAurabindo Pillai } else {
5737dda4fb85SAurabindo Pillai MaximumEffectiveCompressionChroma = 4;
5738dda4fb85SAurabindo Pillai }
5739dda4fb85SAurabindo Pillai TotalCompressedReadBandwidth =
5740dda4fb85SAurabindo Pillai TotalCompressedReadBandwidth
5741dda4fb85SAurabindo Pillai + ReadBandwidthSurfaceChroma[k]
5742dda4fb85SAurabindo Pillai / dml_min(NetDCCRateChroma[k],
5743dda4fb85SAurabindo Pillai MaximumEffectiveCompressionChroma);
5744dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5745dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, ReadBandwidthSurfaceChroma = %f\n",
5746dda4fb85SAurabindo Pillai __func__, k, ReadBandwidthSurfaceChroma[k]);
5747dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, NetDCCRateChroma = %f\n",
5748dda4fb85SAurabindo Pillai __func__, k, NetDCCRateChroma[k]);
5749dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, MaximumEffectiveCompressionChroma = %f\n",
5750dda4fb85SAurabindo Pillai __func__, k, MaximumEffectiveCompressionChroma);
5751dda4fb85SAurabindo Pillai #endif
5752dda4fb85SAurabindo Pillai TotalZeroSizeRequestReadBandwidth = TotalZeroSizeRequestReadBandwidth
5753dda4fb85SAurabindo Pillai + ReadBandwidthSurfaceChroma[k]
5754dda4fb85SAurabindo Pillai * DCCFractionOfZeroSizeRequestsChroma[k];
5755dda4fb85SAurabindo Pillai TotalZeroSizeCompressedReadBandwidth = TotalZeroSizeCompressedReadBandwidth
5756dda4fb85SAurabindo Pillai + ReadBandwidthSurfaceChroma[k]
5757dda4fb85SAurabindo Pillai * DCCFractionOfZeroSizeRequestsChroma[k]
5758dda4fb85SAurabindo Pillai / MaximumEffectiveCompressionChroma;
5759dda4fb85SAurabindo Pillai }
5760dda4fb85SAurabindo Pillai } else {
5761dda4fb85SAurabindo Pillai TotalCompressedReadBandwidth = TotalCompressedReadBandwidth
5762dda4fb85SAurabindo Pillai + ReadBandwidthSurfaceLuma[k] + ReadBandwidthSurfaceChroma[k];
5763dda4fb85SAurabindo Pillai }
5764dda4fb85SAurabindo Pillai TotalRowReadBandwidth = TotalRowReadBandwidth
5765dda4fb85SAurabindo Pillai + DPPPerSurface[k] * (meta_row_bw[k] + dpte_row_bw[k]);
5766dda4fb85SAurabindo Pillai }
5767dda4fb85SAurabindo Pillai }
5768dda4fb85SAurabindo Pillai
5769dda4fb85SAurabindo Pillai AverageDCCCompressionRate = TotalDataReadBandwidth / TotalCompressedReadBandwidth;
5770dda4fb85SAurabindo Pillai AverageDCCZeroSizeFraction = TotalZeroSizeRequestReadBandwidth / TotalDataReadBandwidth;
5771dda4fb85SAurabindo Pillai
5772dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5773dda4fb85SAurabindo Pillai dml_print("DML::%s: UnboundedRequestEnabled = %d\n", __func__, UnboundedRequestEnabled);
5774dda4fb85SAurabindo Pillai dml_print("DML::%s: TotalCompressedReadBandwidth = %f\n", __func__, TotalCompressedReadBandwidth);
5775dda4fb85SAurabindo Pillai dml_print("DML::%s: TotalZeroSizeRequestReadBandwidth = %f\n", __func__, TotalZeroSizeRequestReadBandwidth);
5776dda4fb85SAurabindo Pillai dml_print("DML::%s: TotalZeroSizeCompressedReadBandwidth = %f\n",
5777dda4fb85SAurabindo Pillai __func__, TotalZeroSizeCompressedReadBandwidth);
5778dda4fb85SAurabindo Pillai dml_print("DML::%s: MaximumEffectiveCompressionLuma = %f\n", __func__, MaximumEffectiveCompressionLuma);
5779dda4fb85SAurabindo Pillai dml_print("DML::%s: MaximumEffectiveCompressionChroma = %f\n", __func__, MaximumEffectiveCompressionChroma);
5780dda4fb85SAurabindo Pillai dml_print("DML::%s: AverageDCCCompressionRate = %f\n", __func__, AverageDCCCompressionRate);
5781dda4fb85SAurabindo Pillai dml_print("DML::%s: AverageDCCZeroSizeFraction = %f\n", __func__, AverageDCCZeroSizeFraction);
5782dda4fb85SAurabindo Pillai dml_print("DML::%s: CompbufReservedSpace64B = %d\n", __func__, CompbufReservedSpace64B);
5783dda4fb85SAurabindo Pillai dml_print("DML::%s: CompbufReservedSpaceZs = %d\n", __func__, CompbufReservedSpaceZs);
5784dda4fb85SAurabindo Pillai dml_print("DML::%s: CompressedBufferSizeInkByte = %d\n", __func__, CompressedBufferSizeInkByte);
5785dda4fb85SAurabindo Pillai #endif
5786dda4fb85SAurabindo Pillai if (AverageDCCZeroSizeFraction == 1) {
5787dda4fb85SAurabindo Pillai AverageZeroSizeCompressionRate = TotalZeroSizeRequestReadBandwidth
5788dda4fb85SAurabindo Pillai / TotalZeroSizeCompressedReadBandwidth;
5789dda4fb85SAurabindo Pillai EffectiveCompressedBufferSize = (double) MetaFIFOSizeInKEntries * 1024 * 64
5790dda4fb85SAurabindo Pillai * AverageZeroSizeCompressionRate
5791dda4fb85SAurabindo Pillai + ((double) ZeroSizeBufferEntries - CompbufReservedSpaceZs) * 64
5792dda4fb85SAurabindo Pillai * AverageZeroSizeCompressionRate;
5793dda4fb85SAurabindo Pillai } else if (AverageDCCZeroSizeFraction > 0) {
5794dda4fb85SAurabindo Pillai AverageZeroSizeCompressionRate = TotalZeroSizeRequestReadBandwidth
5795dda4fb85SAurabindo Pillai / TotalZeroSizeCompressedReadBandwidth;
5796dda4fb85SAurabindo Pillai EffectiveCompressedBufferSize = dml_min(
5797dda4fb85SAurabindo Pillai (double) CompressedBufferSizeInkByte * 1024 * AverageDCCCompressionRate,
5798dda4fb85SAurabindo Pillai (double) MetaFIFOSizeInKEntries * 1024 * 64
5799dda4fb85SAurabindo Pillai / (AverageDCCZeroSizeFraction / AverageZeroSizeCompressionRate
5800dda4fb85SAurabindo Pillai + 1 / AverageDCCCompressionRate))
5801dda4fb85SAurabindo Pillai + dml_min(((double) ROBBufferSizeInKByte * 1024 - CompbufReservedSpace64B * 64)
5802dda4fb85SAurabindo Pillai * AverageDCCCompressionRate,
5803dda4fb85SAurabindo Pillai ((double) ZeroSizeBufferEntries - CompbufReservedSpaceZs) * 64
5804dda4fb85SAurabindo Pillai / (AverageDCCZeroSizeFraction / AverageZeroSizeCompressionRate));
5805dda4fb85SAurabindo Pillai
5806dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5807dda4fb85SAurabindo Pillai dml_print("DML::%s: min 1 = %f\n", __func__,
5808dda4fb85SAurabindo Pillai CompressedBufferSizeInkByte * 1024 * AverageDCCCompressionRate);
5809dda4fb85SAurabindo Pillai dml_print("DML::%s: min 2 = %f\n", __func__, MetaFIFOSizeInKEntries * 1024 * 64 /
5810dda4fb85SAurabindo Pillai (AverageDCCZeroSizeFraction / AverageZeroSizeCompressionRate + 1 /
5811dda4fb85SAurabindo Pillai AverageDCCCompressionRate));
5812dda4fb85SAurabindo Pillai dml_print("DML::%s: min 3 = %f\n", __func__, (ROBBufferSizeInKByte * 1024 -
5813dda4fb85SAurabindo Pillai CompbufReservedSpace64B * 64) * AverageDCCCompressionRate);
5814dda4fb85SAurabindo Pillai dml_print("DML::%s: min 4 = %f\n", __func__, (ZeroSizeBufferEntries - CompbufReservedSpaceZs) * 64 /
5815dda4fb85SAurabindo Pillai (AverageDCCZeroSizeFraction / AverageZeroSizeCompressionRate));
5816dda4fb85SAurabindo Pillai #endif
5817dda4fb85SAurabindo Pillai } else {
5818dda4fb85SAurabindo Pillai EffectiveCompressedBufferSize = dml_min(
5819dda4fb85SAurabindo Pillai (double) CompressedBufferSizeInkByte * 1024 * AverageDCCCompressionRate,
5820dda4fb85SAurabindo Pillai (double) MetaFIFOSizeInKEntries * 1024 * 64 * AverageDCCCompressionRate)
5821dda4fb85SAurabindo Pillai + ((double) ROBBufferSizeInKByte * 1024 - CompbufReservedSpace64B * 64)
5822dda4fb85SAurabindo Pillai * AverageDCCCompressionRate;
5823dda4fb85SAurabindo Pillai
5824dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5825dda4fb85SAurabindo Pillai dml_print("DML::%s: min 1 = %f\n", __func__,
5826dda4fb85SAurabindo Pillai CompressedBufferSizeInkByte * 1024 * AverageDCCCompressionRate);
5827dda4fb85SAurabindo Pillai dml_print("DML::%s: min 2 = %f\n", __func__,
5828dda4fb85SAurabindo Pillai MetaFIFOSizeInKEntries * 1024 * 64 * AverageDCCCompressionRate);
5829dda4fb85SAurabindo Pillai #endif
5830dda4fb85SAurabindo Pillai }
5831dda4fb85SAurabindo Pillai
5832dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5833dda4fb85SAurabindo Pillai dml_print("DML::%s: MetaFIFOSizeInKEntries = %d\n", __func__, MetaFIFOSizeInKEntries);
5834dda4fb85SAurabindo Pillai dml_print("DML::%s: AverageZeroSizeCompressionRate = %f\n", __func__, AverageZeroSizeCompressionRate);
5835dda4fb85SAurabindo Pillai dml_print("DML::%s: EffectiveCompressedBufferSize = %f\n", __func__, EffectiveCompressedBufferSize);
5836dda4fb85SAurabindo Pillai #endif
5837dda4fb85SAurabindo Pillai
5838dda4fb85SAurabindo Pillai *StutterPeriod = 0;
5839dda4fb85SAurabindo Pillai
5840dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
5841dda4fb85SAurabindo Pillai if (UseMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe) {
5842dda4fb85SAurabindo Pillai LinesInDETY = ((double) DETBufferSizeY[k]
5843dda4fb85SAurabindo Pillai + (UnboundedRequestEnabled == true ? EffectiveCompressedBufferSize : 0)
5844dda4fb85SAurabindo Pillai * ReadBandwidthSurfaceLuma[k] / TotalDataReadBandwidth)
5845dda4fb85SAurabindo Pillai / BytePerPixelDETY[k] / SwathWidthY[k];
5846dda4fb85SAurabindo Pillai LinesInDETYRoundedDownToSwath = dml_floor(LinesInDETY, SwathHeightY[k]);
5847dda4fb85SAurabindo Pillai DETBufferingTimeY = LinesInDETYRoundedDownToSwath * ((double) HTotal[k] / PixelClock[k])
5848dda4fb85SAurabindo Pillai / VRatio[k];
5849dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5850dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DETBufferSizeY = %d\n", __func__, k, DETBufferSizeY[k]);
5851dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, BytePerPixelDETY = %f\n", __func__, k, BytePerPixelDETY[k]);
5852dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, SwathWidthY = %d\n", __func__, k, SwathWidthY[k]);
5853dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, ReadBandwidthSurfaceLuma = %f\n",
5854dda4fb85SAurabindo Pillai __func__, k, ReadBandwidthSurfaceLuma[k]);
5855dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, TotalDataReadBandwidth = %f\n", __func__, k, TotalDataReadBandwidth);
5856dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, LinesInDETY = %f\n", __func__, k, LinesInDETY);
5857dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, LinesInDETYRoundedDownToSwath = %f\n",
5858dda4fb85SAurabindo Pillai __func__, k, LinesInDETYRoundedDownToSwath);
5859dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, HTotal = %d\n", __func__, k, HTotal[k]);
5860dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, PixelClock = %f\n", __func__, k, PixelClock[k]);
5861dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, VRatio = %f\n", __func__, k, VRatio[k]);
5862dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, DETBufferingTimeY = %f\n", __func__, k, DETBufferingTimeY);
5863dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, PixelClock = %f\n", __func__, k, PixelClock[k]);
5864dda4fb85SAurabindo Pillai #endif
5865dda4fb85SAurabindo Pillai
5866dda4fb85SAurabindo Pillai if (!FoundCriticalSurface || DETBufferingTimeY < *StutterPeriod) {
5867dda4fb85SAurabindo Pillai bool isInterlaceTiming = Interlace[k] && !ProgressiveToInterlaceUnitInOPP;
5868dda4fb85SAurabindo Pillai
5869dda4fb85SAurabindo Pillai FoundCriticalSurface = true;
5870dda4fb85SAurabindo Pillai *StutterPeriod = DETBufferingTimeY;
5871dda4fb85SAurabindo Pillai FrameTimeCriticalSurface = (
5872dda4fb85SAurabindo Pillai isInterlaceTiming ?
5873dda4fb85SAurabindo Pillai dml_floor((double) VTotal[k] / 2.0, 1.0) : VTotal[k])
5874dda4fb85SAurabindo Pillai * (double) HTotal[k] / PixelClock[k];
5875dda4fb85SAurabindo Pillai VActiveTimeCriticalSurface = (
5876dda4fb85SAurabindo Pillai isInterlaceTiming ?
5877dda4fb85SAurabindo Pillai dml_floor((double) VActive[k] / 2.0, 1.0) : VActive[k])
5878dda4fb85SAurabindo Pillai * (double) HTotal[k] / PixelClock[k];
5879dda4fb85SAurabindo Pillai BytePerPixelYCriticalSurface = BytePerPixelY[k];
5880dda4fb85SAurabindo Pillai SwathWidthYCriticalSurface = SwathWidthY[k];
5881dda4fb85SAurabindo Pillai SwathHeightYCriticalSurface = SwathHeightY[k];
5882dda4fb85SAurabindo Pillai BlockWidth256BytesYCriticalSurface = BlockWidth256BytesY[k];
5883dda4fb85SAurabindo Pillai LinesToFinishSwathTransferStutterCriticalSurface = SwathHeightY[k]
5884dda4fb85SAurabindo Pillai - (LinesInDETY - LinesInDETYRoundedDownToSwath);
5885dda4fb85SAurabindo Pillai DETBufferSizeYCriticalSurface = DETBufferSizeY[k];
5886dda4fb85SAurabindo Pillai MinTTUVBlankCriticalSurface = MinTTUVBlank[k];
5887dda4fb85SAurabindo Pillai doublePlaneCriticalSurface = (ReadBandwidthSurfaceChroma[k] == 0);
5888dda4fb85SAurabindo Pillai doublePipeCriticalSurface = (DPPPerSurface[k] == 1);
5889dda4fb85SAurabindo Pillai
5890dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5891dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, FoundCriticalSurface = %d\n",
5892dda4fb85SAurabindo Pillai __func__, k, FoundCriticalSurface);
5893dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, StutterPeriod = %f\n",
5894dda4fb85SAurabindo Pillai __func__, k, *StutterPeriod);
5895dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, MinTTUVBlankCriticalSurface = %f\n",
5896dda4fb85SAurabindo Pillai __func__, k, MinTTUVBlankCriticalSurface);
5897dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, FrameTimeCriticalSurface = %f\n",
5898dda4fb85SAurabindo Pillai __func__, k, FrameTimeCriticalSurface);
5899dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, VActiveTimeCriticalSurface = %f\n",
5900dda4fb85SAurabindo Pillai __func__, k, VActiveTimeCriticalSurface);
5901dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, BytePerPixelYCriticalSurface = %d\n",
5902dda4fb85SAurabindo Pillai __func__, k, BytePerPixelYCriticalSurface);
5903dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, SwathWidthYCriticalSurface = %f\n",
5904dda4fb85SAurabindo Pillai __func__, k, SwathWidthYCriticalSurface);
5905dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, SwathHeightYCriticalSurface = %f\n",
5906dda4fb85SAurabindo Pillai __func__, k, SwathHeightYCriticalSurface);
5907dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, BlockWidth256BytesYCriticalSurface = %d\n",
5908dda4fb85SAurabindo Pillai __func__, k, BlockWidth256BytesYCriticalSurface);
5909dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, doublePlaneCriticalSurface = %d\n",
5910dda4fb85SAurabindo Pillai __func__, k, doublePlaneCriticalSurface);
5911dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, doublePipeCriticalSurface = %d\n",
5912dda4fb85SAurabindo Pillai __func__, k, doublePipeCriticalSurface);
5913dda4fb85SAurabindo Pillai dml_print("DML::%s: k=%0d, LinesToFinishSwathTransferStutterCriticalSurface = %f\n",
5914dda4fb85SAurabindo Pillai __func__, k, LinesToFinishSwathTransferStutterCriticalSurface);
5915dda4fb85SAurabindo Pillai #endif
5916dda4fb85SAurabindo Pillai }
5917dda4fb85SAurabindo Pillai }
5918dda4fb85SAurabindo Pillai }
5919dda4fb85SAurabindo Pillai
5920dda4fb85SAurabindo Pillai PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer = dml_min(*StutterPeriod * TotalDataReadBandwidth,
5921dda4fb85SAurabindo Pillai EffectiveCompressedBufferSize);
5922dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5923dda4fb85SAurabindo Pillai dml_print("DML::%s: ROBBufferSizeInKByte = %d\n", __func__, ROBBufferSizeInKByte);
5924dda4fb85SAurabindo Pillai dml_print("DML::%s: AverageDCCCompressionRate = %f\n", __func__, AverageDCCCompressionRate);
5925dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterPeriod * TotalDataReadBandwidth = %f\n",
5926dda4fb85SAurabindo Pillai __func__, *StutterPeriod * TotalDataReadBandwidth);
5927dda4fb85SAurabindo Pillai dml_print("DML::%s: EffectiveCompressedBufferSize = %f\n", __func__, EffectiveCompressedBufferSize);
5928dda4fb85SAurabindo Pillai dml_print("DML::%s: PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer = %f\n", __func__,
5929dda4fb85SAurabindo Pillai PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer);
5930dda4fb85SAurabindo Pillai dml_print("DML::%s: ReturnBW = %f\n", __func__, ReturnBW);
5931dda4fb85SAurabindo Pillai dml_print("DML::%s: TotalDataReadBandwidth = %f\n", __func__, TotalDataReadBandwidth);
5932dda4fb85SAurabindo Pillai dml_print("DML::%s: TotalRowReadBandwidth = %f\n", __func__, TotalRowReadBandwidth);
5933dda4fb85SAurabindo Pillai dml_print("DML::%s: DCFCLK = %f\n", __func__, DCFCLK);
5934dda4fb85SAurabindo Pillai #endif
5935dda4fb85SAurabindo Pillai
5936dda4fb85SAurabindo Pillai StutterBurstTime = PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer / AverageDCCCompressionRate
5937dda4fb85SAurabindo Pillai / ReturnBW
5938dda4fb85SAurabindo Pillai + (*StutterPeriod * TotalDataReadBandwidth
5939dda4fb85SAurabindo Pillai - PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer) / (DCFCLK * 64)
5940dda4fb85SAurabindo Pillai + *StutterPeriod * TotalRowReadBandwidth / ReturnBW;
5941dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5942dda4fb85SAurabindo Pillai dml_print("DML::%s: Part 1 = %f\n", __func__, PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer /
5943dda4fb85SAurabindo Pillai AverageDCCCompressionRate / ReturnBW);
5944dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterPeriod * TotalDataReadBandwidth = %f\n",
5945dda4fb85SAurabindo Pillai __func__, (*StutterPeriod * TotalDataReadBandwidth));
5946dda4fb85SAurabindo Pillai dml_print("DML::%s: Part 2 = %f\n", __func__, (*StutterPeriod * TotalDataReadBandwidth -
5947dda4fb85SAurabindo Pillai PartOfUncompressedPixelBurstThatFitsInROBAndCompressedBuffer) / (DCFCLK * 64));
5948dda4fb85SAurabindo Pillai dml_print("DML::%s: Part 3 = %f\n", __func__, *StutterPeriod * TotalRowReadBandwidth / ReturnBW);
5949dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterBurstTime = %f\n", __func__, StutterBurstTime);
5950dda4fb85SAurabindo Pillai #endif
5951dda4fb85SAurabindo Pillai StutterBurstTime = dml_max(StutterBurstTime,
5952dda4fb85SAurabindo Pillai LinesToFinishSwathTransferStutterCriticalSurface * BytePerPixelYCriticalSurface
5953dda4fb85SAurabindo Pillai * SwathWidthYCriticalSurface / ReturnBW);
5954dda4fb85SAurabindo Pillai
5955dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5956dda4fb85SAurabindo Pillai dml_print("DML::%s: Time to finish residue swath=%f\n",
5957dda4fb85SAurabindo Pillai __func__,
5958dda4fb85SAurabindo Pillai LinesToFinishSwathTransferStutterCriticalSurface *
5959dda4fb85SAurabindo Pillai BytePerPixelYCriticalSurface * SwathWidthYCriticalSurface / ReturnBW);
5960dda4fb85SAurabindo Pillai #endif
5961dda4fb85SAurabindo Pillai
5962dda4fb85SAurabindo Pillai TotalActiveWriteback = 0;
5963dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
5964dda4fb85SAurabindo Pillai if (WritebackEnable[k])
5965dda4fb85SAurabindo Pillai TotalActiveWriteback = TotalActiveWriteback + 1;
5966dda4fb85SAurabindo Pillai }
5967dda4fb85SAurabindo Pillai
5968dda4fb85SAurabindo Pillai if (TotalActiveWriteback == 0) {
5969dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5970dda4fb85SAurabindo Pillai dml_print("DML::%s: SRExitTime = %f\n", __func__, SRExitTime);
5971dda4fb85SAurabindo Pillai dml_print("DML::%s: SRExitZ8Time = %f\n", __func__, SRExitZ8Time);
5972dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterBurstTime = %f (final)\n", __func__, StutterBurstTime);
5973dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterPeriod = %f\n", __func__, *StutterPeriod);
5974dda4fb85SAurabindo Pillai #endif
5975dda4fb85SAurabindo Pillai *StutterEfficiencyNotIncludingVBlank = dml_max(0.,
5976dda4fb85SAurabindo Pillai 1 - (SRExitTime + StutterBurstTime) / *StutterPeriod) * 100;
5977dda4fb85SAurabindo Pillai *Z8StutterEfficiencyNotIncludingVBlank = dml_max(0.,
5978dda4fb85SAurabindo Pillai 1 - (SRExitZ8Time + StutterBurstTime) / *StutterPeriod) * 100;
5979dda4fb85SAurabindo Pillai *NumberOfStutterBurstsPerFrame = (
5980dda4fb85SAurabindo Pillai *StutterEfficiencyNotIncludingVBlank > 0 ?
5981dda4fb85SAurabindo Pillai dml_ceil(VActiveTimeCriticalSurface / *StutterPeriod, 1) : 0);
5982dda4fb85SAurabindo Pillai *Z8NumberOfStutterBurstsPerFrame = (
5983dda4fb85SAurabindo Pillai *Z8StutterEfficiencyNotIncludingVBlank > 0 ?
5984dda4fb85SAurabindo Pillai dml_ceil(VActiveTimeCriticalSurface / *StutterPeriod, 1) : 0);
5985dda4fb85SAurabindo Pillai } else {
5986dda4fb85SAurabindo Pillai *StutterEfficiencyNotIncludingVBlank = 0.;
5987dda4fb85SAurabindo Pillai *Z8StutterEfficiencyNotIncludingVBlank = 0.;
5988dda4fb85SAurabindo Pillai *NumberOfStutterBurstsPerFrame = 0;
5989dda4fb85SAurabindo Pillai *Z8NumberOfStutterBurstsPerFrame = 0;
5990dda4fb85SAurabindo Pillai }
5991dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
5992dda4fb85SAurabindo Pillai dml_print("DML::%s: VActiveTimeCriticalSurface = %f\n", __func__, VActiveTimeCriticalSurface);
5993dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterEfficiencyNotIncludingVBlank = %f\n",
5994dda4fb85SAurabindo Pillai __func__, *StutterEfficiencyNotIncludingVBlank);
5995dda4fb85SAurabindo Pillai dml_print("DML::%s: Z8StutterEfficiencyNotIncludingVBlank = %f\n",
5996dda4fb85SAurabindo Pillai __func__, *Z8StutterEfficiencyNotIncludingVBlank);
5997dda4fb85SAurabindo Pillai dml_print("DML::%s: NumberOfStutterBurstsPerFrame = %d\n", __func__, *NumberOfStutterBurstsPerFrame);
5998dda4fb85SAurabindo Pillai dml_print("DML::%s: Z8NumberOfStutterBurstsPerFrame = %d\n", __func__, *Z8NumberOfStutterBurstsPerFrame);
5999dda4fb85SAurabindo Pillai #endif
6000dda4fb85SAurabindo Pillai
6001dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
6002dda4fb85SAurabindo Pillai if (UseMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe) {
6003dda4fb85SAurabindo Pillai if (BlendingAndTiming[k] == k) {
6004dda4fb85SAurabindo Pillai if (TotalNumberOfActiveOTG == 0) {
6005dda4fb85SAurabindo Pillai doublePixelClock = PixelClock[k];
6006dda4fb85SAurabindo Pillai doubleHTotal = HTotal[k];
6007dda4fb85SAurabindo Pillai doubleVTotal = VTotal[k];
6008dda4fb85SAurabindo Pillai } else if (doublePixelClock != PixelClock[k] || doubleHTotal != HTotal[k]
6009dda4fb85SAurabindo Pillai || doubleVTotal != VTotal[k]) {
6010dda4fb85SAurabindo Pillai SameTiming = false;
6011dda4fb85SAurabindo Pillai }
6012dda4fb85SAurabindo Pillai TotalNumberOfActiveOTG = TotalNumberOfActiveOTG + 1;
6013dda4fb85SAurabindo Pillai }
6014dda4fb85SAurabindo Pillai }
6015dda4fb85SAurabindo Pillai }
6016dda4fb85SAurabindo Pillai
6017dda4fb85SAurabindo Pillai if (*StutterEfficiencyNotIncludingVBlank > 0) {
6018dda4fb85SAurabindo Pillai LastStutterPeriod = VActiveTimeCriticalSurface - (*NumberOfStutterBurstsPerFrame - 1) * *StutterPeriod;
6019dda4fb85SAurabindo Pillai
6020dda4fb85SAurabindo Pillai if ((SynchronizeTimingsFinal || TotalNumberOfActiveOTG == 1) && SameTiming
6021dda4fb85SAurabindo Pillai && LastStutterPeriod + MinTTUVBlankCriticalSurface > StutterEnterPlusExitWatermark) {
6022dda4fb85SAurabindo Pillai *StutterEfficiency = (1 - (*NumberOfStutterBurstsPerFrame * SRExitTime
6023dda4fb85SAurabindo Pillai + StutterBurstTime * VActiveTimeCriticalSurface
6024dda4fb85SAurabindo Pillai / *StutterPeriod) / FrameTimeCriticalSurface) * 100;
6025dda4fb85SAurabindo Pillai } else {
6026dda4fb85SAurabindo Pillai *StutterEfficiency = *StutterEfficiencyNotIncludingVBlank;
6027dda4fb85SAurabindo Pillai }
6028dda4fb85SAurabindo Pillai } else {
6029dda4fb85SAurabindo Pillai *StutterEfficiency = 0;
6030dda4fb85SAurabindo Pillai }
6031dda4fb85SAurabindo Pillai
6032dda4fb85SAurabindo Pillai if (*Z8StutterEfficiencyNotIncludingVBlank > 0) {
6033dda4fb85SAurabindo Pillai LastZ8StutterPeriod = VActiveTimeCriticalSurface
6034dda4fb85SAurabindo Pillai - (*NumberOfStutterBurstsPerFrame - 1) * *StutterPeriod;
6035dda4fb85SAurabindo Pillai if ((SynchronizeTimingsFinal || TotalNumberOfActiveOTG == 1) && SameTiming && LastZ8StutterPeriod +
6036dda4fb85SAurabindo Pillai MinTTUVBlankCriticalSurface > Z8StutterEnterPlusExitWatermark) {
6037dda4fb85SAurabindo Pillai *Z8StutterEfficiency = (1 - (*NumberOfStutterBurstsPerFrame * SRExitZ8Time + StutterBurstTime
6038dda4fb85SAurabindo Pillai * VActiveTimeCriticalSurface / *StutterPeriod) / FrameTimeCriticalSurface) * 100;
6039dda4fb85SAurabindo Pillai } else {
6040dda4fb85SAurabindo Pillai *Z8StutterEfficiency = *Z8StutterEfficiencyNotIncludingVBlank;
6041dda4fb85SAurabindo Pillai }
6042dda4fb85SAurabindo Pillai } else {
6043dda4fb85SAurabindo Pillai *Z8StutterEfficiency = 0.;
6044dda4fb85SAurabindo Pillai }
6045dda4fb85SAurabindo Pillai
6046dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
6047dda4fb85SAurabindo Pillai dml_print("DML::%s: LastZ8StutterPeriod = %f\n", __func__, LastZ8StutterPeriod);
6048dda4fb85SAurabindo Pillai dml_print("DML::%s: Z8StutterEnterPlusExitWatermark = %f\n", __func__, Z8StutterEnterPlusExitWatermark);
6049dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterBurstTime = %f\n", __func__, StutterBurstTime);
6050dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterPeriod = %f\n", __func__, *StutterPeriod);
6051dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterEfficiency = %f\n", __func__, *StutterEfficiency);
6052dda4fb85SAurabindo Pillai dml_print("DML::%s: Z8StutterEfficiency = %f\n", __func__, *Z8StutterEfficiency);
6053dda4fb85SAurabindo Pillai dml_print("DML::%s: StutterEfficiencyNotIncludingVBlank = %f\n",
6054dda4fb85SAurabindo Pillai __func__, *StutterEfficiencyNotIncludingVBlank);
6055dda4fb85SAurabindo Pillai dml_print("DML::%s: Z8NumberOfStutterBurstsPerFrame = %d\n", __func__, *Z8NumberOfStutterBurstsPerFrame);
6056dda4fb85SAurabindo Pillai #endif
6057dda4fb85SAurabindo Pillai
6058dda4fb85SAurabindo Pillai SwathSizeCriticalSurface = BytePerPixelYCriticalSurface * SwathHeightYCriticalSurface
6059dda4fb85SAurabindo Pillai * dml_ceil(SwathWidthYCriticalSurface, BlockWidth256BytesYCriticalSurface);
6060dda4fb85SAurabindo Pillai LastChunkOfSwathSize = SwathSizeCriticalSurface % (PixelChunkSizeInKByte * 1024);
6061dda4fb85SAurabindo Pillai MissingPartOfLastSwathOfDETSize = dml_ceil(DETBufferSizeYCriticalSurface, SwathSizeCriticalSurface)
6062dda4fb85SAurabindo Pillai - DETBufferSizeYCriticalSurface;
6063dda4fb85SAurabindo Pillai
6064dda4fb85SAurabindo Pillai *DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE = !(!UnboundedRequestEnabled && (NumberOfActiveSurfaces == 1)
6065dda4fb85SAurabindo Pillai && doublePlaneCriticalSurface && doublePipeCriticalSurface && (LastChunkOfSwathSize > 0)
6066dda4fb85SAurabindo Pillai && (LastChunkOfSwathSize <= 4096) && (MissingPartOfLastSwathOfDETSize > 0)
6067dda4fb85SAurabindo Pillai && (MissingPartOfLastSwathOfDETSize <= LastChunkOfSwathSize));
6068dda4fb85SAurabindo Pillai
6069dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
6070dda4fb85SAurabindo Pillai dml_print("DML::%s: SwathSizeCriticalSurface = %d\n", __func__, SwathSizeCriticalSurface);
6071dda4fb85SAurabindo Pillai dml_print("DML::%s: LastChunkOfSwathSize = %d\n", __func__, LastChunkOfSwathSize);
6072dda4fb85SAurabindo Pillai dml_print("DML::%s: MissingPartOfLastSwathOfDETSize = %d\n", __func__, MissingPartOfLastSwathOfDETSize);
6073dda4fb85SAurabindo Pillai dml_print("DML::%s: DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE = %d\n", __func__, *DCHUBBUB_ARB_CSTATE_MAX_CAP_MODE);
6074dda4fb85SAurabindo Pillai #endif
6075dda4fb85SAurabindo Pillai } // CalculateStutterEfficiency
6076dda4fb85SAurabindo Pillai
dml32_CalculateMaxDETAndMinCompressedBufferSize(unsigned int ConfigReturnBufferSizeInKByte,unsigned int ROBBufferSizeInKByte,unsigned int MaxNumDPP,bool nomDETInKByteOverrideEnable,unsigned int nomDETInKByteOverrideValue,unsigned int * MaxTotalDETInKByte,unsigned int * nomDETInKByte,unsigned int * MinCompressedBufferSizeInKByte)6077dda4fb85SAurabindo Pillai void dml32_CalculateMaxDETAndMinCompressedBufferSize(
6078dda4fb85SAurabindo Pillai unsigned int ConfigReturnBufferSizeInKByte,
6079dda4fb85SAurabindo Pillai unsigned int ROBBufferSizeInKByte,
6080dda4fb85SAurabindo Pillai unsigned int MaxNumDPP,
6081dda4fb85SAurabindo Pillai bool nomDETInKByteOverrideEnable, // VBA_DELTA, allow DV to override default DET size
6082dda4fb85SAurabindo Pillai unsigned int nomDETInKByteOverrideValue, // VBA_DELTA
6083dda4fb85SAurabindo Pillai
6084dda4fb85SAurabindo Pillai /* Output */
6085dda4fb85SAurabindo Pillai unsigned int *MaxTotalDETInKByte,
6086dda4fb85SAurabindo Pillai unsigned int *nomDETInKByte,
6087dda4fb85SAurabindo Pillai unsigned int *MinCompressedBufferSizeInKByte)
6088dda4fb85SAurabindo Pillai {
6089dda4fb85SAurabindo Pillai bool det_buff_size_override_en = nomDETInKByteOverrideEnable;
6090dda4fb85SAurabindo Pillai unsigned int det_buff_size_override_val = nomDETInKByteOverrideValue;
6091dda4fb85SAurabindo Pillai
6092dda4fb85SAurabindo Pillai *MaxTotalDETInKByte = dml_ceil(((double)ConfigReturnBufferSizeInKByte +
6093dda4fb85SAurabindo Pillai (double) ROBBufferSizeInKByte) * 4.0 / 5.0, 64);
6094dda4fb85SAurabindo Pillai *nomDETInKByte = dml_floor((double) *MaxTotalDETInKByte / (double) MaxNumDPP, 64);
6095dda4fb85SAurabindo Pillai *MinCompressedBufferSizeInKByte = ConfigReturnBufferSizeInKByte - *MaxTotalDETInKByte;
6096dda4fb85SAurabindo Pillai
6097dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
6098dda4fb85SAurabindo Pillai dml_print("DML::%s: ConfigReturnBufferSizeInKByte = %0d\n", __func__, ConfigReturnBufferSizeInKByte);
6099dda4fb85SAurabindo Pillai dml_print("DML::%s: ROBBufferSizeInKByte = %0d\n", __func__, ROBBufferSizeInKByte);
6100dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxNumDPP = %0d\n", __func__, MaxNumDPP);
6101dda4fb85SAurabindo Pillai dml_print("DML::%s: MaxTotalDETInKByte = %0d\n", __func__, *MaxTotalDETInKByte);
6102dda4fb85SAurabindo Pillai dml_print("DML::%s: nomDETInKByte = %0d\n", __func__, *nomDETInKByte);
6103dda4fb85SAurabindo Pillai dml_print("DML::%s: MinCompressedBufferSizeInKByte = %0d\n", __func__, *MinCompressedBufferSizeInKByte);
6104dda4fb85SAurabindo Pillai #endif
6105dda4fb85SAurabindo Pillai
6106dda4fb85SAurabindo Pillai if (det_buff_size_override_en) {
6107dda4fb85SAurabindo Pillai *nomDETInKByte = det_buff_size_override_val;
6108dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
6109dda4fb85SAurabindo Pillai dml_print("DML::%s: nomDETInKByte = %0d (override)\n", __func__, *nomDETInKByte);
6110dda4fb85SAurabindo Pillai #endif
6111dda4fb85SAurabindo Pillai }
6112dda4fb85SAurabindo Pillai } // CalculateMaxDETAndMinCompressedBufferSize
6113dda4fb85SAurabindo Pillai
dml32_CalculateVActiveBandwithSupport(unsigned int NumberOfActiveSurfaces,double ReturnBW,bool NotUrgentLatencyHiding[],double ReadBandwidthLuma[],double ReadBandwidthChroma[],double cursor_bw[],double meta_row_bandwidth[],double dpte_row_bandwidth[],unsigned int NumberOfDPP[],double UrgentBurstFactorLuma[],double UrgentBurstFactorChroma[],double UrgentBurstFactorCursor[])6114dda4fb85SAurabindo Pillai bool dml32_CalculateVActiveBandwithSupport(unsigned int NumberOfActiveSurfaces,
6115dda4fb85SAurabindo Pillai double ReturnBW,
6116dda4fb85SAurabindo Pillai bool NotUrgentLatencyHiding[],
6117dda4fb85SAurabindo Pillai double ReadBandwidthLuma[],
6118dda4fb85SAurabindo Pillai double ReadBandwidthChroma[],
6119dda4fb85SAurabindo Pillai double cursor_bw[],
6120dda4fb85SAurabindo Pillai double meta_row_bandwidth[],
6121dda4fb85SAurabindo Pillai double dpte_row_bandwidth[],
6122dda4fb85SAurabindo Pillai unsigned int NumberOfDPP[],
6123dda4fb85SAurabindo Pillai double UrgentBurstFactorLuma[],
6124dda4fb85SAurabindo Pillai double UrgentBurstFactorChroma[],
6125dda4fb85SAurabindo Pillai double UrgentBurstFactorCursor[])
6126dda4fb85SAurabindo Pillai {
6127dda4fb85SAurabindo Pillai unsigned int k;
6128dda4fb85SAurabindo Pillai bool NotEnoughUrgentLatencyHiding = false;
6129dda4fb85SAurabindo Pillai bool CalculateVActiveBandwithSupport_val = false;
6130dda4fb85SAurabindo Pillai double VActiveBandwith = 0;
6131dda4fb85SAurabindo Pillai
6132dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
6133dda4fb85SAurabindo Pillai if (NotUrgentLatencyHiding[k]) {
6134dda4fb85SAurabindo Pillai NotEnoughUrgentLatencyHiding = true;
6135dda4fb85SAurabindo Pillai }
6136dda4fb85SAurabindo Pillai }
6137dda4fb85SAurabindo Pillai
6138dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
6139dda4fb85SAurabindo Pillai VActiveBandwith = VActiveBandwith + ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k] + NumberOfDPP[k] * meta_row_bandwidth[k] + NumberOfDPP[k] * dpte_row_bandwidth[k];
6140dda4fb85SAurabindo Pillai }
6141dda4fb85SAurabindo Pillai
6142dda4fb85SAurabindo Pillai CalculateVActiveBandwithSupport_val = (VActiveBandwith <= ReturnBW) && !NotEnoughUrgentLatencyHiding;
6143dda4fb85SAurabindo Pillai
6144dda4fb85SAurabindo Pillai #ifdef __DML_VBA_DEBUG__
6145dda4fb85SAurabindo Pillai dml_print("DML::%s: NotEnoughUrgentLatencyHiding = %d\n", __func__, NotEnoughUrgentLatencyHiding);
6146dda4fb85SAurabindo Pillai dml_print("DML::%s: VActiveBandwith = %f\n", __func__, VActiveBandwith);
6147dda4fb85SAurabindo Pillai dml_print("DML::%s: ReturnBW = %f\n", __func__, ReturnBW);
6148dda4fb85SAurabindo Pillai dml_print("DML::%s: CalculateVActiveBandwithSupport_val = %d\n", __func__, CalculateVActiveBandwithSupport_val);
6149dda4fb85SAurabindo Pillai #endif
6150dda4fb85SAurabindo Pillai return CalculateVActiveBandwithSupport_val;
6151dda4fb85SAurabindo Pillai }
6152dda4fb85SAurabindo Pillai
dml32_CalculatePrefetchBandwithSupport(unsigned int NumberOfActiveSurfaces,double ReturnBW,bool NotUrgentLatencyHiding[],double ReadBandwidthLuma[],double ReadBandwidthChroma[],double PrefetchBandwidthLuma[],double PrefetchBandwidthChroma[],double cursor_bw[],double meta_row_bandwidth[],double dpte_row_bandwidth[],double cursor_bw_pre[],double prefetch_vmrow_bw[],unsigned int NumberOfDPP[],double UrgentBurstFactorLuma[],double UrgentBurstFactorChroma[],double UrgentBurstFactorCursor[],double UrgentBurstFactorLumaPre[],double UrgentBurstFactorChromaPre[],double UrgentBurstFactorCursorPre[],double PrefetchBW[],double VRatio[],double MaxVRatioPre,double * MaxPrefetchBandwidth,double * FractionOfUrgentBandwidth,bool * PrefetchBandwidthSupport)6153dda4fb85SAurabindo Pillai void dml32_CalculatePrefetchBandwithSupport(unsigned int NumberOfActiveSurfaces,
6154dda4fb85SAurabindo Pillai double ReturnBW,
6155dda4fb85SAurabindo Pillai bool NotUrgentLatencyHiding[],
6156dda4fb85SAurabindo Pillai double ReadBandwidthLuma[],
6157dda4fb85SAurabindo Pillai double ReadBandwidthChroma[],
6158dda4fb85SAurabindo Pillai double PrefetchBandwidthLuma[],
6159dda4fb85SAurabindo Pillai double PrefetchBandwidthChroma[],
6160dda4fb85SAurabindo Pillai double cursor_bw[],
6161dda4fb85SAurabindo Pillai double meta_row_bandwidth[],
6162dda4fb85SAurabindo Pillai double dpte_row_bandwidth[],
6163dda4fb85SAurabindo Pillai double cursor_bw_pre[],
6164dda4fb85SAurabindo Pillai double prefetch_vmrow_bw[],
6165dda4fb85SAurabindo Pillai unsigned int NumberOfDPP[],
6166dda4fb85SAurabindo Pillai double UrgentBurstFactorLuma[],
6167dda4fb85SAurabindo Pillai double UrgentBurstFactorChroma[],
6168dda4fb85SAurabindo Pillai double UrgentBurstFactorCursor[],
6169dda4fb85SAurabindo Pillai double UrgentBurstFactorLumaPre[],
6170dda4fb85SAurabindo Pillai double UrgentBurstFactorChromaPre[],
6171dda4fb85SAurabindo Pillai double UrgentBurstFactorCursorPre[],
61723a615704SAlvin Lee double PrefetchBW[],
61733a615704SAlvin Lee double VRatio[],
61743a615704SAlvin Lee double MaxVRatioPre,
6175dda4fb85SAurabindo Pillai
6176dda4fb85SAurabindo Pillai /* output */
61773a615704SAlvin Lee double *MaxPrefetchBandwidth,
6178dda4fb85SAurabindo Pillai double *FractionOfUrgentBandwidth,
6179dda4fb85SAurabindo Pillai bool *PrefetchBandwidthSupport)
6180dda4fb85SAurabindo Pillai {
6181dda4fb85SAurabindo Pillai unsigned int k;
61827cd07d9dSAlvin Lee double ActiveBandwidthPerSurface;
6183dda4fb85SAurabindo Pillai bool NotEnoughUrgentLatencyHiding = false;
61847cd07d9dSAlvin Lee double TotalActiveBandwidth = 0;
61853a615704SAlvin Lee double TotalPrefetchBandwidth = 0;
61863a615704SAlvin Lee
6187dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
6188dda4fb85SAurabindo Pillai if (NotUrgentLatencyHiding[k]) {
6189dda4fb85SAurabindo Pillai NotEnoughUrgentLatencyHiding = true;
6190dda4fb85SAurabindo Pillai }
6191dda4fb85SAurabindo Pillai }
6192dda4fb85SAurabindo Pillai
61933a615704SAlvin Lee *MaxPrefetchBandwidth = 0;
6194dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
61957cd07d9dSAlvin Lee ActiveBandwidthPerSurface = ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k] + NumberOfDPP[k] * (meta_row_bandwidth[k] + dpte_row_bandwidth[k]);
61967cd07d9dSAlvin Lee
61977cd07d9dSAlvin Lee TotalActiveBandwidth += ActiveBandwidthPerSurface;
61987cd07d9dSAlvin Lee
61993a615704SAlvin Lee TotalPrefetchBandwidth = TotalPrefetchBandwidth + PrefetchBW[k] * VRatio[k];
62003a615704SAlvin Lee
62013a615704SAlvin Lee *MaxPrefetchBandwidth = *MaxPrefetchBandwidth + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k],
62027cd07d9dSAlvin Lee ActiveBandwidthPerSurface,
6203dda4fb85SAurabindo Pillai NumberOfDPP[k] * (PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k]) + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
6204dda4fb85SAurabindo Pillai }
6205dda4fb85SAurabindo Pillai
62063a615704SAlvin Lee if (MaxVRatioPre == __DML_MAX_VRATIO_PRE__)
62073a615704SAlvin Lee *PrefetchBandwidthSupport = (*MaxPrefetchBandwidth <= ReturnBW) && (TotalPrefetchBandwidth <= TotalActiveBandwidth * __DML_MAX_BW_RATIO_PRE__) && !NotEnoughUrgentLatencyHiding;
62083a615704SAlvin Lee else
62093a615704SAlvin Lee *PrefetchBandwidthSupport = (*MaxPrefetchBandwidth <= ReturnBW) && !NotEnoughUrgentLatencyHiding;
62103a615704SAlvin Lee
62113a615704SAlvin Lee *FractionOfUrgentBandwidth = *MaxPrefetchBandwidth / ReturnBW;
6212dda4fb85SAurabindo Pillai }
6213dda4fb85SAurabindo Pillai
dml32_CalculateBandwidthAvailableForImmediateFlip(unsigned int NumberOfActiveSurfaces,double ReturnBW,double ReadBandwidthLuma[],double ReadBandwidthChroma[],double PrefetchBandwidthLuma[],double PrefetchBandwidthChroma[],double cursor_bw[],double cursor_bw_pre[],unsigned int NumberOfDPP[],double UrgentBurstFactorLuma[],double UrgentBurstFactorChroma[],double UrgentBurstFactorCursor[],double UrgentBurstFactorLumaPre[],double UrgentBurstFactorChromaPre[],double UrgentBurstFactorCursorPre[])6214dda4fb85SAurabindo Pillai double dml32_CalculateBandwidthAvailableForImmediateFlip(unsigned int NumberOfActiveSurfaces,
6215dda4fb85SAurabindo Pillai double ReturnBW,
6216dda4fb85SAurabindo Pillai double ReadBandwidthLuma[],
6217dda4fb85SAurabindo Pillai double ReadBandwidthChroma[],
6218dda4fb85SAurabindo Pillai double PrefetchBandwidthLuma[],
6219dda4fb85SAurabindo Pillai double PrefetchBandwidthChroma[],
6220dda4fb85SAurabindo Pillai double cursor_bw[],
6221dda4fb85SAurabindo Pillai double cursor_bw_pre[],
6222dda4fb85SAurabindo Pillai unsigned int NumberOfDPP[],
6223dda4fb85SAurabindo Pillai double UrgentBurstFactorLuma[],
6224dda4fb85SAurabindo Pillai double UrgentBurstFactorChroma[],
6225dda4fb85SAurabindo Pillai double UrgentBurstFactorCursor[],
6226dda4fb85SAurabindo Pillai double UrgentBurstFactorLumaPre[],
6227dda4fb85SAurabindo Pillai double UrgentBurstFactorChromaPre[],
6228dda4fb85SAurabindo Pillai double UrgentBurstFactorCursorPre[])
6229dda4fb85SAurabindo Pillai {
6230dda4fb85SAurabindo Pillai unsigned int k;
6231dda4fb85SAurabindo Pillai double CalculateBandwidthAvailableForImmediateFlip_val = ReturnBW;
6232dda4fb85SAurabindo Pillai
6233dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
6234dda4fb85SAurabindo Pillai CalculateBandwidthAvailableForImmediateFlip_val = CalculateBandwidthAvailableForImmediateFlip_val - dml_max(ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k],
6235dda4fb85SAurabindo Pillai NumberOfDPP[k] * (PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k]) + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
6236dda4fb85SAurabindo Pillai }
6237dda4fb85SAurabindo Pillai
6238dda4fb85SAurabindo Pillai return CalculateBandwidthAvailableForImmediateFlip_val;
6239dda4fb85SAurabindo Pillai }
6240dda4fb85SAurabindo Pillai
dml32_CalculateImmediateFlipBandwithSupport(unsigned int NumberOfActiveSurfaces,double ReturnBW,enum immediate_flip_requirement ImmediateFlipRequirement[],double final_flip_bw[],double ReadBandwidthLuma[],double ReadBandwidthChroma[],double PrefetchBandwidthLuma[],double PrefetchBandwidthChroma[],double cursor_bw[],double meta_row_bandwidth[],double dpte_row_bandwidth[],double cursor_bw_pre[],double prefetch_vmrow_bw[],unsigned int NumberOfDPP[],double UrgentBurstFactorLuma[],double UrgentBurstFactorChroma[],double UrgentBurstFactorCursor[],double UrgentBurstFactorLumaPre[],double UrgentBurstFactorChromaPre[],double UrgentBurstFactorCursorPre[],double * TotalBandwidth,double * FractionOfUrgentBandwidth,bool * ImmediateFlipBandwidthSupport)6241dda4fb85SAurabindo Pillai void dml32_CalculateImmediateFlipBandwithSupport(unsigned int NumberOfActiveSurfaces,
6242dda4fb85SAurabindo Pillai double ReturnBW,
6243dda4fb85SAurabindo Pillai enum immediate_flip_requirement ImmediateFlipRequirement[],
6244dda4fb85SAurabindo Pillai double final_flip_bw[],
6245dda4fb85SAurabindo Pillai double ReadBandwidthLuma[],
6246dda4fb85SAurabindo Pillai double ReadBandwidthChroma[],
6247dda4fb85SAurabindo Pillai double PrefetchBandwidthLuma[],
6248dda4fb85SAurabindo Pillai double PrefetchBandwidthChroma[],
6249dda4fb85SAurabindo Pillai double cursor_bw[],
6250dda4fb85SAurabindo Pillai double meta_row_bandwidth[],
6251dda4fb85SAurabindo Pillai double dpte_row_bandwidth[],
6252dda4fb85SAurabindo Pillai double cursor_bw_pre[],
6253dda4fb85SAurabindo Pillai double prefetch_vmrow_bw[],
6254dda4fb85SAurabindo Pillai unsigned int NumberOfDPP[],
6255dda4fb85SAurabindo Pillai double UrgentBurstFactorLuma[],
6256dda4fb85SAurabindo Pillai double UrgentBurstFactorChroma[],
6257dda4fb85SAurabindo Pillai double UrgentBurstFactorCursor[],
6258dda4fb85SAurabindo Pillai double UrgentBurstFactorLumaPre[],
6259dda4fb85SAurabindo Pillai double UrgentBurstFactorChromaPre[],
6260dda4fb85SAurabindo Pillai double UrgentBurstFactorCursorPre[],
6261dda4fb85SAurabindo Pillai
6262dda4fb85SAurabindo Pillai /* output */
6263dda4fb85SAurabindo Pillai double *TotalBandwidth,
6264dda4fb85SAurabindo Pillai double *FractionOfUrgentBandwidth,
6265dda4fb85SAurabindo Pillai bool *ImmediateFlipBandwidthSupport)
6266dda4fb85SAurabindo Pillai {
6267dda4fb85SAurabindo Pillai unsigned int k;
6268dda4fb85SAurabindo Pillai *TotalBandwidth = 0;
6269dda4fb85SAurabindo Pillai for (k = 0; k < NumberOfActiveSurfaces; ++k) {
6270dda4fb85SAurabindo Pillai if (ImmediateFlipRequirement[k] != dm_immediate_flip_not_required) {
6271dda4fb85SAurabindo Pillai *TotalBandwidth = *TotalBandwidth + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k],
6272dda4fb85SAurabindo Pillai NumberOfDPP[k] * final_flip_bw[k] + ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k],
6273dda4fb85SAurabindo Pillai NumberOfDPP[k] * (final_flip_bw[k] + PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k]) + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
6274dda4fb85SAurabindo Pillai } else {
6275dda4fb85SAurabindo Pillai *TotalBandwidth = *TotalBandwidth + dml_max3(NumberOfDPP[k] * prefetch_vmrow_bw[k],
6276dda4fb85SAurabindo Pillai NumberOfDPP[k] * (meta_row_bandwidth[k] + dpte_row_bandwidth[k]) + ReadBandwidthLuma[k] * UrgentBurstFactorLuma[k] + ReadBandwidthChroma[k] * UrgentBurstFactorChroma[k] + cursor_bw[k] * UrgentBurstFactorCursor[k],
6277dda4fb85SAurabindo Pillai NumberOfDPP[k] * (PrefetchBandwidthLuma[k] * UrgentBurstFactorLumaPre[k] + PrefetchBandwidthChroma[k] * UrgentBurstFactorChromaPre[k]) + cursor_bw_pre[k] * UrgentBurstFactorCursorPre[k]);
6278dda4fb85SAurabindo Pillai }
6279dda4fb85SAurabindo Pillai }
6280dda4fb85SAurabindo Pillai *ImmediateFlipBandwidthSupport = (*TotalBandwidth <= ReturnBW);
6281dda4fb85SAurabindo Pillai *FractionOfUrgentBandwidth = *TotalBandwidth / ReturnBW;
6282dda4fb85SAurabindo Pillai }
62836d4727c8SDillon Varone
dml32_CalculateDETSwathFillLatencyHiding(unsigned int NumberOfActiveSurfaces,double ReturnBW,double UrgentLatency,unsigned int SwathHeightY[],unsigned int SwathHeightC[],unsigned int SwathWidthY[],unsigned int SwathWidthC[],double BytePerPixelInDETY[],double BytePerPixelInDETC[],unsigned int DETBufferSizeY[],unsigned int DETBufferSizeC[],unsigned int NumOfDPP[],unsigned int HTotal[],double PixelClock[],double VRatioY[],double VRatioC[],enum dm_use_mall_for_pstate_change_mode UsesMALLForPStateChange[],enum unbounded_requesting_policy UseUnboundedRequesting)62846d4727c8SDillon Varone bool dml32_CalculateDETSwathFillLatencyHiding(unsigned int NumberOfActiveSurfaces,
62856d4727c8SDillon Varone double ReturnBW,
62866d4727c8SDillon Varone double UrgentLatency,
62876d4727c8SDillon Varone unsigned int SwathHeightY[],
62886d4727c8SDillon Varone unsigned int SwathHeightC[],
62896d4727c8SDillon Varone unsigned int SwathWidthY[],
62906d4727c8SDillon Varone unsigned int SwathWidthC[],
62916d4727c8SDillon Varone double BytePerPixelInDETY[],
62926d4727c8SDillon Varone double BytePerPixelInDETC[],
62936d4727c8SDillon Varone unsigned int DETBufferSizeY[],
62946d4727c8SDillon Varone unsigned int DETBufferSizeC[],
62956d4727c8SDillon Varone unsigned int NumOfDPP[],
62966d4727c8SDillon Varone unsigned int HTotal[],
62976d4727c8SDillon Varone double PixelClock[],
62986d4727c8SDillon Varone double VRatioY[],
62996d4727c8SDillon Varone double VRatioC[],
6300de930140SAlvin Lee enum dm_use_mall_for_pstate_change_mode UsesMALLForPStateChange[],
6301de930140SAlvin Lee enum unbounded_requesting_policy UseUnboundedRequesting)
63026d4727c8SDillon Varone {
63036d4727c8SDillon Varone int k;
63046d4727c8SDillon Varone double SwathSizeAllSurfaces = 0;
63056d4727c8SDillon Varone double SwathSizeAllSurfacesInFetchTimeUs;
63066d4727c8SDillon Varone double DETSwathLatencyHidingUs;
63076d4727c8SDillon Varone double DETSwathLatencyHidingYUs;
63086d4727c8SDillon Varone double DETSwathLatencyHidingCUs;
63096d4727c8SDillon Varone double SwathSizePerSurfaceY[DC__NUM_DPP__MAX];
63106d4727c8SDillon Varone double SwathSizePerSurfaceC[DC__NUM_DPP__MAX];
63116d4727c8SDillon Varone bool NotEnoughDETSwathFillLatencyHiding = false;
63126d4727c8SDillon Varone
6313de930140SAlvin Lee if (UseUnboundedRequesting == dm_unbounded_requesting)
6314de930140SAlvin Lee return false;
6315de930140SAlvin Lee
63166d4727c8SDillon Varone /* calculate sum of single swath size for all pipes in bytes */
63176d4727c8SDillon Varone for (k = 0; k < NumberOfActiveSurfaces; k++) {
6318878a3c00SSamson Tam SwathSizePerSurfaceY[k] = SwathHeightY[k] * SwathWidthY[k] * BytePerPixelInDETY[k] * NumOfDPP[k];
63196d4727c8SDillon Varone
63206d4727c8SDillon Varone if (SwathHeightC[k] != 0)
6321878a3c00SSamson Tam SwathSizePerSurfaceC[k] = SwathHeightC[k] * SwathWidthC[k] * BytePerPixelInDETC[k] * NumOfDPP[k];
63226d4727c8SDillon Varone else
63236d4727c8SDillon Varone SwathSizePerSurfaceC[k] = 0;
63246d4727c8SDillon Varone
63256d4727c8SDillon Varone SwathSizeAllSurfaces += SwathSizePerSurfaceY[k] + SwathSizePerSurfaceC[k];
63266d4727c8SDillon Varone }
63276d4727c8SDillon Varone
63286d4727c8SDillon Varone SwathSizeAllSurfacesInFetchTimeUs = SwathSizeAllSurfaces / ReturnBW + UrgentLatency;
63296d4727c8SDillon Varone
63306d4727c8SDillon Varone /* ensure all DET - 1 swath can hide a fetch for all surfaces */
63316d4727c8SDillon Varone for (k = 0; k < NumberOfActiveSurfaces; k++) {
63326d4727c8SDillon Varone double LineTime = HTotal[k] / PixelClock[k];
63336d4727c8SDillon Varone
63346d4727c8SDillon Varone /* only care if surface is not phantom */
63356d4727c8SDillon Varone if (UsesMALLForPStateChange[k] != dm_use_mall_pstate_change_phantom_pipe) {
63366d4727c8SDillon Varone DETSwathLatencyHidingYUs = (dml_floor(DETBufferSizeY[k] / BytePerPixelInDETY[k] / SwathWidthY[k], 1.0) - SwathHeightY[k]) / VRatioY[k] * LineTime;
63376d4727c8SDillon Varone
63386d4727c8SDillon Varone if (SwathHeightC[k] != 0) {
63396d4727c8SDillon Varone DETSwathLatencyHidingCUs = (dml_floor(DETBufferSizeC[k] / BytePerPixelInDETC[k] / SwathWidthC[k], 1.0) - SwathHeightC[k]) / VRatioC[k] * LineTime;
63406d4727c8SDillon Varone
63416d4727c8SDillon Varone DETSwathLatencyHidingUs = dml_min(DETSwathLatencyHidingYUs, DETSwathLatencyHidingCUs);
63426d4727c8SDillon Varone } else {
63436d4727c8SDillon Varone DETSwathLatencyHidingUs = DETSwathLatencyHidingYUs;
63446d4727c8SDillon Varone }
63456d4727c8SDillon Varone
63466d4727c8SDillon Varone /* DET must be able to hide time to fetch 1 swath for each surface */
63476d4727c8SDillon Varone if (DETSwathLatencyHidingUs < SwathSizeAllSurfacesInFetchTimeUs) {
63486d4727c8SDillon Varone NotEnoughDETSwathFillLatencyHiding = true;
63496d4727c8SDillon Varone break;
63506d4727c8SDillon Varone }
63516d4727c8SDillon Varone }
63526d4727c8SDillon Varone }
63536d4727c8SDillon Varone
63546d4727c8SDillon Varone return NotEnoughDETSwathFillLatencyHiding;
63556d4727c8SDillon Varone }
6356