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