1 /*==============================================================================
2 Copyright(c) 2017 Intel Corporation
3
4 Permission is hereby granted, free of charge, to any person obtaining a
5 copy of this software and associated documentation files(the "Software"),
6 to deal in the Software without restriction, including without limitation
7 the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 and / or sell copies of the Software, and to permit persons to whom the
9 Software is furnished to do so, subject to the following conditions:
10
11 The above copyright notice and this permission notice shall be included
12 in all copies or substantial portions of the Software.
13
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 OTHER DEALINGS IN THE SOFTWARE.
21 ============================================================================*/
22
23
24 #include "Internal/Common/GmmLibInc.h"
25
26 /////////////////////////////////////////////////////////////////////////////////////
27 /// Copies parameters or sets flags based on info sent by the client.
28 ///
29 /// @param[in] CreateParams: Flags which specify what sort of resource to create
30 /// @return false if encountered invalid param. true otherwise.
31 /////////////////////////////////////////////////////////////////////////////////////
CopyClientParams(GMM_RESCREATE_PARAMS & CreateParams)32 bool GmmLib::GmmResourceInfoCommon::CopyClientParams(GMM_RESCREATE_PARAMS &CreateParams)
33 {
34 uint32_t BitsPerPixel;
35 uint8_t Optimize64KBTile = 0;
36
37 if((CreateParams.Format > GMM_FORMAT_INVALID) &&
38 (CreateParams.Format < GMM_RESOURCE_FORMATS))
39 {
40 BitsPerPixel = GetGmmLibContext()->GetPlatformInfo().FormatTable[CreateParams.Format].Element.BitsPer;
41 }
42 else
43 {
44 GMM_ASSERTDPF(0, "Format Error");
45 return false;
46 }
47 {
48 // Promote tiling options if caller does not provide any.
49 // X/Y/W/L are tiling formats, and Yf/Ys are modifiers to the internal
50 // ordering for Y and L macro-formats.
51 if((CreateParams.Flags.Info.Linear +
52 CreateParams.Flags.Info.TiledW +
53 CreateParams.Flags.Info.TiledX +
54 CreateParams.Flags.Info.TiledY) == 0)
55 {
56 if(CreateParams.Type == RESOURCE_1D ||
57 CreateParams.Type == RESOURCE_BUFFER ||
58 CreateParams.Type == RESOURCE_SCRATCH ||
59 CreateParams.Flags.Info.ExistingSysMem)
60 {
61 CreateParams.Flags.Info.Linear = true;
62 }
63
64 if(GetGmmLibContext()->GetSkuTable().FtrTileY)
65 {
66
67 CreateParams.Flags.Info.TiledYs |= CreateParams.Flags.Info.StdSwizzle || CreateParams.Flags.Gpu.TiledResource;
68
69 // Propose L+Y by default.
70 CreateParams.Flags.Info.Linear = true;
71 CreateParams.Flags.Info.TiledY = true;
72
73 // Pre-Gen11 Planar
74 if(GmmIsPlanar(CreateParams.Format) && (GFX_GET_CURRENT_RENDERCORE(GetGmmLibContext()->GetPlatformInfo().Platform) < IGFX_GEN11_CORE))
75 {
76 CreateParams.Flags.Info.TiledX = true;
77 }
78 }
79 //Auto-tiling selection if not Linear already
80 else if(CreateParams.Flags.Info.Linear == 0)
81 {
82 // Xe_HP onwards.
83 if((CreateParams.Flags.Info.TiledYs +
84 CreateParams.Flags.Info.TiledYf +
85 CreateParams.Flags.Info.Tile4 +
86 CreateParams.Flags.Info.Tile64) == 0)
87 {
88 GMM_ASSERTDPF(!CreateParams.Flags.Info.StdSwizzle, "StdSwizzle not supported on current platform");
89
90 if(!GetGmmLibContext()->GetWaTable().WaDefaultTile4)
91 {
92 // Default Tiling is set to Tile64 on FtrTileY disabled platforms
93 uint8_t IsYUVSurface = ((GmmIsPlanar(CreateParams.Format) &&
94 (!((CreateParams.Format == GMM_FORMAT_BGRP) || (CreateParams.Format == GMM_FORMAT_RGBP)))) ||
95 (GmmIsYUVPacked(CreateParams.Format) &&
96 !((CreateParams.Format == GMM_FORMAT_YVYU_2x1) || (CreateParams.Format == GMM_FORMAT_UYVY_2x1) || (CreateParams.Format == GMM_FORMAT_UYVY_2x1))));
97
98 CreateParams.Flags.Info.Tile4 = ((!GMM_IS_SUPPORTED_BPP_ON_TILE_64_YF_YS(BitsPerPixel)) || // 24,48,96 bpps are not supported on Tile64, Tile4 is bpp independent
99 ((CreateParams.Type == RESOURCE_3D) && (CreateParams.Flags.Gpu.Depth || CreateParams.Flags.Gpu.SeparateStencil)) ||
100 ((!GetGmmLibContext()->GetSkuTable().FtrDisplayDisabled) &&
101 (CreateParams.Flags.Gpu.FlipChain || CreateParams.Flags.Gpu.Overlay)
102 ) ||
103 IsYUVSurface);
104
105 CreateParams.Flags.Info.Tile64 = !CreateParams.Flags.Info.Tile4;
106 // Optimize only when GMM makes tiling decision on behalf of UMD clients.
107 // Defering the memory calculations until GMM_TEXTURE_INFO is available.
108 if(CreateParams.Flags.Info.Tile64)
109 {
110 Optimize64KBTile = 1;
111 }
112 }
113 else
114 {
115 CreateParams.Flags.Info.Tile64 = (CreateParams.MSAA.NumSamples > 1) || CreateParams.Flags.Gpu.TiledResource; // Colour & Depth/Stencil(IMS) MSAA should use Tile64
116 CreateParams.Flags.Info.Tile4 = !CreateParams.Flags.Info.Tile64;
117 }
118 }
119 else if((CreateParams.Flags.Info.TiledYs +
120 CreateParams.Flags.Info.TiledYf) > 0)
121 {
122 GMM_ASSERTDPF(0, "Tile Yf/Ys not supported on given platform");
123
124 // Overrides the flags.
125 if(GetGmmLibContext()->GetWaTable().WaDefaultTile4)
126 {
127 CreateParams.Flags.Info.Tile64 = CreateParams.Flags.Info.TiledYs ||
128 (CreateParams.MSAA.NumSamples > 1) || CreateParams.Flags.Gpu.TiledResource; // Colour & Depth/Stencil(IMS) MSAA should use Tile64
129
130 CreateParams.Flags.Info.Tile4 = !CreateParams.Flags.Info.Tile64;
131 CreateParams.Flags.Info.TiledYf = 0;
132 CreateParams.Flags.Info.TiledYs = 0;
133 }
134 }
135 }
136 }
137 //Convert non linear & non-tiledX tiling selection by client to proper tiling.
138 else if(CreateParams.Flags.Info.Linear + CreateParams.Flags.Info.TiledX == 0)
139 {
140 if(!GetGmmLibContext()->GetSkuTable().FtrTileY)
141 {
142 __GMM_ASSERT(!(CreateParams.Flags.Info.TiledYs ||
143 CreateParams.Flags.Info.TiledYf ||
144 CreateParams.Flags.Info.TiledY));
145
146 // On Xe_HP onwards translate UMD's TileY/TileYs request to Tile4/Tile64 respectively
147 // Exclude TileX, Linear from override
148 if(GetGmmLibContext()->GetWaTable().WaDefaultTile4 && (CreateParams.Flags.Info.TiledYs ||
149 CreateParams.Flags.Info.TiledY))
150 {
151 CreateParams.Flags.Info.Tile64 =
152 CreateParams.Flags.Info.TiledYs ||
153 (CreateParams.MSAA.NumSamples > 1) || CreateParams.Flags.Gpu.TiledResource;
154
155 CreateParams.Flags.Info.Tile4 = !CreateParams.Flags.Info.Tile64;
156
157 CreateParams.Flags.Info.TiledY = 0;
158 CreateParams.Flags.Info.TiledYs = 0;
159 CreateParams.Flags.Info.TiledW = 0;
160 CreateParams.Flags.Info.TiledYf = 0;
161 }
162
163 // Displayable surfaces cannot be Tiled4/64.
164 __GMM_ASSERT(!GetGmmLibContext()->GetSkuTable().FtrDisplayYTiling);
165
166 //override displayable surfaces to TileX
167 if(GetGmmLibContext()->GetSkuTable().FtrDisplayXTiling)
168 {
169 if(CreateParams.Flags.Gpu.FlipChain || CreateParams.Flags.Gpu.Overlay ||
170 CreateParams.Flags.Gpu.Presentable)
171 {
172 CreateParams.Flags.Info.TiledX = 1;
173 CreateParams.Flags.Info.TiledY = 0;
174 CreateParams.Flags.Info.Tile4 = 0;
175 CreateParams.Flags.Info.Tile64 = 0;
176 }
177 }
178 }
179 }
180
181 //ExistingSysMem allocations must be Linear
182 __GMM_ASSERT(!CreateParams.Flags.Info.ExistingSysMem ||
183 CreateParams.Flags.Info.Linear);
184 }
185
186 if(GetGmmLibContext()->GetSkuTable().FtrMultiTileArch)
187 {
188 // For Naive apps, UMD does not populate multi tile arch params.
189 // Gmm will populate them based on the kmd assigned tile to the umd process
190 if(!CreateParams.MultiTileArch.Enable)
191 {
192 uint32_t GpuTile = 0;
193 __GMM_ASSERT(CreateParams.MultiTileArch.GpuVaMappingSet == 0);
194 __GMM_ASSERT(CreateParams.MultiTileArch.LocalMemEligibilitySet == 0);
195 __GMM_ASSERT(CreateParams.MultiTileArch.LocalMemPreferredSet == 0);
196
197 __GMM_ASSERT(GetGmmLibContext()->GetSkuTable().FtrAssignedGpuTile < 4);
198
199 #if !__GMM_KMD__
200 GpuTile = GetGmmLibContext()->GetSkuTable().FtrAssignedGpuTile;
201 CreateParams.MultiTileArch.GpuVaMappingSet = __BIT(GpuTile);
202 #else
203 GpuTile = 0;
204 CreateParams.MultiTileArch.GpuVaMappingSet = GetGmmLibContext()->GetGtSysInfo()->MultiTileArchInfo.TileMask;
205 #endif
206
207 CreateParams.MultiTileArch.Enable = true;
208
209 if(!CreateParams.Flags.Info.NonLocalOnly)
210 {
211 CreateParams.MultiTileArch.LocalMemEligibilitySet = __BIT(GpuTile);
212 CreateParams.MultiTileArch.LocalMemPreferredSet = __BIT(GpuTile);
213 }
214 }
215 }
216
217 Surf.Type = CreateParams.Type;
218 Surf.Format = CreateParams.Format;
219 Surf.BaseWidth = CreateParams.BaseWidth64;
220 Surf.BaseHeight = CreateParams.BaseHeight;
221 Surf.Depth = CreateParams.Depth;
222 Surf.MaxLod = CreateParams.MaxLod;
223 Surf.ArraySize = CreateParams.ArraySize;
224 Surf.Flags = CreateParams.Flags;
225 Surf.MSAA = CreateParams.MSAA;
226 Surf.Alignment.BaseAlignment = CreateParams.BaseAlignment;
227 Surf.CachePolicy.Usage = CreateParams.Usage;
228 Surf.MSAA.NumSamples = GFX_MAX(Surf.MSAA.NumSamples, 1);
229 Surf.MaximumRenamingListLength = CreateParams.MaximumRenamingListLength;
230 Surf.OverridePitch = CreateParams.OverridePitch;
231 Surf.CpTag = CreateParams.CpTag;
232
233 Surf.Flags.Info.__PreWddm2SVM =
234 Surf.Flags.Info.SVM &&
235 !(GetGmmLibContext()->GetSkuTable().FtrWddm2GpuMmu ||
236 GetGmmLibContext()->GetSkuTable().FtrWddm2Svm);
237
238 #if !__GMM_KMD__ && LHDM
239 if(GetGmmLibContext()->GetWaTable().WaLLCCachingUnsupported)
240 {
241 Surf.Flags.Info.GttMapType = (CreateParams.Flags.Info.Cacheable) ?
242 GMM_GTT_CACHETYPE_VLV_SNOOPED :
243 GMM_GTT_CACHETYPE_UNCACHED;
244 }
245
246 if(GetGmmLibContext()->GetSkuTable().FtrCameraCaptureCaching == FALSE &&
247 CreateParams.Flags.Gpu.CameraCapture)
248 {
249 Surf.Flags.Info.Cacheable = 0;
250 }
251 Surf.Flags.Wa.ForceStdAllocAlign = 0;
252 #endif
253
254 #if(_DEBUG || _RELEASE_INTERNAL)
255 Surf.Platform = GetGmmLibContext()->GetPlatformInfo().Platform;
256 #endif
257
258 Surf.BitsPerPixel = BitsPerPixel;
259
260 // Get pTextureCalc after surface evaluation
261 GMM_TEXTURE_CALC *pTextureCalc = GMM_OVERRIDE_TEXTURE_CALC(&Surf, GetGmmLibContext());
262
263 GetGmmLibContext()->GetPlatformInfoObj()->SetCCSFlag(this->GetResFlags());
264
265 // Moderate down displayable flags if input parameters are not conducive.
266 // Reject non displayable tiling modes
267 if(Surf.Flags.Gpu.FlipChain || Surf.Flags.Gpu.Overlay)
268 {
269 if(Surf.Flags.Info.TiledY && !GetGmmLibContext()->GetSkuTable().FtrDisplayYTiling)
270 {
271 if(Surf.Flags.Gpu.FlipChainPreferred)
272 {
273 Surf.Flags.Gpu.Overlay = 0;
274 Surf.Flags.Gpu.FlipChain = 0;
275 }
276 else
277 {
278 GMM_ASSERTDPF(0, "Y-Tiling mode not displayable");
279 //return false;
280 }
281 }
282 }
283
284 // Memory optimization for 64KB tiled Surface.
285 if(GetGmmLibContext()->GetWaTable().WaTile64Optimization && Optimize64KBTile)
286 {
287 if(pTextureCalc->SurfaceRequires64KBTileOptimization(&Surf))
288 {
289 GMM_SET_64KB_TILE(Surf.Flags, 0, GetGmmLibContext());
290 GMM_SET_4KB_TILE(Surf.Flags, 1, GetGmmLibContext());
291 }
292 }
293
294 // Convert Any Pseudo Creation Params to Actual...
295 if(Surf.Flags.Gpu.UnifiedAuxSurface)
296 {
297 AuxSurf = Surf;
298
299 if(Surf.Flags.Gpu.Depth && Surf.Flags.Gpu.CCS) //Depth + HiZ+CCS
300 {
301 //GMM_ASSERTDPF(Surf.Flags.Gpu.HiZ, "Lossless Z compression supported when Depth+HiZ+CCS is unified");
302 AuxSecSurf = Surf;
303 AuxSecSurf.Type = GetGmmLibContext()->GetSkuTable().FtrFlatPhysCCS ? RESOURCE_INVALID : AuxSecSurf.Type;
304 Surf.Flags.Gpu.HiZ = 0; //Its depth buffer, so clear HiZ
305 AuxSecSurf.Flags.Gpu.HiZ = 0;
306 AuxSurf.Flags.Gpu.IndirectClearColor = 0; //Clear Depth flags from HiZ, contained with separate/legacy HiZ when Depth isn't compressible.
307 AuxSurf.Flags.Gpu.CCS = 0;
308 AuxSurf.Type = (AuxSurf.Flags.Gpu.HiZ) ? AuxSurf.Type : RESOURCE_INVALID;
309 AuxSurf.Flags.Info.RenderCompressed = AuxSurf.Flags.Info.MediaCompressed = 0;
310 }
311 else if(Surf.Flags.Gpu.SeparateStencil && Surf.Flags.Gpu.CCS) //Stencil compression
312 {
313 AuxSurf.Flags.Gpu.SeparateStencil = 0;
314 Surf.Flags.Gpu.CCS = 0;
315 if(GMM_SUCCESS != pTextureCalc->PreProcessTexSpecialCases(&Surf))
316 {
317 return false;
318 }
319 Surf.Flags.Gpu.CCS = 1;
320 AuxSurf.Type = GetGmmLibContext()->GetSkuTable().FtrFlatPhysCCS ? RESOURCE_INVALID : AuxSurf.Type;
321 }
322 else if(Surf.MSAA.NumSamples > 1 && Surf.Flags.Gpu.CCS) //MSAA+MCS+CCS
323 {
324 GMM_ASSERTDPF(Surf.Flags.Gpu.MCS, "Lossless MSAA supported when MSAA+MCS+CCS is unified");
325 AuxSecSurf = Surf;
326 AuxSecSurf.Type = GetGmmLibContext()->GetSkuTable().FtrFlatPhysCCS ? RESOURCE_INVALID : AuxSecSurf.Type;
327 AuxSecSurf.Flags.Gpu.MCS = 0;
328 AuxSurf.Flags.Gpu.CCS = 0;
329 AuxSurf.Flags.Info.RenderCompressed = AuxSurf.Flags.Info.MediaCompressed = 0;
330 }
331 else if(Surf.Flags.Gpu.CCS)
332 {
333 AuxSurf.Type = (GetGmmLibContext()->GetSkuTable().FtrFlatPhysCCS && !Surf.Flags.Gpu.ProceduralTexture) ? RESOURCE_INVALID : AuxSurf.Type;
334 }
335
336 if(AuxSurf.Type != RESOURCE_INVALID &&
337 GMM_SUCCESS != pTextureCalc->PreProcessTexSpecialCases(&AuxSurf))
338 {
339 return false;
340 }
341 if(AuxSecSurf.Type != RESOURCE_INVALID &&
342 GMM_SUCCESS != pTextureCalc->PreProcessTexSpecialCases(&AuxSecSurf))
343 {
344 return false;
345 }
346 }
347 else
348 {
349 if(GMM_SUCCESS != pTextureCalc->PreProcessTexSpecialCases(&Surf))
350 {
351 return false;
352 }
353 }
354
355 RotateInfo = CreateParams.RotateInfo;
356
357 if(GetGmmLibContext()->GetSkuTable().FtrMultiTileArch)
358 {
359 MultiTileArch = CreateParams.MultiTileArch;
360 }
361
362 return true;
363 }
364
365
366 /////////////////////////////////////////////////////////////////////////////////////
367 /// Validates the parameters passed in by clients to make sure they do not
368 /// conflict or ask for unsupporting combinations/features.
369 ///
370 /// @return 1 is validation passed. 0 otherwise.
371 /////////////////////////////////////////////////////////////////////////////////////
ValidateParams()372 uint8_t GMM_STDCALL GmmLib::GmmResourceInfoCommon::ValidateParams()
373 {
374 __GMM_BUFFER_TYPE Restrictions = {0};
375 const __GMM_PLATFORM_RESOURCE *pPlatformResource = NULL;
376 GMM_TEXTURE_CALC * pTextureCalc = NULL;
377 bool AllowMaxWidthViolations = false;
378 bool AllowMaxHeightViolations = false;
379 uint8_t Status = 0;
380
381 GMM_DPF_ENTER;
382
383 __GMM_ASSERTPTR(GetGmmLibContext(), 0);
384
385 #if(defined(__GMM_KMD__) && (_DEBUG || _RELEASE_INTERNAL))
386 //KMD Debug and Release Internal Drivers only
387 //if GMM_TEXTURE_INFO's platform type != native platform
388 //then initialize the OverridePlatformInfo.
389
390 //If GMM_TEXTURE_INFO's platform type == IGFX_UNKNOWN_CORE then it means that UMD driver is
391 //in "Release" version and passes all zeros in Surf.Platform
392 if(GFX_GET_CURRENT_RENDERCORE(Surf.Platform) == IGFX_UNKNOWN_CORE)
393 {
394 Surf.Platform = GetGmmLibContext()->GetPlatformInfo().Platform;
395 // If this is a unified surface then make sure the AUX surface has the same platform info
396 if(Surf.Flags.Gpu.UnifiedAuxSurface)
397 {
398 AuxSurf.Platform = Surf.Platform;
399 AuxSecSurf.Platform = Surf.Platform;
400 }
401 }
402
403 if(GetGmmLibContext()->GetPlatformInfoObj() != NULL &&
404 (GFX_GET_CURRENT_RENDERCORE(Surf.Platform) !=
405 GFX_GET_CURRENT_RENDERCORE(GetGmmLibContext()->GetPlatformInfo().Platform)) &&
406 (GetGmmLibContext()->GetOverridePlatformInfoObj() == NULL ||
407 (GFX_GET_CURRENT_RENDERCORE(Surf.Platform) !=
408 GFX_GET_CURRENT_RENDERCORE(GetGmmLibContext()->GetOverridePlatformInfo().Platform))))
409 {
410 //Ensure override is a future platform.
411 __GMM_ASSERT(GFX_GET_CURRENT_RENDERCORE(Surf.Platform) >
412 GFX_GET_CURRENT_RENDERCORE(GetGmmLibContext()->GetPlatformInfo().Platform));
413
414 GetGmmLibContext()->SetOverridePlatformInfoObj(GetGmmLibContext()->CreatePlatformInfo(Surf.Platform, true));
415
416 if(GetGmmLibContext()->GetOverrideTextureCalc())
417 {
418 delete(GetGmmLibContext()->GetOverrideTextureCalc());
419 GetGmmLibContext()->SetOverrideTextureCalc(NULL);
420 }
421
422 GetGmmLibContext()->SetOverrideTextureCalc(GetGmmLibContext()->CreateTextureCalc(Surf.Platform, true));
423
424 }
425 #endif
426
427 pPlatformResource = GMM_OVERRIDE_PLATFORM_INFO(&Surf, GetGmmLibContext());
428 pTextureCalc = GMM_OVERRIDE_TEXTURE_CALC(&Surf, GetGmmLibContext());
429
430 __GMM_ASSERT(!(
431 Surf.Flags.Gpu.Query &&
432 !Surf.Flags.Info.Cacheable)); // Why query not set as cacheable? If not cacheable, what keeps from stolen memory (because STORE_DWORD/PIPE_CONTROL/etc. targets can't be in stolen)?
433
434 if(Surf.Flags.Gpu.HiZ)
435 {
436 // HiZ checked in PreProcessTexSpecialCases before legal HZ_Width/Height expansion.
437 AllowMaxWidthViolations = true;
438 AllowMaxHeightViolations = true;
439 }
440
441 // check bpp
442 if(((Surf.BitsPerPixel < 8) || (Surf.BitsPerPixel % GMM_BITS(8))) &&
443 !(Surf.BitsPerPixel == 1))
444 {
445 GMM_ASSERTDPF(0, "Invalid BitsPerPixel!");
446 goto ERROR_CASE;
447 }
448
449 // Check at least one tile pref set.
450 // Yf/Ys checked explicitly here, require one of Y or Linear depending on resource type (e.g 1D-->Linear)
451 // that TODO: could be automatically promoted.
452 if((Surf.Flags.Info.Linear == 0) &&
453 (Surf.Flags.Info.TiledX == 0) &&
454 (Surf.Flags.Info.TiledW == 0) &&
455 (Surf.Flags.Info.TiledYf == 0) &&
456 !GMM_IS_4KB_TILE(Surf.Flags) && !GMM_IS_64KB_TILE(Surf.Flags))
457 {
458 GMM_ASSERTDPF(0, "No Tile or Linear preference specified!");
459 goto ERROR_CASE;
460 }
461
462 if(Surf.Flags.Info.Tile64 || Surf.Flags.Info.TiledYf || Surf.Flags.Info.TiledYs)
463 {
464 if(!GMM_IS_SUPPORTED_BPP_ON_TILE_64_YF_YS(Surf.BitsPerPixel))
465 {
466 GMM_ASSERTDPF(0, "BPP not supported on selected Tile format!");
467 goto ERROR_CASE;
468 }
469 }
470
471 if(!__CanSupportStdTiling(Surf, GetGmmLibContext()))
472 {
473 GMM_ASSERTDPF(0, "Invalid TileYf/TileYs usage!");
474 goto ERROR_CASE;
475 }
476
477 if(Surf.TileMode < TILE_NONE || Surf.TileMode >= GMM_TILE_MODES)
478 {
479 GMM_ASSERTDPF(0, "Invalid TileMode usage!");
480 goto ERROR_CASE;
481 }
482
483 if(!((Surf.Format > GMM_FORMAT_INVALID) &&
484 (Surf.Format < GMM_RESOURCE_FORMATS)))
485 {
486 GMM_ASSERTDPF(0, "Invalid Resource Format!");
487 goto ERROR_CASE;
488 }
489
490 // Check resource format is supported on running platform
491 if(IsPresentableformat() == false)
492 {
493 GMM_ASSERTDPF(0, "Bad Format!");
494 goto ERROR_CASE;
495 }
496
497 if((Surf.Type == RESOURCE_PRIMARY) &&
498 !Surf.Flags.Gpu.FlipChain)
499 {
500 GMM_ASSERTDPF(0, "Primary does not have FlipChain flag set.");
501 goto ERROR_CASE;
502 }
503
504 if(Surf.Flags.Gpu.Overlay &&
505 Surf.Flags.Gpu.FlipChain)
506 {
507 GMM_ASSERTDPF(0, "Overlay and FlipChain flags set. S3D logic may fail.");
508 goto ERROR_CASE;
509 }
510
511 // Displayable surfaces must remain Tile4
512 if(((!GetGmmLibContext()->GetSkuTable().FtrDisplayDisabled) &&
513 (Surf.Flags.Gpu.Overlay || Surf.Flags.Gpu.FlipChain)) &&
514 (!(Surf.Flags.Info.Linear || Surf.Flags.Info.TiledX || GMM_IS_4KB_TILE(Surf.Flags))))
515 {
516 GMM_ASSERTDPF(0, "Unsupported tiling format for displayable resource.");
517 goto ERROR_CASE;
518 }
519
520 if(GetGmmLibContext()->GetSkuTable().FtrLocalMemory)
521 {
522 GMM_ASSERTDPF(((Surf.Flags.Info.NonLocalOnly && Surf.Flags.Info.LocalOnly) == 0),
523 "Incorrect segment preference, cannot be both local and system memory.");
524
525 // Before overriding the flags predetermine if compression request is deniable or not.
526 if(!Surf.Flags.Info.LocalOnly &&
527 (!(Surf.Flags.Gpu.Overlay || Surf.Flags.Gpu.FlipChain)) &&
528 !(Surf.Flags.Info.HardwareProtected))
529 {
530 Surf.Flags.Wa.DeniableLocalOnlyForCompression = 1;
531 }
532
533 if(Surf.Flags.Gpu.Overlay ||
534 Surf.Flags.Gpu.FlipChain)
535 {
536 if(Surf.Flags.Info.NonLocalOnly)
537 {
538 GMM_ASSERTDPF(0, "Overlay and FlipChain cannot be in system memory.");
539 goto ERROR_CASE;
540 }
541 Surf.Flags.Info.LocalOnly = 1;
542 Surf.Flags.Info.NonLocalOnly = 0;
543 }
544 if(GetGmmLibContext()->GetSkuTable().FtrFlatPhysCCS &&
545 (Surf.Flags.Info.RenderCompressed ||
546 Surf.Flags.Info.MediaCompressed))
547 {
548 if(Surf.Flags.Info.NonLocalOnly)
549 {
550 GMM_ASSERTDPF(0, "Compressible surfaces cannot be in system memory.");
551 goto ERROR_CASE;
552 }
553 Surf.Flags.Info.LocalOnly = 1;
554 Surf.Flags.Info.NonLocalOnly = 0;
555 }
556
557 if(!Surf.Flags.Info.NotLockable &&
558 Surf.Flags.Info.Shared)
559 {
560 if(Surf.Flags.Info.LocalOnly)
561 {
562 GMM_ASSERTDPF(0, "Lockable Shared cannot be in local memory.");
563 goto ERROR_CASE;
564 }
565 Surf.Flags.Info.LocalOnly = 0;
566 Surf.Flags.Info.NonLocalOnly = 1;
567 }
568
569 if(Surf.Flags.Gpu.CameraCapture)
570 {
571 if(Surf.Flags.Info.LocalOnly)
572 {
573 GMM_ASSERTDPF(0, "CameraCapture cannot be in local memory.");
574 }
575 Surf.Flags.Info.LocalOnly = 0;
576 Surf.Flags.Info.NonLocalOnly = 1;
577 }
578
579 if(GetGmmLibContext()->GetWaTable().Wa64kbMappingAt2mbGranularity &&
580 (!GetGmmLibContext()->GetSkuTable().FtrLocalMemoryAllows4KB) &&
581 !Surf.Flags.Info.NonLocalOnly)
582 {
583 Surf.Flags.Info.LocalOnly = true;
584
585 }
586 }
587 else
588 {
589 Surf.Flags.Info.LocalOnly = false; //Zero out on iGPU
590 }
591
592 if((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) < IGFX_GEN8_CORE) &&
593 Surf.Flags.Info.TiledW)
594 {
595 GMM_ASSERTDPF(0, "Flag not supported on this platform.");
596 goto ERROR_CASE;
597 }
598
599 if((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) > IGFX_GEN11_CORE) &&
600 Surf.Flags.Info.TiledW)
601 {
602 GMM_ASSERTDPF(0, "Flag not supported on this platform.");
603 goto ERROR_CASE;
604 }
605
606 if((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) < IGFX_GEN9_CORE) &&
607 #if(_DEBUG || _RELEASE_INTERNAL)
608 !GetGmmLibContext()->GetWaTable().WaDisregardPlatformChecks &&
609 #endif
610 Surf.Flags.Gpu.MMC)
611 {
612 GMM_ASSERTDPF(0, "Flag not supported on this platform.");
613 goto ERROR_CASE;
614 }
615
616 //For Media Memory Compression --
617 if((Status = GetGmmLibContext()->GetPlatformInfoObj()->ValidateMMC(Surf)) == 0)
618 {
619 GMM_ASSERTDPF(0, "Invalid flag or array size!");
620 goto ERROR_CASE;
621 }
622
623 if(!GetGmmLibContext()->GetSkuTable().FtrTileY)
624 {
625 if(Surf.Flags.Gpu.TiledResource &&
626 ((Surf.Flags.Info.Linear && !(Surf.Type == RESOURCE_BUFFER)) || Surf.Flags.Info.TiledYs ||
627 Surf.Flags.Info.TiledYf || Surf.Flags.Info.TiledY))
628 {
629 GMM_ASSERTDPF(0, "Invalid Tile for TiledResource!");
630 goto ERROR_CASE;
631 }
632 if(GMM_IS_64KB_TILE(Surf.Flags) &&
633 (Surf.MSAA.NumSamples > 1) &&
634 (Surf.MaxLod != 0))
635 {
636 GMM_ASSERTDPF(0, "Mipped MSAA not supported for Tile64!");
637 goto ERROR_CASE;
638 }
639 // Tile4 does not support MSAA.
640 if(GMM_IS_4KB_TILE(Surf.Flags) &&
641 (Surf.MSAA.NumSamples > 1))
642 {
643 GMM_ASSERTDPF(0, "No MSAA support for Tile4!");
644 goto ERROR_CASE;
645 }
646 }
647
648 __GMM_ASSERT(!(GetGmmLibContext()->GetSkuTable().FtrTileY &&
649 (Surf.Flags.Info.Tile4 || Surf.Flags.Info.Tile64)));
650
651 //GMM asserts that ExistingSysMem allocation (whose malloc is outside GmmLib) are either
652 //SVM Buffer, Index Buffer, Vertex Buffers, Render Target, Texture
653 if(Surf.Flags.Info.ExistingSysMem &&
654 !Surf.ExistingSysMem.IsGmmAllocated &&
655 !Surf.ExistingSysMem.IsPageAligned)
656 {
657 if(!(Surf.Flags.Gpu.RenderTarget ||
658 Surf.Flags.Gpu.Vertex ||
659 Surf.Flags.Gpu.Index ||
660 Surf.Flags.Gpu.Texture ||
661 Surf.Flags.Info.Linear ||
662 Surf.Flags.Info.SVM))
663 {
664 GMM_ASSERTDPF(0, "Flag not supported by ExistingSysMem alloc!");
665 goto ERROR_CASE;
666 }
667
668 if(Surf.Type == RESOURCE_3D ||
669 Surf.Type == RESOURCE_CUBE ||
670 Surf.MaxLod ||
671 GmmIsYUVPlanar(Surf.Format))
672 {
673 GMM_ASSERTDPF(0, "Invalid ExistingSysMem resource Type/Format");
674 goto ERROR_CASE;
675 }
676 }
677
678 pTextureCalc->GetResRestrictions(&Surf, Restrictions);
679
680 // Check array size to make sure it meets HW limits
681 if((Surf.ArraySize > Restrictions.MaxArraySize) &&
682 ((RESOURCE_1D == Surf.Type) ||
683 (RESOURCE_2D == Surf.Type) ||
684 (RESOURCE_CUBE == Surf.Type)))
685 {
686 GMM_ASSERTDPF(0, "Invalid array size!");
687 goto ERROR_CASE;
688 }
689
690 // Check dimensions to make sure it meets HW max limits
691 if(((Surf.BaseHeight > Restrictions.MaxHeight) && !AllowMaxHeightViolations) ||
692 ((Surf.BaseWidth > Restrictions.MaxWidth) && !AllowMaxWidthViolations) ||
693 (Surf.Depth > Restrictions.MaxDepth)) // Any reason why MaxDepth != 1 for Tex2D
694 {
695 GMM_ASSERTDPF(0, "Invalid Dimension. Greater than max!");
696 goto ERROR_CASE;
697 }
698
699 // Check width to make sure it meets Yx requirements
700 if(((Surf.Format == GMM_FORMAT_Y8_UNORM_VA) && (Surf.BaseWidth % 4)) ||
701 ((Surf.Format == GMM_FORMAT_Y16_UNORM) && (Surf.BaseWidth % 2)) ||
702 ((Surf.Format == GMM_FORMAT_Y1_UNORM) && (Surf.BaseWidth % 32)))
703 {
704 GMM_ASSERTDPF(0, "Invalid width!");
705 goto ERROR_CASE;
706 }
707
708 // Check dimensions to make sure it meets HW min limits
709 if((Surf.BaseHeight < Restrictions.MinHeight) ||
710 (Surf.BaseWidth < Restrictions.MinWidth) ||
711 (Surf.Depth < Restrictions.MinDepth))
712 {
713 GMM_ASSERTDPF(0, "Invalid Dimension. Less than min!");
714 goto ERROR_CASE;
715 }
716
717 // check mip map
718 if(Surf.MaxLod > pPlatformResource->MaxLod)
719 {
720 GMM_ASSERTDPF(0, "Invalid mip map chain specified!");
721 goto ERROR_CASE;
722 }
723
724 // MIPs are not supported for tiled Yf/Ys planar surfaces
725 if((Surf.MaxLod) &&
726 GmmIsPlanar(Surf.Format) &&
727 (Surf.Flags.Info.TiledYf || GMM_IS_64KB_TILE(Surf.Flags)))
728 {
729 GMM_ASSERTDPF(0, "Invalid mip map chain specified!");
730 goto ERROR_CASE;
731 }
732
733 // check depth buffer tilings
734 if((Surf.Flags.Gpu.Depth == 1) &&
735 (Surf.Flags.Info.TiledX == 1))
736 {
737 GMM_ASSERTDPF(0, "Invalid Tiling for Depth Buffer!");
738 goto ERROR_CASE;
739 }
740
741 #if DBG
742 // Check if stencil buffer gpu flag is set w/ other flags
743 if(Surf.Flags.Gpu.SeparateStencil == 1)
744 {
745 GMM_RESOURCE_FLAG OnlySeparateStencilGpuFlag;
746
747 memset(&OnlySeparateStencilGpuFlag.Gpu, 0, sizeof(OnlySeparateStencilGpuFlag.Gpu));
748 OnlySeparateStencilGpuFlag.Gpu.SeparateStencil = 1;
749
750 if(memcmp(&Surf.Flags.Gpu, &OnlySeparateStencilGpuFlag.Gpu, sizeof(OnlySeparateStencilGpuFlag.Gpu)))
751 {
752 GMM_ASSERTDPF(0,
753 "Should not set w/ other flags b/c vertical alignment is "
754 "unique for separate stencil and incompatible w/ other "
755 "usages such as render target.");
756 goto ERROR_CASE;
757 }
758 }
759 #endif
760
761 // MSAA Restrictions
762 if((Surf.MSAA.NumSamples > 1) &&
763 !( //--- Legitimate MSAA Case ------------------------------------------
764 (Surf.Type == RESOURCE_2D) &&
765 (Surf.Flags.Gpu.Depth ||
766 Surf.Flags.Gpu.HiZ ||
767 Surf.Flags.Gpu.RenderTarget ||
768 Surf.Flags.Gpu.SeparateStencil) &&
769 // Single-LOD (pre-SKL)...
770 ((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) >= IGFX_GEN9_CORE) ||
771 (Surf.MaxLod == 0)) &&
772 // TileYF cannot be MSAA'ed (pre-Gen10)...
773 ((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) >= IGFX_GEN10_CORE) ||
774 !Surf.Flags.Info.TiledYf) &&
775 // Tile64 MSAA (Xe_HP)
776 (GetGmmLibContext()->GetSkuTable().FtrTileY ||
777 !GMM_IS_64KB_TILE(Surf.Flags) ||
778 (Surf.MaxLod == 0)) &&
779 // Tile4 does not support MSAA
780 (GetGmmLibContext()->GetSkuTable().FtrTileY ||
781 !GMM_IS_4KB_TILE(Surf.Flags)) &&
782 // Non-Compressed/YUV...
783 !GmmIsCompressed(GetGmmLibContext(), Surf.Format) &&
784 !GmmIsYUVPacked(Surf.Format) &&
785 !GmmIsPlanar(Surf.Format) &&
786 // Supported Sample Count for Platform...
787 (((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) >= IGFX_GEN7_CORE) &&
788 ((Surf.MSAA.NumSamples == 4) || (Surf.MSAA.NumSamples == 8))) ||
789 ((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) >= IGFX_GEN8_CORE) &&
790 ((Surf.MSAA.NumSamples == 2))) ||
791 ((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) >= IGFX_GEN9_CORE) &&
792 ((Surf.MSAA.NumSamples == 16))))))
793 {
794 GMM_ASSERTDPF(0, "Invalid MSAA usage!");
795 goto ERROR_CASE;
796 }
797
798 // CCS Restrictions
799 if(Surf.Flags.Gpu.CCS)
800 {
801 if((Status = GetGmmLibContext()->GetPlatformInfoObj()->ValidateCCS(Surf)) == 0)
802 {
803 GMM_ASSERTDPF(0, "Invalid CCS usage!");
804 goto ERROR_CASE;
805 }
806
807 if(Surf.Flags.Info.RenderCompressed && Surf.Flags.Info.MediaCompressed)
808 {
809 GMM_ASSERTDPF(0, "Invalid CCS usage - can't be both RC and MC!");
810 goto ERROR_CASE;
811 }
812 }
813
814 // UnifiedAuxSurface Restrictions
815 if((Status = GetGmmLibContext()->GetPlatformInfoObj()->ValidateUnifiedAuxSurface(Surf)) == 0)
816 {
817 GMM_ASSERTDPF(0, "Invalid UnifiedAuxSurface usage!");
818 goto ERROR_CASE;
819 }
820
821 // IndirectClearColor Restrictions
822 if((Surf.Flags.Gpu.IndirectClearColor) &&
823 !( //--- Legitimate IndirectClearColor Case ------------------------------------------
824 ((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) >= IGFX_GEN9_CORE) &&
825 Surf.Flags.Gpu.UnifiedAuxSurface) ||
826 ((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) > IGFX_GEN11_CORE) &&
827 (Surf.Flags.Gpu.HiZ || Surf.Flags.Gpu.SeparateStencil))))
828 {
829 GMM_ASSERTDPF(0, "Invalid IndirectClearColor usage!");
830 goto ERROR_CASE;
831 }
832
833 // CornerTexelMode Restrictions
834 if(Surf.Flags.Info.CornerTexelMode &&
835 (!( //--- Legitimate CornerTexelMode Case -------------------------------------------
836 (GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) >= IGFX_GEN11_CORE) &&
837 (!GmmIsPlanar(Surf.Format)) &&
838 (!Surf.Flags.Info.StdSwizzle))))
839 {
840 GMM_ASSERTDPF(0, "Flag.Info.CornerTexelMode not supported on this platform.");
841 goto ERROR_CASE;
842 }
843
844 //MultiTileArch params
845 if(GetGmmLibContext()->GetSkuTable().FtrMultiTileArch)
846 {
847 /*
848 MultiTileArch validation criteria
849 - MultiTileArch.Enable must be set.
850 - NonLocalOnly alloc must have LocalEligibilitySet and LocalPreferenceSet both zero
851 - LocalOnly alloc must have non-zero LocalEligibilitySet
852 - GpuVaMappingSet/LocalEligibilitySet must be subset of GtSysInfo.TileMask
853 - PreferredSet must be subset of EligibilitySet or zero
854 */
855 if(!(
856 // Legitimate cases
857 MultiTileArch.Enable &&
858 (Surf.Flags.Info.NonLocalOnly || MultiTileArch.LocalMemEligibilitySet) &&
859 ((MultiTileArch.GpuVaMappingSet & GetGmmLibContext()->GetGtSysInfo()->MultiTileArchInfo.TileMask) == MultiTileArch.GpuVaMappingSet) &&
860 ((MultiTileArch.LocalMemEligibilitySet & GetGmmLibContext()->GetGtSysInfo()->MultiTileArchInfo.TileMask) == MultiTileArch.LocalMemEligibilitySet) &&
861 ((MultiTileArch.LocalMemEligibilitySet & MultiTileArch.LocalMemPreferredSet) == MultiTileArch.LocalMemPreferredSet)))
862 {
863 GMM_ASSERTDPF(0, "Invalid MultiTileArch allocation params");
864 goto ERROR_CASE;
865 }
866 }
867
868 // check 2D, 3D & Cubemap dimensions
869 switch(Surf.Type)
870 {
871 case RESOURCE_1D:
872 case RESOURCE_2D:
873 case RESOURCE_3D:
874 {
875 if(!Surf.BaseWidth || !Surf.BaseHeight)
876 {
877 GMM_ASSERTDPF(0, "Width or Height is 0!");
878 goto ERROR_CASE;
879 }
880 break;
881 }
882 case RESOURCE_CUBE:
883 {
884 if(!Surf.BaseWidth || !Surf.BaseHeight)
885 {
886 GMM_ASSERTDPF(0, "Cubemap Dimensions invalid!");
887 goto ERROR_CASE;
888 }
889 if(Surf.BaseWidth != Surf.BaseHeight)
890 {
891 GMM_ASSERTDPF(0, "Cubemap Dimensions invalid (width != Height)!");
892 goto ERROR_CASE;
893 }
894 break;
895 }
896 case RESOURCE_SCRATCH:
897 case RESOURCE_BUFFER:
898 {
899 if(Surf.BaseHeight != 1)
900 {
901 GMM_ASSERTDPF(0, "Linear surface height not 1!");
902 goto ERROR_CASE;
903 }
904 break;
905 }
906 default:
907 break;
908 }
909
910 GMM_DPF_EXIT;
911 return 1;
912
913 ERROR_CASE:
914 __GMM_ASSERT(0);
915 return 0;
916 }
917
918 //=============================================================================
919 //
920 // Function: GetDisplayCompressionSupport
921 //
922 // Desc: Returns true if display hw supports lossless render/media decompression
923 // else returns false.
924 // Umds can call it to decide if full resolve is required
925 //
926 // Parameters:
927 // See function arguments.
928 //
929 // Returns:
930 // uint8_t
931 //-----------------------------------------------------------------------------
GetDisplayCompressionSupport()932 uint8_t GMM_STDCALL GmmLib::GmmResourceInfoCommon::GetDisplayCompressionSupport()
933 {
934 uint8_t ComprSupported = 0;
935 GMM_RESOURCE_FORMAT Format = Surf.Format;
936
937 if(Surf.Flags.Gpu.UnifiedAuxSurface)
938 {
939 bool IsSupportedRGB64_16_16_16_16 = false;
940 bool IsSupportedRGB32_8_8_8_8 = false;
941 bool IsSupportedRGB32_2_10_10_10 = false;
942 bool IsSupportedMediaFormats = false;
943
944 switch(Format) //RGB64 16:16 : 16 : 16 FP16
945 {
946 case GMM_FORMAT_R16G16B16A16_FLOAT:
947 case GMM_FORMAT_R16G16B16X16_FLOAT:
948 IsSupportedRGB64_16_16_16_16 = true;
949 default:
950 break;
951 }
952
953 switch(Format) //RGB32 8 : 8 : 8 : 8
954 {
955 case GMM_FORMAT_B8G8R8A8_UNORM:
956 case GMM_FORMAT_R8G8B8A8_UNORM:
957 case GMM_FORMAT_B8G8R8X8_UNORM:
958 case GMM_FORMAT_R8G8B8X8_UNORM:
959 case GMM_FORMAT_R8G8B8A8_UNORM_SRGB:
960 case GMM_FORMAT_B8X8_UNORM_G8R8_SNORM:
961 case GMM_FORMAT_X8B8_UNORM_G8R8_SNORM:
962 case GMM_FORMAT_A8X8_UNORM_G8R8_SNORM:
963 case GMM_FORMAT_B8G8R8A8_UNORM_SRGB:
964 case GMM_FORMAT_B8G8R8X8_UNORM_SRGB:
965 case GMM_FORMAT_R8G8B8A8_SINT:
966 case GMM_FORMAT_R8G8B8A8_SNORM:
967 case GMM_FORMAT_R8G8B8A8_SSCALED:
968 case GMM_FORMAT_R8G8B8A8_UINT:
969 case GMM_FORMAT_R8G8B8A8_USCALED:
970 case GMM_FORMAT_R8G8B8X8_UNORM_SRGB:
971 IsSupportedRGB32_8_8_8_8 = true;
972 default:
973 break;
974 }
975
976 switch(Format) //RGB32 2 : 10 : 10 : 10
977 {
978 case GMM_FORMAT_B10G10R10X2_UNORM:
979 case GMM_FORMAT_R10G10B10A2_UNORM:
980 case GMM_FORMAT_B10G10R10A2_UNORM:
981 case GMM_FORMAT_B10G10R10A2_SINT:
982 case GMM_FORMAT_B10G10R10A2_SNORM:
983 case GMM_FORMAT_B10G10R10A2_SSCALED:
984 case GMM_FORMAT_B10G10R10A2_UINT:
985 case GMM_FORMAT_B10G10R10A2_UNORM_SRGB:
986 case GMM_FORMAT_B10G10R10A2_USCALED:
987 case GMM_FORMAT_R10G10B10_FLOAT_A2_UNORM:
988 case GMM_FORMAT_R10G10B10_SNORM_A2_UNORM:
989 case GMM_FORMAT_R10G10B10A2_SINT:
990 case GMM_FORMAT_R10G10B10A2_SNORM:
991 case GMM_FORMAT_R10G10B10A2_SSCALED:
992 case GMM_FORMAT_R10G10B10A2_UINT:
993 case GMM_FORMAT_R10G10B10A2_UNORM_SRGB:
994 case GMM_FORMAT_R10G10B10A2_USCALED:
995 case GMM_FORMAT_R10G10B10X2_USCALED:
996 case GMM_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
997 IsSupportedRGB32_2_10_10_10 = true;
998 default:
999 break;
1000 }
1001
1002 switch(Format)
1003 {
1004 case GMM_FORMAT_YUY2: //YUV422 8 bpc
1005 case GMM_FORMAT_NV12: //YUV420 - NV12
1006 case GMM_FORMAT_P010: //YUV420 - P0xx
1007 case GMM_FORMAT_P016:
1008 case GMM_FORMAT_Y210: //YUV422 - Y210, Y212, Y216
1009 case GMM_FORMAT_Y216:
1010 case GMM_FORMAT_Y410: //YUV444 - Y410
1011 case GMM_FORMAT_Y416:
1012 IsSupportedMediaFormats = true; //YUV444 - Y412, Y416
1013 default:
1014 break;
1015 }
1016
1017 //Check fmt is display decompressible
1018 ComprSupported = GetGmmLibContext()->GetPlatformInfoObj()->CheckFmtDisplayDecompressible(Surf, IsSupportedRGB64_16_16_16_16,
1019 IsSupportedRGB32_8_8_8_8, IsSupportedRGB32_2_10_10_10,
1020 IsSupportedMediaFormats);
1021 }
1022
1023 return ComprSupported;
1024 }
1025
1026 //=============================================================================
1027 //
1028 // Function: GetDisplayFastClearSupport
1029 //
1030 // Desc: Returns 1 if display hw supports fast clear else returns 0.
1031 // Umds can call it to decide if FC resolve is required
1032 //
1033 // Parameters:
1034 // See function arguments.
1035 //
1036 // Returns:
1037 // uint8_t
1038 //-----------------------------------------------------------------------------
GetDisplayFastClearSupport()1039 uint8_t GMM_STDCALL GmmLib::GmmResourceInfoCommon::GetDisplayFastClearSupport()
1040 {
1041 uint8_t FCSupported = 0;
1042
1043 if(GFX_GET_CURRENT_RENDERCORE(GetGmmLibContext()->GetPlatformInfo().Platform) >= IGFX_GEN11_CORE)
1044 {
1045 FCSupported = GetDisplayCompressionSupport() && !GmmIsPlanar(Surf.Format);
1046 FCSupported &= Surf.Flags.Gpu.IndirectClearColor;
1047 }
1048
1049 return FCSupported;
1050 }
1051