Debian Codegraph @

media_driver/linux/Xe_M/ddi/media_sku_wa_xe.cpp

raw
1 /*
2 * Copyright (c) 2021-2022, 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 //! \file media_sku_wa_xe.cpp
25 //!
26
27 #include "igfxfmid.h"
28 #include "linux_system_info.h"
29 #include "skuwa_factory.h"
30 #include "linux_skuwa_debug.h"
31 #include "linux_media_skuwa.h"
32 #include "mos_utilities.h"
33 #include "mos_os_specific.h"
34 #include "media_user_setting_specific.h"
35
36 #ifndef SI_REV_LO
37 #define SI_REV_LO(SteppingID) (SteppingID & 0xFFFF)
38 #endif
39
40 #ifndef SI_WA_FROM
41 #define SI_WA_FROM(ulRevID, STEPPING) (ulRevID >= (int)SI_REV_LO(STEPPING))
42 #endif
43
44 #ifndef ACM_G10_MEDIA_REV_ID_B0
45 #define ACM_G10_MEDIA_REV_ID_B0 DG2_MEDIA_REV_ID_B0
46 #endif
47
48 static constexpr uint32_t singleVeboxSubSliceNumMax = 24;
49
50 //extern template class DeviceInfoFactory<GfxDeviceInfo>;
51 typedef DeviceInfoFactory<LinuxDeviceInit> DeviceInit;
52
53 static struct LinuxCodecInfo XehpSdvCodecInfo =
54 {
55 .avcDecoding = 1,
56 .mpeg2Decoding = 1,
57 .vp8Decoding = 0,
58 .vc1Decoding = 0,
59 .jpegDecoding = 1,
60 .avcEncoding = 0,
61 .mpeg2Encoding = 0,
62 .hevcDecoding = 1,
63 .hevcEncoding = 0,
64 .jpegEncoding = 0,
65 .avcVdenc = 0,
66 .vp9Decoding = 1,
67 .hevc10Decoding = 1,
68 .vp9b10Decoding = 1,
69 .hevc10Encoding = 0,
70 .hevc12Encoding = 0,
71 .vp8Encoding = 0,
72 .hevcVdenc = 0,
73 .vp9Vdenc = 0,
74 .adv0Decoding = SET_STATUS_BY_FULL_OPEN_SOURCE(1, 0),
75 .adv1Decoding = SET_STATUS_BY_FULL_OPEN_SOURCE(1, 0),
76 };
77
78 static struct LinuxCodecInfo Dg2CodecInfo =
79 {
80 .avcDecoding = 1,
81 .mpeg2Decoding = 1,
82 .vp8Decoding = 0,
83 .vc1Decoding = 0,
84 .jpegDecoding = 1,
85 .avcEncoding = 0,
86 .mpeg2Encoding = 0,
87 .hevcDecoding = 1,
88 .hevcEncoding = 0,
89 .jpegEncoding = 1,
90 .avcVdenc = 1,
91 .vp9Decoding = 1,
92 .hevc10Decoding = 1,
93 .vp9b10Decoding = 1,
94 .hevc10Encoding = 0,
95 .hevc12Encoding = 0,
96 .vp8Encoding = 0,
97 .hevcVdenc = 1,
98 .vp9Vdenc = 1,
99 .adv0Decoding = SET_STATUS_BY_FULL_OPEN_SOURCE(1, 0),
100 .adv1Decoding = SET_STATUS_BY_FULL_OPEN_SOURCE(1, 0),
101 };
102
103 static struct LinuxCodecInfo PvcCodecInfo =
104 {
105 .avcDecoding = 1,
106 .mpeg2Decoding = 1,
107 .vp8Decoding = 0,
108 .vc1Decoding = 0,
109 .jpegDecoding = 1,
110 .avcEncoding = 0,
111 .mpeg2Encoding = 0,
112 .hevcDecoding = 1,
113 .hevcEncoding = 0,
114 #ifdef IGFX_PVC_ENABLE_NON_UPSTREAM
115 .jpegEncoding = 1,
116 .avcVdenc = 1,
117 #else
118 .jpegEncoding = 0,
119 .avcVdenc = 0,
120 #endif
121 .vp9Decoding = 1,
122 .hevc10Decoding = 1,
123 .vp9b10Decoding = 1,
124 .hevc10Encoding = 0,
125 .hevc12Encoding = 0,
126 .vp8Encoding = 0,
127 #ifdef IGFX_PVC_ENABLE_NON_UPSTREAM
128 .hevcVdenc = 1,
129 .vp9Vdenc = 1,
130 #else
131 .hevcVdenc = 0,
132 .vp9Vdenc = 0,
133 #endif
134 .adv0Decoding = SET_STATUS_BY_FULL_OPEN_SOURCE(1, 0),
135 .adv1Decoding = SET_STATUS_BY_FULL_OPEN_SOURCE(1, 0),
136 };
137
138 static bool InitTglMediaSkuExt(struct GfxDeviceInfo *devInfo,
139 MediaFeatureTable *skuTable,
140 struct LinuxDriverInfo *drvInfo,
141 struct LinuxCodecInfo *codecInfo,
142 MediaUserSettingSharedPtr userSettingPtr)
143 {
144 if ((devInfo == nullptr) || (skuTable == nullptr) || (drvInfo == nullptr))
145 {
146 DEVINFO_ERROR("null ptr is passed\n");
147 return false;
148 }
149
150 if (drvInfo->hasBsd)
151 {
152 MEDIA_WR_SKU(skuTable, FtrAVCVLDLongDecoding, codecInfo->avcDecoding);
153 MEDIA_WR_SKU(skuTable, FtrMPEG2VLDDecoding, codecInfo->mpeg2Decoding);
154 MEDIA_WR_SKU(skuTable, FtrIntelVP8VLDDecoding, codecInfo->vp8Decoding);
155 MEDIA_WR_SKU(skuTable, FtrVC1VLDDecoding, codecInfo->vc1Decoding);
156 MEDIA_WR_SKU(skuTable, FtrIntelJPEGDecoding, codecInfo->jpegDecoding);
157 MEDIA_WR_SKU(skuTable, FtrEncodeAVC, codecInfo->avcEncoding);
158 MEDIA_WR_SKU(skuTable, FtrEncodeMPEG2, codecInfo->mpeg2Encoding);
159 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMainDecoding, codecInfo->hevcDecoding);
160 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMain10Decoding, codecInfo->hevc10Decoding);
161
162 MEDIA_WR_SKU(skuTable, FtrEncodeHEVC, codecInfo->hevcEncoding);
163 MEDIA_WR_SKU(skuTable, FtrEncodeHEVC10bit, codecInfo->hevc10Encoding);
164 MEDIA_WR_SKU(skuTable, FtrEncodeJPEG, codecInfo->jpegEncoding);
165 MEDIA_WR_SKU(skuTable, FtrEncodeAVCVdenc, codecInfo->avcVdenc);
166 MEDIA_WR_SKU(skuTable, FtrVP9VLDDecoding, codecInfo->vp9Decoding);
167 MEDIA_WR_SKU(skuTable, FtrIntelVP9VLDProfile0Decoding8bit420, codecInfo->vp9Decoding);
168 MEDIA_WR_SKU(skuTable, FtrVP9VLD10bProfile2Decoding, codecInfo->vp9b10Decoding);
169 MEDIA_WR_SKU(skuTable, FtrIntelVP9VLDProfile2Decoding, codecInfo->vp9b10Decoding);
170 MEDIA_WR_SKU(skuTable, FtrIntelAV1VLDDecoding8bit420, codecInfo->adv0Decoding);
171 MEDIA_WR_SKU(skuTable, FtrIntelAV1VLDDecoding10bit420, codecInfo->adv1Decoding);
172
173 /* VP8 enc */
174 MEDIA_WR_SKU(skuTable, FtrEncodeVP8, codecInfo->vp8Encoding);
175
176 /* HEVC VDENC */
177 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain, codecInfo->hevcVdenc);
178 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain10, codecInfo->hevcVdenc);
179
180 /* Vp9 VDENC */
181 MEDIA_WR_SKU(skuTable, FtrEncodeVP9Vdenc, codecInfo->vp9Vdenc);
182
183 /* HEVC Main8/10bit-422/444 Decoding. Currently it is enabled. */
184 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLD42210bitDecoding, 1);
185 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLD4448bitDecoding, 1);
186 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLD44410bitDecoding, 1);
187
188 /* SFC Histogram Streamout. */
189 MEDIA_WR_SKU(skuTable, FtrSFCHistogramStreamOut, 1);
190
191 /* Subset buffer for realtile decoding. */
192 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDDecodingSubsetBuffer, 1);
193
194 /* HEVC Main8/10bit-420/422/444 Scc Decoding. Currently it is enabled. */
195 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMain8bit420SCC, 1);
196 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMain10bit420SCC, 1);
197 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMain8bit444SCC, 1);
198 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMain10bit444SCC, 1);
199
200 /* HEVC VDENC Main8/10 422/444 Encoding. */
201 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain444, codecInfo->hevcVdenc);
202 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain422, codecInfo->hevcVdenc);
203 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain10bit422, codecInfo->hevcVdenc);
204 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain10bit444, codecInfo->hevcVdenc);
205
206 /* HEVC VDENC Main8/10bit-420/422/444 Scc Encoding. */
207 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMainSCC, codecInfo->hevcVdenc);
208 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain10bitSCC, codecInfo->hevcVdenc);
209 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain444SCC, codecInfo->hevcVdenc);
210 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain10bit444SCC, codecInfo->hevcVdenc);
211
212 /* HEVC 12bit Decoding. Currently it is enabled */
213 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMain12bit420Decoding, 1);
214 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMain12bit422Decoding, 1);
215 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMain12bit444Decoding, 1);
216
217 /* VP9 8 bit 444 */
218 MEDIA_WR_SKU(skuTable, FtrIntelVP9VLDProfile1Decoding8bit444, 1);
219 /* VP9 10 Bit 444*/
220 MEDIA_WR_SKU(skuTable, FtrIntelVP9VLDProfile3Decoding10bit444, 1);
221 /* VP9 12 bit 420/444 */
222 MEDIA_WR_SKU(skuTable, FtrIntelVP9VLDProfile2Decoding12bit420, 1);
223 MEDIA_WR_SKU(skuTable, FtrIntelVP9VLDProfile3Decoding12bit444, 1);
224
225 /* VP9 VDENC 8Bit 444 */
226 MEDIA_WR_SKU(skuTable, FtrEncodeVP9Vdenc8bit444, codecInfo->vp9Vdenc);
227 /* VP9 VDENC 10Bit 420/444 */
228 MEDIA_WR_SKU(skuTable, FtrEncodeVP9Vdenc10bit420, codecInfo->vp9Vdenc);
229 MEDIA_WR_SKU(skuTable, FtrEncodeVP9Vdenc10bit444, codecInfo->vp9Vdenc);
230 }
231
232 MEDIA_WR_SKU(skuTable, FtrEnableMediaKernels, drvInfo->hasHuc);
233
234 if (devInfo->eGTType == GTTYPE_GT1)
235 {
236 MEDIA_WR_SKU(skuTable, FtrGT1, 1);
237 }
238 else if (devInfo->eGTType == GTTYPE_GT1_5)
239 {
240 MEDIA_WR_SKU(skuTable, FtrGT1_5, 1);
241 }
242 else if (devInfo->eGTType == GTTYPE_GT2)
243 {
244 MEDIA_WR_SKU(skuTable, FtrGT2, 1);
245 }
246 else if (devInfo->eGTType == GTTYPE_GT3)
247 {
248 MEDIA_WR_SKU(skuTable, FtrGT3, 1);
249 }
250 else if (devInfo->eGTType == GTTYPE_GT4)
251 {
252 MEDIA_WR_SKU(skuTable, FtrGT4, 1);
253 }
254 else
255 {
256 /* GT1 is by default */
257 MEDIA_WR_SKU(skuTable, FtrGT1, 1);
258 }
259
260 MEDIA_WR_SKU(skuTable, FtrVERing, drvInfo->hasVebox);
261 MEDIA_WR_SKU(skuTable, FtrPPGTT, drvInfo->hasPpgtt);
262 MEDIA_WR_SKU(skuTable, FtrEDram, devInfo->hasERAM);
263
264 /* Virtual VDBOX ring is used on Gen12 */
265 MEDIA_WR_SKU(skuTable, FtrVcs2, 0);
266
267 MEDIA_WR_SKU(skuTable, FtrSingleVeboxSlice, 1);
268 if (devInfo->SubSliceCount >= singleVeboxSubSliceNumMax)
269 {
270 MEDIA_WR_SKU(skuTable, FtrSingleVeboxSlice, 0);
271 }
272
273 MEDIA_WR_SKU(skuTable, FtrSFCPipe, 1);
274
275 MEDIA_WR_SKU(skuTable, FtrHCP2SFCPipe, 1);
276 MEDIA_WR_SKU(skuTable, FtrSSEUPowerGating, 1);
277 MEDIA_WR_SKU(skuTable, FtrSSEUPowerGatingControlByUMD, 1);
278
279 MEDIA_WR_SKU(skuTable, FtrPerCtxtPreemptionGranularityControl, 1);
280
281 /* It is disabled by default. It can be enabled based on HW */
282 MEDIA_WR_SKU(skuTable, FtrMemoryCompression, 0);
283 MEDIA_WR_SKU(skuTable, FtrHcpDecMemoryCompression, 0);
284 MEDIA_WR_SKU(skuTable, Ftr10bitDecMemoryCompression, 0);
285
286 MEDIA_WR_SKU(skuTable, FtrCCSNode, 1);
287
288 MEDIA_WR_SKU(skuTable, FtrVpP010Output, 1);
289 MEDIA_WR_SKU(skuTable, FtrVp10BitSupport, 1);
290 MEDIA_WR_SKU(skuTable, FtrVp16BitSupport, 1);
291
292 MEDIA_WR_SKU(skuTable, FtrContextBasedScheduling, 1);
293
294 MEDIA_WR_SKU(skuTable, FtrSWMediaReset, 1);
295
296 MEDIA_WR_SKU(skuTable, FtrVeboxScalabilitywith4K, 1);
297
298 MEDIA_WR_SKU(skuTable, FtrTileY, 1);
299 MEDIA_WR_SKU(skuTable, FtrE2ECompression, 1);
300 MEDIA_WR_SKU(skuTable, FtrLinearCCS, 1);
301 MEDIA_WR_SKU(skuTable, FtrFlatPhysCCS, 0);
302
303 MEDIA_WR_SKU(skuTable, FtrHeight8AlignVE3DLUTDualPipe, 1);
304
305 // Disable MMC for all components if set reg key
306 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
307 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
308 MOS_UserFeature_ReadValue_ID(
309 nullptr,
310 __MEDIA_USER_FEATURE_VALUE_DISABLE_MMC_ID,
311 &userFeatureData,
312 (MOS_CONTEXT_HANDLE)nullptr);
313 if (userFeatureData.bData)
314 {
315 MEDIA_WR_SKU(skuTable, FtrE2ECompression, 0);
316 }
317
318 // Create uncompressible surface by default
319 MEDIA_WR_SKU(skuTable, FtrCompressibleSurfaceDefault, 0);
320
321 bool compressibleSurfaceEnable = false;
322
323 ReadUserSetting(userSettingPtr,
324 compressibleSurfaceEnable,
325 "Enable Compressible Surface Creation",
326 MediaUserSetting::Group::Device);
327
328 if (compressibleSurfaceEnable)
329 {
330 MEDIA_WR_SKU(skuTable, FtrCompressibleSurfaceDefault, 1);
331 }
332
333 if (drvInfo->devId == 0xFF20)
334 {
335 MEDIA_WR_SKU(skuTable, FtrConditionalBatchBuffEnd, 1);
336 }
337
338 MEDIA_WR_SKU(skuTable, FtrUseSwSwizzling, 1);
339
340 MEDIA_WR_SKU(skuTable, FtrMemoryRemapSupport, 1);
341
342 MEDIA_WR_SKU(skuTable, FtrAV1VLDLSTDecoding, 0);
343
344 //Tile64
345 if (GFX_IS_DG2_G11_CONFIG(drvInfo->devId))
346 {
347 MEDIA_WR_SKU(skuTable, FtrTileY, 0);
348 }
349
350 return true;
351 }
352
353 static bool InitTglMediaWaExt(struct GfxDeviceInfo *devInfo,
354 MediaWaTable *waTable,
355 struct LinuxDriverInfo *drvInfo)
356 {
357 if ((devInfo == nullptr) || (waTable == nullptr) || (drvInfo == nullptr))
358 {
359 DEVINFO_ERROR("null ptr is passed\n");
360 return false;
361 }
362
363 MEDIA_WR_WA(waTable, WaForceGlobalGTT, !drvInfo->hasPpgtt);
364 MEDIA_WR_WA(waTable, WaMidBatchPreemption, 0);
365 MEDIA_WR_WA(waTable, WaArbitraryNumMbsInSlice, 1);
366
367 MEDIA_WR_WA(waTable, WaSuperSliceHeaderPacking, 1);
368
369 MEDIA_WR_WA(waTable, WaSFC270DegreeRotation, 0);
370
371 MEDIA_WR_WA(waTable, WaEnableYV12BugFixInHalfSliceChicken7, 1);
372
373 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
374 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
375 MOS_UserFeature_ReadValue_ID(
376 nullptr,
377 __MEDIA_USER_FEATURE_VALUE_AUX_TABLE_16K_GRANULAR_ID,
378 &userFeatureData,
379 (MOS_CONTEXT_HANDLE)nullptr);
380
381 MEDIA_WR_WA(waTable, WaDummyReference, 1);
382
383 MEDIA_WR_WA(waTable, Wa16KInputHeightNV12Planar420, 1);
384
385 /*software wa to disable calculate the UV offset by gmmlib
386 CPU blt call will add/remove padding on the platform*/
387 MEDIA_WR_WA(waTable, WaDisableGmmLibOffsetInDeriveImage, 1);
388
389 /*software wa to fix some corner cases of HEVC/VP9 SFC and Scalability*/
390 MEDIA_WR_WA(waTable, Wa_14010222001, 1);
391
392 /*software wa to fix some corner hang cases for Scalability*/
393 MEDIA_WR_WA(waTable, Wa_2209620131, 1);
394
395
396 if (drvInfo->devId == 0x9A49 ||
397 drvInfo->devId == 0x9AC9 ||
398 drvInfo->devId == 0x9A60 ||
399 drvInfo->devId == 0x9A68 ||
400 drvInfo->devId == 0x9A70 ||
401 drvInfo->devId == 0x4905 ||
402 drvInfo->devId == 0x4906 ||
403 drvInfo->devId == 0x4907)
404 {
405 /*software wa to use frame based decoding for AV1 decode*/
406 MEDIA_WR_WA(waTable, Wa_1409820462, 1);
407 }
408
409 if (drvInfo->devId == 0x4905 ||
410 drvInfo->devId == 0x4906 ||
411 drvInfo->devId == 0x4907)
412 {
413 /* Turn off MMC for codec, need to remove once turn it on */
414 MEDIA_WR_WA(waTable, WaDisableCodecMmc, 1);
415
416 /* Turn off MMC for VPP, need to remove once turn it on */
417 MEDIA_WR_WA(waTable, WaDisableVPMmc, 1);
418 }
419
420 if (MEDIA_IS_WA(waTable, Wa_14012254246))
421 {
422 MOS_UserFeature_ReadValue_ID(
423 nullptr,
424 __MEDIA_USER_FEATURE_VALUE_DISABLE_TLB_PREFETCH_ID,
425 &userFeatureData,
426 (MOS_CONTEXT_HANDLE)nullptr);
427 // For PVC A0, if TLB pre-fetch disabled, resource could be allocated to system memory and local memory;
428 // otherwise, resource could be allocated to local memory only.
429 if (userFeatureData.u32Data == 0)
430 {
431 MEDIA_WR_WA(waTable, WaForceAllocateLML2, 1);
432 MEDIA_WR_WA(waTable, WaForceAllocateLML3, 0);
433 MEDIA_WR_WA(waTable, WaForceAllocateLML4, 0);
434 }
435 }
436
437 // For DG2
438 if (GFX_IS_DG2_G11_CONFIG(drvInfo->devId))
439 {
440 MEDIA_WR_WA(waTable, Wa_22011549751, 1);
441 }
442
443 MEDIA_WR_WA(waTable, WaEnableVPPCopy, 1);
444 MEDIA_WR_WA(waTable, Wa_AvcUnalignedHeight, 1);
445 return true;
446 }
447
448 static bool InitXehpSDVMediaSku(struct GfxDeviceInfo *devInfo,
449 MediaFeatureTable *skuTable,
450 struct LinuxDriverInfo *drvInfo,
451 MediaUserSettingSharedPtr userSettingPtr)
452 {
453 if (!InitTglMediaSkuExt(devInfo, skuTable, drvInfo, &XehpSdvCodecInfo, userSettingPtr))
454 {
455 return false;
456 }
457
458 // Guc Submission
459 MEDIA_WR_SKU(skuTable, FtrGucSubmission, 1);
460
461 // doesn't support legacy TileY
462 MEDIA_WR_SKU(skuTable, FtrTileY, 0);
463 MEDIA_WR_SKU(skuTable, FtrE2ECompression, 1);
464 MEDIA_WR_SKU(skuTable, FtrLinearCCS, 1);
465 MEDIA_WR_SKU(skuTable, FtrFlatPhysCCS, 1);
466 MEDIA_WR_SKU(skuTable, FtrCompsitionMemoryCompressedOut, 1);
467
468 //Enable LocalMemory for all dGraphics
469 MEDIA_WR_SKU(skuTable, FtrLocalMemory, 1);
470
471 MEDIA_WR_SKU(skuTable, FtrConditionalBatchBuffEnd, 1);
472 return true;
473 }
474
475 static bool InitXehpSDVMediaWa(struct GfxDeviceInfo *devInfo,
476 MediaWaTable *waTable,
477 struct LinuxDriverInfo *drvInfo)
478 {
479 if (!InitTglMediaWaExt(devInfo, waTable, drvInfo))
480 {
481 DEVINFO_ERROR("InitMediaWA failed\n");
482 return false;
483 }
484 /*software wa to use frame based decoding for AV1 decode*/
485 MEDIA_WR_WA(waTable, Wa_1409820462, 1);
486
487 /*software wa to add a dummy workload in front of
488 normal workload per batch buffer*/
489 MEDIA_WR_WA(waTable, Wa_1508208842, 1);
490
491 /* Turn off MMC for codec, need to remove once turn it on */
492 MEDIA_WR_WA(waTable, WaDisableCodecMmc, 1);
493
494 /* Turn off MMC for VPP, need to remove once turn it on */
495 MEDIA_WR_WA(waTable, WaDisableVPMmc, 1);
496
497 /* default resource allocate policy for XeHP_SDV*/
498 MEDIA_WR_WA(waTable, WaForceAllocateLML2, 0);
499
500 /* only enable L3 for A step*/
501 if (drvInfo->devRev == 0x0 || drvInfo->devRev == 0x1)
502 {
503 MEDIA_WR_WA(waTable, WaForceAllocateLML3, 1);
504 }
505 else
506 {
507 MEDIA_WR_WA(waTable, WaForceAllocateLML3, 0);
508 }
509 MEDIA_WR_WA(waTable, WaForceAllocateLML4, 0);
510
511 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
512 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
513 MOS_UserFeature_ReadValue_ID(
514 nullptr,
515 __MEDIA_USER_FEATURE_VALUE_LOCAL_MEMORY_LEVEL_SWITCH_ID,
516 &userFeatureData,
517 (MOS_CONTEXT_HANDLE)nullptr);
518
519 if(userFeatureData.u32Data == 2)
520 {
521 MEDIA_WR_WA(waTable, WaForceAllocateLML2, 1);
522 MEDIA_WR_WA(waTable, WaForceAllocateLML3, 0);
523 MEDIA_WR_WA(waTable, WaForceAllocateLML4, 0);
524 }
525
526 if(userFeatureData.u32Data == 3)
527 {
528 MEDIA_WR_WA(waTable, WaForceAllocateLML2, 0);
529 MEDIA_WR_WA(waTable, WaForceAllocateLML3, 1);
530 MEDIA_WR_WA(waTable, WaForceAllocateLML4, 0);
531 }
532
533 if(userFeatureData.u32Data == 4)
534 {
535 MEDIA_WR_WA(waTable, WaForceAllocateLML2, 0);
536 MEDIA_WR_WA(waTable, WaForceAllocateLML3, 1);
537 MEDIA_WR_WA(waTable, WaForceAllocateLML4, 1);
538 }
539
540 if (char* pLocalMemLevelSwitch = getenv("LOCALMEMLEVELSWITCH"))
541 {
542 int localMemLevelSwitch = atoi(pLocalMemLevelSwitch);
543
544 if(localMemLevelSwitch == 2)
545 {
546 MEDIA_WR_WA(waTable, WaForceAllocateLML2, 1);
547 MEDIA_WR_WA(waTable, WaForceAllocateLML3, 0);
548 MEDIA_WR_WA(waTable, WaForceAllocateLML4, 0);
549 }
550 else if(localMemLevelSwitch == 3)
551 {
552 MEDIA_WR_WA(waTable, WaForceAllocateLML2, 0);
553 MEDIA_WR_WA(waTable, WaForceAllocateLML3, 1);
554 MEDIA_WR_WA(waTable, WaForceAllocateLML4, 0);
555 }
556 else if(localMemLevelSwitch == 4)
557 {
558 MEDIA_WR_WA(waTable, WaForceAllocateLML2, 0);
559 MEDIA_WR_WA(waTable, WaForceAllocateLML3, 1);
560 MEDIA_WR_WA(waTable, WaForceAllocateLML4, 1);
561 }
562 }
563 // XeHP_SDV I as P WA
564 MEDIA_WR_WA(waTable, Wa_22011549751, 1);
565 #ifdef IGFX_XEHP_SDV_ENABLE_NON_UPSTREAM
566 MEDIA_WR_WA(waTable, WaHEVCVDEncForceDeltaQpRoiNotSupported, 1);
567 #else
568 MEDIA_WR_WA(waTable, WaHEVCVDEncForceDeltaQpRoiNotSupported, 0);
569 #endif
570 return true;
571 }
572
573 static bool InitPvcMediaSku(struct GfxDeviceInfo *devInfo,
574 MediaFeatureTable *skuTable,
575 struct LinuxDriverInfo *drvInfo,
576 MediaUserSettingSharedPtr userSettingPtr)
577 {
578 if (!InitTglMediaSkuExt(devInfo, skuTable, drvInfo, &PvcCodecInfo, userSettingPtr))
579 {
580 return false;
581 }
582
583 // PVC doesn't have VEBOX and SFC
584 MEDIA_WR_SKU(skuTable, FtrSingleVeboxSlice, 0);
585 MEDIA_WR_SKU(skuTable, FtrSFCPipe, 0);
586 MEDIA_WR_SKU(skuTable, FtrVERing, 0);
587 // PVC doesn't support legacy TileY
588 MEDIA_WR_SKU(skuTable, FtrTileY, 0);
589 MEDIA_WR_SKU(skuTable, FtrVERing, 0);
590
591 MEDIA_WR_SKU(skuTable, FtrVeboxScalabilitywith4K, 0);
592
593 // Compression Flags
594 if (!(drvInfo->devId == 0x0BD0 ||
595 (drvInfo->devId == 0x0BD5 && drvInfo->devRev == 0x03)))
596 {
597 MEDIA_WR_SKU(skuTable, FtrLinearCCS, 1);
598 MEDIA_WR_SKU(skuTable, FtrFlatPhysCCS, 1);
599 MEDIA_WR_SKU(skuTable, FtrE2ECompression, 1);
600 MEDIA_WR_SKU(skuTable, FtrRenderCompressionOnly, 1);
601 MEDIA_WR_SKU(skuTable, FtrCompsitionMemoryCompressedOut, 1);
602 }
603
604 // Force MMC Turn on for all components if set reg key
605 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
606 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
607 MOS_UserFeature_ReadValue_ID(
608 nullptr,
609 __MEDIA_USER_FEATURE_VALUE_FORCE_MMC_ON_ID,
610 &userFeatureData,
611 (MOS_CONTEXT_HANDLE)nullptr);
612
613 if (userFeatureData.bData)
614 {
615 MEDIA_WR_SKU(skuTable, FtrE2ECompression, 1);
616 }
617
618 // Disable MMC for all components if set reg key
619 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
620 MOS_UserFeature_ReadValue_ID(
621 nullptr,
622 __MEDIA_USER_FEATURE_VALUE_DISABLE_MMC_ID,
623 &userFeatureData,
624 (MOS_CONTEXT_HANDLE)nullptr);
625 if (userFeatureData.bData)
626 {
627 MEDIA_WR_SKU(skuTable, FtrE2ECompression, 0);
628 }
629
630 MEDIA_WR_SKU(skuTable, FtrWithSlimVdbox, 1);
631
632 // Enable LocalMemory for all dGraphics
633 MEDIA_WR_SKU(skuTable, FtrLocalMemory, 1);
634
635 //Enable AV1 Large Scale Tile decoding
636 MEDIA_WR_SKU(skuTable, FtrAV1VLDLSTDecoding, 1);
637
638 return true;
639 }
640
641 static bool InitPvcMediaWa(struct GfxDeviceInfo *devInfo,
642 MediaWaTable *waTable,
643 struct LinuxDriverInfo *drvInfo)
644 {
645 if (!InitTglMediaWaExt(devInfo, waTable, drvInfo))
646 {
647 DEVINFO_ERROR("InitMediaWA failed\n");
648 return false;
649 }
650
651 // turn on Compression on B Step+
652 if (drvInfo->devId == 0x0BD0 ||
653 (drvInfo->devId == 0x0BD5 && drvInfo->devRev == 0x03))
654 {
655 /* Turn off MMC for codec, need to remove once turn it on */
656 MEDIA_WR_WA(waTable, WaDisableCodecMmc, 1);
657
658 /* Turn off MMC for VPP, need to remove once turn it on */
659 MEDIA_WR_WA(waTable, WaDisableVPMmc, 1);
660 }
661
662 // For PVC A0 dev, disable TLB prefetch WA
663 if (drvInfo->devId == 0x0BD0 || drvInfo->devId == 0x0BD5)
664 {
665 MEDIA_WR_WA(waTable, Wa_14012254246, 1);
666 }
667
668 // for PVC XL/XT A0 dev, need add MEM policy WA, B0 doesn't need.
669 if (drvInfo->devId == 0x0BD0 ||
670 (drvInfo->devId == 0x0BD5 && drvInfo->devRev == 0x03))
671 {
672 /* default resource allocate policy for PVC */
673 MEDIA_WR_WA(waTable, WaForceAllocateLML2, 0);
674 MEDIA_WR_WA(waTable, WaForceAllocateLML3, 1);
675 MEDIA_WR_WA(waTable, WaForceAllocateLML4, 0);
676
677 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
678 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
679 MOS_UserFeature_ReadValue_ID(
680 nullptr,
681 __MEDIA_USER_FEATURE_VALUE_LOCAL_MEMORY_LEVEL_SWITCH_ID,
682 &userFeatureData,
683 (MOS_CONTEXT_HANDLE)nullptr);
684
685 if(userFeatureData.u32Data == 2)
686 {
687 MEDIA_WR_WA(waTable, WaForceAllocateLML2, 1);
688 MEDIA_WR_WA(waTable, WaForceAllocateLML3, 0);
689 MEDIA_WR_WA(waTable, WaForceAllocateLML4, 0);
690 }
691
692 if(userFeatureData.u32Data == 3)
693 {
694 MEDIA_WR_WA(waTable, WaForceAllocateLML2, 0);
695 MEDIA_WR_WA(waTable, WaForceAllocateLML3, 1);
696 MEDIA_WR_WA(waTable, WaForceAllocateLML4, 0);
697 }
698
699 if(userFeatureData.u32Data == 4)
700 {
701 MEDIA_WR_WA(waTable, WaForceAllocateLML2, 0);
702 MEDIA_WR_WA(waTable, WaForceAllocateLML3, 1);
703 MEDIA_WR_WA(waTable, WaForceAllocateLML4, 1);
704 }
705
706 if (char* pLocalMemLevelSwitch = getenv("LOCALMEMLEVELSWITCH"))
707 {
708 int localMemLevelSwitch = atoi(pLocalMemLevelSwitch);
709
710 if(localMemLevelSwitch == 2)
711 {
712 MEDIA_WR_WA(waTable, WaForceAllocateLML2, 1);
713 MEDIA_WR_WA(waTable, WaForceAllocateLML3, 0);
714 MEDIA_WR_WA(waTable, WaForceAllocateLML4, 0);
715 }
716 else if(localMemLevelSwitch == 3)
717 {
718 MEDIA_WR_WA(waTable, WaForceAllocateLML2, 0);
719 MEDIA_WR_WA(waTable, WaForceAllocateLML3, 1);
720 MEDIA_WR_WA(waTable, WaForceAllocateLML4, 0);
721 }
722 else if(localMemLevelSwitch == 4)
723 {
724 MEDIA_WR_WA(waTable, WaForceAllocateLML2, 0);
725 MEDIA_WR_WA(waTable, WaForceAllocateLML3, 1);
726 MEDIA_WR_WA(waTable, WaForceAllocateLML4, 1);
727 }
728 }
729 }
730
731 #ifdef IGFX_PVC_ENABLE_NON_UPSTREAM
732 MEDIA_WR_WA(waTable, WaHEVCVDEncForceDeltaQpRoiNotSupported, 1);
733 #else
734 MEDIA_WR_WA(waTable, WaHEVCVDEncForceDeltaQpRoiNotSupported, 0);
735 #endif
736
737 // I as P WA
738 MEDIA_WR_WA(waTable, Wa_22011549751, 1);
739
740 // Remove the WA of DummyReference
741 MEDIA_WR_WA(waTable, WaDummyReference, 0);
742
743 return true;
744 }
745
746 static bool InitDg2MediaSku(struct GfxDeviceInfo *devInfo,
747 MediaFeatureTable *skuTable,
748 struct LinuxDriverInfo *drvInfo,
749 MediaUserSettingSharedPtr userSettingPtr)
750 {
751 if (!InitTglMediaSkuExt(devInfo, skuTable, drvInfo, &Dg2CodecInfo, userSettingPtr))
752 {
753 return false;
754 }
755
756 // Disable CCS on DG2A
757 if (drvInfo->devRev == 0)
758 {
759 MEDIA_WR_SKU(skuTable, FtrCCSNode, 0);
760 }
761
762 if (drvInfo->hasBsd)
763 {
764 /* AV1 VDENC 8/10Bit 420 */
765 MEDIA_WR_SKU(skuTable, FtrEncodeAV1Vdenc, 1);
766 MEDIA_WR_SKU(skuTable, FtrEncodeAV1Vdenc10bit420, 1);
767 }
768
769 MEDIA_WR_SKU(skuTable, FtrSfcScalability, 1);
770
771 // Guc Submission
772 MEDIA_WR_SKU(skuTable, FtrGucSubmission, 1);
773
774 MEDIA_WR_SKU(skuTable, FtrTileY, 0);
775 MEDIA_WR_SKU(skuTable, FtrE2ECompression, 1);
776 MEDIA_WR_SKU(skuTable, FtrLinearCCS, 1);
777 MEDIA_WR_SKU(skuTable, FtrFlatPhysCCS, 1);
778 MEDIA_WR_SKU(skuTable, FtrCompsitionMemoryCompressedOut, 1);
779
780 // Enable LocalMemory for all dGraphics
781 MEDIA_WR_SKU(skuTable, FtrLocalMemory, 1);
782
783 // Enable AV1 Large Scale Tile decoding
784 MEDIA_WR_SKU(skuTable, FtrAV1VLDLSTDecoding, 1);
785
786 // Enable HDR
787 MEDIA_WR_SKU(skuTable, FtrHDR, 1);
788
789 // Enable down scaling first if 3DLUT enabled
790 MEDIA_WR_SKU(skuTable, FtrScalingFirst, 1);
791
792 // Disable HEVC 422 Virtual Tile Scalability
793 MEDIA_WR_SKU(skuTable, FtrDecodeHEVC422VTScalaDisable, 1);
794
795 // Tile64
796 if (drvInfo->devRev >= 0x04 &&
797 (drvInfo->devId == 0x4F80 ||
798 drvInfo->devId == 0x4F81 ||
799 drvInfo->devId == 0x4F82 ||
800 drvInfo->devId == 0x4F83 ||
801 drvInfo->devId == 0x4F84 ||
802 drvInfo->devId == 0x4F85 ||
803 drvInfo->devId == 0x4F86 ||
804 drvInfo->devId == 0x5690 ||
805 drvInfo->devId == 0x5691 ||
806 drvInfo->devId == 0x5692 ||
807 drvInfo->devId == 0x5695 ||
808 drvInfo->devId == 0x5696 ||
809 drvInfo->devId == 0x5697 ||
810 drvInfo->devId == 0x5698 ||
811 drvInfo->devId == 0x56A0 ||
812 drvInfo->devId == 0x56A1 ||
813 drvInfo->devId == 0x56A2 ||
814 drvInfo->devId == 0x56A3 ||
815 drvInfo->devId == 0x56A4 ||
816 drvInfo->devId == 0x56A5 ||
817 drvInfo->devId == 0x56A6 ||
818 drvInfo->devId == 0x56A7 ||
819 drvInfo->devId == 0x56A8 ||
820 drvInfo->devId == 0x56A9 ||
821 drvInfo->devId == 0x56C0))
822 {
823 MEDIA_WR_SKU(skuTable, FtrTileY, 0);
824 }
825
826 MEDIA_WR_SKU(skuTable, FtrHDR, 1);
827
828 // Enable HVS Denoise
829 MEDIA_WR_SKU(skuTable, FtrHVSDenoise, 1);
830
831 #define IS_SERVER_SKU(d) (((d) >= 0x56C0) && ((d) <= 0x56C1))
832 if (IS_SERVER_SKU(drvInfo->devId))
833 {
834 drvInfo->isServer = 1;
835 }
836 else
837 {
838 drvInfo->isServer = 0;
839 }
840
841 return true;
842 }
843
844 static bool InitDg2MediaWa(struct GfxDeviceInfo *devInfo,
845 MediaWaTable *waTable,
846 struct LinuxDriverInfo *drvInfo)
847 {
848 if (!InitTglMediaWaExt(devInfo, waTable, drvInfo))
849 {
850 DEVINFO_ERROR("InitMediaWA failed\n");
851 return false;
852 }
853
854 /* Turn off MMC for codec, need to remove once turn it on */
855 MEDIA_WR_WA(waTable, WaDisableCodecMmc, 1);
856
857 /* Turn off MMC for VPP, need to remove once turn it on */
858 MEDIA_WR_WA(waTable, WaDisableVPMmc, 1);
859
860 // Compression Settings
861 if (SI_WA_FROM(drvInfo->devRev, ACM_G10_MEDIA_REV_ID_B0) ||
862 GFX_IS_DG2_G11_CONFIG(drvInfo->devId))
863 {
864 /* Turn on MMC for codec and vpp*/
865 MEDIA_WR_WA(waTable, WaDisableCodecMmc, 0);
866 MEDIA_WR_WA(waTable, WaDisableVPMmc, 0);
867 }
868
869 if (GFX_IS_DG2_G11_CONFIG(drvInfo->devId) ||
870 (GFX_IS_DG2_G10_CONFIG(drvInfo->devId) && SI_WA_FROM(drvInfo->devRev, ACM_G10_MEDIA_REV_ID_B0)))
871 {
872 MEDIA_WR_WA(waTable, Wa_22011700429, 1);
873 }
874
875 // For DG2 128/512 need to distinguish A stepping and B stepping
876 // Disable B+ stepping features on DG2A
877 if (GFX_IS_DG2_G10_CONFIG(drvInfo->devId) ||
878 GFX_IS_DG2_G11_CONFIG(drvInfo->devId))
879 {
880 if (drvInfo->devRev < 4)
881 {
882 MEDIA_WR_WA(waTable, WaEnableOnlyASteppingFeatures, 1);
883 MEDIA_WR_WA(waTable, Wa_14010476401, 1);
884 MEDIA_WR_WA(waTable, Wa_22011531258, 1);
885 MEDIA_WR_WA(waTable, Wa_2209975292, 1);
886 MEDIA_WR_WA(waTable, WaHEVCVDEncForceDeltaQpRoiNotSupported, 1);
887 }
888 MEDIA_WR_WA(waTable, Wa_22011549751, 1);
889 }
890
891 // for DG2 256EU, support B+ features, don't need wa for A stepping
892 if (GFX_IS_DG2_G12_CONFIG(drvInfo->devId))
893 {
894 MEDIA_WR_WA(waTable, Wa_22011549751, 1);
895 }
896
897 // CCS Chromakey
898 if (GFX_IS_DG2_G11_CONFIG(drvInfo->devId))
899 {
900 MEDIA_WR_WA(waTable, Wa_16011481064, 1);
901 }
902 else
903 {
904 if (drvInfo->devRev >= 4)
905 {
906 MEDIA_WR_WA(waTable, Wa_16011481064, 1);
907 }
908 }
909
910 MEDIA_WR_WA(waTable, Wa_15010089951, 1);
911
912 // Remove the WA of DummyReference
913 MEDIA_WR_WA(waTable, WaDummyReference, 0);
914
915 MEDIA_WR_WA(waTable, WaDisableSetObjectCapture, 1);
916
917 MEDIA_WR_WA(waTable, Wa_15013355402, 1);
918
919 MEDIA_WR_WA(waTable, Wa_AvcUnalignedHeight, 0);
920
921 return true;
922 }
923
924
925 static struct LinuxDeviceInit xehpSDVDeviceInit =
926 {
927 .productFamily = IGFX_XE_HP_SDV,
928 .InitMediaFeature = InitXehpSDVMediaSku,
929 .InitMediaWa = InitXehpSDVMediaWa,
930 };
931
932 static bool xehpSDVDeviceRegister = DeviceInfoFactory<LinuxDeviceInit>::
933 RegisterDevice(IGFX_XE_HP_SDV, &xehpSDVDeviceInit);
934
935 static struct LinuxDeviceInit dg2DeviceInit =
936 {
937 .productFamily = IGFX_DG2,
938 .InitMediaFeature = InitDg2MediaSku,
939 .InitMediaWa = InitDg2MediaWa,
940 };
941
942 static bool dg2DeviceRegister = DeviceInfoFactory<LinuxDeviceInit>::
943 RegisterDevice(IGFX_DG2, &dg2DeviceInit);
944
945 static struct LinuxDeviceInit pvcDeviceInit =
946 {
947 .productFamily = IGFX_PVC,
948 .InitMediaFeature = InitPvcMediaSku,
949 .InitMediaWa = InitPvcMediaWa,
950 };
951
952 static bool pvcDeviceRegister = DeviceInfoFactory<LinuxDeviceInit>::
953 RegisterDevice(IGFX_PVC, &pvcDeviceInit);