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