Debian Codegraph @

media_driver/linux/gen12/ddi/media_sku_wa_g12.cpp

raw
1 /*
2 * Copyright (c) 2018-2023, 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_g12.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 static constexpr uint32_t singleVeboxSubSliceNumMax = 24;
37
38 //extern template class DeviceInfoFactory<GfxDeviceInfo>;
39 typedef DeviceInfoFactory<LinuxDeviceInit> DeviceInit;
40
41 static struct LinuxCodecInfo tglCodecInfo =
42 {
43 .avcDecoding = 1,
44 .mpeg2Decoding = 1,
45 .vp8Decoding = 1,
46 .vc1Decoding = SET_STATUS_BY_FULL_OPEN_SOURCE(1, 0),
47 .jpegDecoding = 1,
48 .avcEncoding = SET_STATUS_BY_FULL_OPEN_SOURCE(1, 0),
49 .mpeg2Encoding = SET_STATUS_BY_FULL_OPEN_SOURCE(1, 0),
50 .hevcDecoding = 1,
51 .hevcEncoding = SET_STATUS_BY_FULL_OPEN_SOURCE(1, 0),
52 .jpegEncoding = 1,
53 .avcVdenc = 1,
54 .vp9Decoding = 1,
55 .hevc10Decoding = 1,
56 .vp9b10Decoding = 1,
57 .hevc10Encoding = SET_STATUS_BY_FULL_OPEN_SOURCE(1, 0),
58 .hevc12Encoding = SET_STATUS_BY_FULL_OPEN_SOURCE(1, 0),
59 .vp8Encoding = 0,
60 .hevcVdenc = 1,
61 .vp9Vdenc = 1,
62 .adv0Decoding = SET_STATUS_BY_FULL_OPEN_SOURCE(1, 0),
63 .adv1Decoding = SET_STATUS_BY_FULL_OPEN_SOURCE(1, 0),
64 };
65
66 static bool InitTglMediaSku(struct GfxDeviceInfo *devInfo,
67 MediaFeatureTable *skuTable,
68 struct LinuxDriverInfo *drvInfo,
69 MediaUserSettingSharedPtr userSettingPtr)
70 {
71 if ((devInfo == nullptr) || (skuTable == nullptr) || (drvInfo == nullptr))
72 {
73 DEVINFO_ERROR("null ptr is passed\n");
74 return false;
75 }
76
77 if (drvInfo->hasBsd)
78 {
79 LinuxCodecInfo *codecInfo = &tglCodecInfo;
80
81 if (devInfo->productFamily == IGFX_TIGERLAKE_LP &&
82 drvInfo->devRev == 0)
83 {
84 codecInfo->adv0Decoding = 0;
85 codecInfo->adv1Decoding = 0;
86 }
87
88 MEDIA_WR_SKU(skuTable, FtrAVCVLDLongDecoding, codecInfo->avcDecoding);
89 MEDIA_WR_SKU(skuTable, FtrMPEG2VLDDecoding, codecInfo->mpeg2Decoding);
90 MEDIA_WR_SKU(skuTable, FtrIntelVP8VLDDecoding, codecInfo->vp8Decoding);
91 MEDIA_WR_SKU(skuTable, FtrVC1VLDDecoding, codecInfo->vc1Decoding);
92 MEDIA_WR_SKU(skuTable, FtrIntelJPEGDecoding, codecInfo->jpegDecoding);
93 MEDIA_WR_SKU(skuTable, FtrEncodeAVC, codecInfo->avcEncoding);
94 MEDIA_WR_SKU(skuTable, FtrEncodeMPEG2, codecInfo->mpeg2Encoding);
95 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMainDecoding, codecInfo->hevcDecoding);
96 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMain10Decoding, codecInfo->hevc10Decoding);
97
98 MEDIA_WR_SKU(skuTable, FtrEncodeHEVC, codecInfo->hevcEncoding);
99 MEDIA_WR_SKU(skuTable, FtrEncodeHEVC10bit, codecInfo->hevc10Encoding);
100 MEDIA_WR_SKU(skuTable, FtrEncodeHEVC12bit, codecInfo->hevc12Encoding);
101 MEDIA_WR_SKU(skuTable, FtrEncodeHEVC10bit422, codecInfo->hevc10Encoding);
102 MEDIA_WR_SKU(skuTable, FtrEncodeHEVC12bit422, codecInfo->hevc12Encoding);
103 MEDIA_WR_SKU(skuTable, FtrEncodeJPEG, codecInfo->jpegEncoding);
104 MEDIA_WR_SKU(skuTable, FtrEncodeAVCVdenc, codecInfo->avcVdenc);
105 MEDIA_WR_SKU(skuTable, FtrVP9VLDDecoding, codecInfo->vp9Decoding);
106 MEDIA_WR_SKU(skuTable, FtrIntelVP9VLDProfile0Decoding8bit420, codecInfo->vp9Decoding);
107 MEDIA_WR_SKU(skuTable, FtrVP9VLD10bProfile2Decoding, codecInfo->vp9b10Decoding);
108 MEDIA_WR_SKU(skuTable, FtrIntelVP9VLDProfile2Decoding, codecInfo->vp9b10Decoding);
109 MEDIA_WR_SKU(skuTable, FtrIntelAV1VLDDecoding8bit420, codecInfo->adv0Decoding);
110 MEDIA_WR_SKU(skuTable, FtrIntelAV1VLDDecoding10bit420, codecInfo->adv1Decoding);
111
112 /* VP8 enc */
113 MEDIA_WR_SKU(skuTable, FtrEncodeVP8, codecInfo->vp8Encoding);
114
115 /* HEVC VDENC */
116 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain, codecInfo->hevcVdenc);
117 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain10, codecInfo->hevcVdenc);
118
119 /* Vp9 VDENC */
120 MEDIA_WR_SKU(skuTable, FtrEncodeVP9Vdenc, codecInfo->vp9Vdenc);
121
122 /* HEVC Main8/10bit-422/444 Decoding. Currently it is enabled. */
123 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLD42210bitDecoding, 1);
124 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLD4448bitDecoding, 1);
125 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLD44410bitDecoding, 1);
126
127 /* SFC Histogram Streamout. */
128 MEDIA_WR_SKU(skuTable, FtrSFCHistogramStreamOut, 1);
129
130 /* Subset buffer for realtile decoding. */
131 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDDecodingSubsetBuffer, 1);
132
133 /* HEVC Main8/10bit-420/422/444 Scc Decoding. Currently it is enabled. */
134 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMain8bit420SCC, 1);
135 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMain10bit420SCC, 1);
136 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMain8bit444SCC, 1);
137 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMain10bit444SCC, 1);
138
139 /* HEVC VDENC Main8/10 422/444 Encoding. */
140 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain444, codecInfo->hevcVdenc);
141 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain422, 0);
142 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain10bit422, 0);
143 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain10bit444, codecInfo->hevcVdenc);
144
145 /* HEVC VDENC Main8/10bit-420/422/444 Scc Encoding. */
146 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMainSCC, codecInfo->hevcVdenc);
147 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain10bitSCC, codecInfo->hevcVdenc);
148 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain444SCC, codecInfo->hevcVdenc);
149 MEDIA_WR_SKU(skuTable, FtrEncodeHEVCVdencMain10bit444SCC, codecInfo->hevcVdenc);
150
151 /* HEVC 12bit Decoding. Currently it is enabled */
152 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMain12bit420Decoding, 1);
153 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMain12bit422Decoding, 1);
154 MEDIA_WR_SKU(skuTable, FtrIntelHEVCVLDMain12bit444Decoding, 1);
155
156 /* VP9 8 bit 444 */
157 MEDIA_WR_SKU(skuTable, FtrIntelVP9VLDProfile1Decoding8bit444, 1);
158 /* VP9 10 Bit 444*/
159 MEDIA_WR_SKU(skuTable, FtrIntelVP9VLDProfile3Decoding10bit444, 1);
160 /* VP9 12 bit 420/444 */
161 MEDIA_WR_SKU(skuTable, FtrIntelVP9VLDProfile2Decoding12bit420, 1);
162 MEDIA_WR_SKU(skuTable, FtrIntelVP9VLDProfile3Decoding12bit444, 1);
163
164 /* VP9 VDENC 8Bit 444 */
165 MEDIA_WR_SKU(skuTable, FtrEncodeVP9Vdenc8bit444, codecInfo->vp9Vdenc);
166 /* VP9 VDENC 10Bit 420/444 */
167 MEDIA_WR_SKU(skuTable, FtrEncodeVP9Vdenc10bit420, codecInfo->vp9Vdenc);
168 MEDIA_WR_SKU(skuTable, FtrEncodeVP9Vdenc10bit444, codecInfo->vp9Vdenc);
169 }
170
171 MEDIA_WR_SKU(skuTable, FtrEnableMediaKernels, drvInfo->hasHuc);
172
173 if (devInfo->eGTType == GTTYPE_GT1)
174 {
175 MEDIA_WR_SKU(skuTable, FtrGT1, 1);
176 }
177 else if (devInfo->eGTType == GTTYPE_GT1_5)
178 {
179 MEDIA_WR_SKU(skuTable, FtrGT1_5, 1);
180 }
181 else if (devInfo->eGTType == GTTYPE_GT2)
182 {
183 MEDIA_WR_SKU(skuTable, FtrGT2, 1);
184 }
185 else if (devInfo->eGTType == GTTYPE_GT3)
186 {
187 MEDIA_WR_SKU(skuTable, FtrGT3, 1);
188 }
189 else if (devInfo->eGTType == GTTYPE_GT4)
190 {
191 MEDIA_WR_SKU(skuTable, FtrGT4, 1);
192 }
193 else
194 {
195 /* GT1 is by default */
196 MEDIA_WR_SKU(skuTable, FtrGT1, 1);
197 }
198
199 MEDIA_WR_SKU(skuTable, FtrVERing, drvInfo->hasVebox);
200 MEDIA_WR_SKU(skuTable, FtrPPGTT, drvInfo->hasPpgtt);
201 MEDIA_WR_SKU(skuTable, FtrEDram, devInfo->hasERAM);
202
203 /* Virtual VDBOX ring is used on Gen12 */
204 MEDIA_WR_SKU(skuTable, FtrVcs2, 0);
205
206 MEDIA_WR_SKU(skuTable, FtrSingleVeboxSlice, 1);
207 if (devInfo->SubSliceCount >= singleVeboxSubSliceNumMax)
208 {
209 MEDIA_WR_SKU(skuTable, FtrSingleVeboxSlice, 0);
210 }
211
212 MEDIA_WR_SKU(skuTable, FtrSFCPipe, 1);
213 MEDIA_WR_SKU(skuTable, FtrHCP2SFCPipe, 1);
214 MEDIA_WR_SKU(skuTable, FtrSSEUPowerGating, 1);
215 MEDIA_WR_SKU(skuTable, FtrSSEUPowerGatingControlByUMD, 1);
216
217 MEDIA_WR_SKU(skuTable, FtrPerCtxtPreemptionGranularityControl, 1);
218
219 /* It is disabled by default. It can be enabled based on HW */
220 MEDIA_WR_SKU(skuTable, FtrMemoryCompression, 0);
221 MEDIA_WR_SKU(skuTable, FtrHcpDecMemoryCompression, 0);
222 MEDIA_WR_SKU(skuTable, Ftr10bitDecMemoryCompression, 0);
223
224 MEDIA_WR_SKU(skuTable, FtrRAMode, 1);
225 MEDIA_WR_SKU(skuTable, FtrVpP010Output, 1);
226 MEDIA_WR_SKU(skuTable, FtrVp10BitSupport, 1);
227 MEDIA_WR_SKU(skuTable, FtrVp16BitSupport, 1);
228
229 MEDIA_WR_SKU(skuTable, FtrContextBasedScheduling, 1);
230 MEDIA_WR_SKU(skuTable, FtrSfcScalability, 1);
231
232 MEDIA_WR_SKU(skuTable, FtrTileY, 1);
233
234 bool disableMMC = false;
235 MEDIA_WR_SKU(skuTable, FtrE2ECompression, 1);
236
237 if (drvInfo->devRev <= 2)
238 {
239 // turn off Compression as HW known issue
240 MEDIA_WR_SKU(skuTable, FtrE2ECompression, 0);
241 }
242
243 // Disable MMC for all components if set reg key
244 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
245 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
246 MOS_UserFeature_ReadValue_ID(
247 nullptr,
248 __MEDIA_USER_FEATURE_VALUE_DISABLE_MMC_ID,
249 &userFeatureData,
250 (MOS_CONTEXT_HANDLE)nullptr);
251 if (userFeatureData.bData)
252 {
253 disableMMC = true;
254 }
255
256 if (disableMMC)
257 {
258 MEDIA_WR_SKU(skuTable, FtrE2ECompression, 0);
259 }
260
261 // Force MMC Turn on for all components if set reg key
262 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
263 MOS_UserFeature_ReadValue_ID(
264 nullptr,
265 __MEDIA_USER_FEATURE_VALUE_FORCE_MMC_ON_ID,
266 &userFeatureData,
267 (MOS_CONTEXT_HANDLE)nullptr);
268
269 if (userFeatureData.bData)
270 {
271 MEDIA_WR_SKU(skuTable, FtrE2ECompression, 1);
272 }
273
274 MEDIA_WR_SKU(skuTable, FtrLinearCCS, 1);
275
276 MEDIA_WR_SKU(skuTable, FtrUseSwSwizzling, 1);
277 MEDIA_WR_SKU(skuTable, FtrScalingFirst, 1);
278
279 // Create uncompressible surface by default
280 MEDIA_WR_SKU(skuTable, FtrCompressibleSurfaceDefault, 0);
281
282 bool compressibleSurfaceEnable = false;
283
284 ReadUserSetting(userSettingPtr,
285 compressibleSurfaceEnable,
286 "Enable Compressible Surface Creation",
287 MediaUserSetting::Group::Device);
288
289 if (compressibleSurfaceEnable)
290 {
291 MEDIA_WR_SKU(skuTable, FtrCompressibleSurfaceDefault, 1);
292 }
293
294 MEDIA_WR_SKU(skuTable, FtrHDR, 1);
295
296 return true;
297 }
298
299 static bool InitTglMediaWa(struct GfxDeviceInfo *devInfo,
300 MediaWaTable *waTable,
301 struct LinuxDriverInfo *drvInfo)
302 {
303 if ((devInfo == nullptr) || (waTable == nullptr) || (drvInfo == nullptr))
304 {
305 DEVINFO_ERROR("null ptr is passed\n");
306 return false;
307 }
308
309 MEDIA_WR_WA(waTable, WaForceGlobalGTT, !drvInfo->hasPpgtt);
310 MEDIA_WR_WA(waTable, WaMidBatchPreemption, 0);
311 MEDIA_WR_WA(waTable, WaArbitraryNumMbsInSlice, 1);
312
313 MEDIA_WR_WA(waTable, WaSuperSliceHeaderPacking, 1);
314
315 MEDIA_WR_WA(waTable, WaSFC270DegreeRotation, 0);
316
317 MEDIA_WR_WA(waTable, WaEnableYV12BugFixInHalfSliceChicken7, 1);
318
319 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
320 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
321 MOS_UserFeature_ReadValue_ID(
322 nullptr,
323 __MEDIA_USER_FEATURE_VALUE_AUX_TABLE_16K_GRANULAR_ID,
324 &userFeatureData,
325 (MOS_CONTEXT_HANDLE)nullptr);
326
327 MEDIA_WR_WA(waTable, WaDummyReference, 1);
328
329 /*software wa to add a dummy workload in front of
330 normal workload per batch buffer*/
331 MEDIA_WR_WA(waTable, Wa_1508208842, 1);
332
333 MEDIA_WR_WA(waTable, Wa16KInputHeightNV12Planar420, 1);
334
335 /*software wa to disable calculate the UV offset by gmmlib
336 CPU blt call will add/remove padding on the platform*/
337 MEDIA_WR_WA(waTable, WaDisableGmmLibOffsetInDeriveImage, 1);
338
339 /*software wa to fix some corner cases of HEVC/VP9 SFC and Scalability*/
340 MEDIA_WR_WA(waTable, Wa_14010222001, 1);
341
342 /*software wa to fix some corner hang cases for Scalability*/
343 MEDIA_WR_WA(waTable, Wa_2209620131, 1);
344
345 /*software wa to prevent error propagation for vertical intra refresh on H264 VDEnc*/
346 MEDIA_WR_WA(waTable, Wa_18011246551, 1);
347
348 MEDIA_WR_WA(waTable, WaDisableVeboxFor8K, 1);
349
350 if (drvInfo->devRev == 0)
351 {
352 /* Turn off MMC for codec, need to remove once turn it on */
353 MEDIA_WR_WA(waTable, WaDisableCodecMmc, 1);
354
355 /* Turn off MMC for VPP, need to remove once turn it on */
356 MEDIA_WR_WA(waTable, WaDisableVPMmc, 1);
357 }
358
359 /*software wa to use frame based decoding for AV1 decode*/
360 MEDIA_WR_WA(waTable, Wa_1409820462, 1);
361
362 /*software wa to use huc copy for init aux table for MFX*/
363 MEDIA_WR_WA(waTable, Wa_22010493002, 1);
364
365 MEDIA_WR_WA(waTable, Wa_Vp9UnalignedHeight, 1);
366 MEDIA_WR_WA(waTable, Wa_AvcUnalignedHeight, 1);
367 MEDIA_WR_WA(waTable, WaDisableSetObjectCapture, 0);
368 return true;
369 }
370
371
372 #ifdef IGFX_GEN12_DG1_SUPPORTED
373 static bool InitDG1MediaSku(struct GfxDeviceInfo *devInfo,
374 MediaFeatureTable *skuTable,
375 struct LinuxDriverInfo *drvInfo,
376 MediaUserSettingSharedPtr userSettingPtr)
377 {
378 if (!InitTglMediaSku(devInfo, skuTable, drvInfo, userSettingPtr))
379 {
380 return false;
381 }
382 MEDIA_WR_SKU(skuTable, FtrLocalMemory, 1);
383
384 if (drvInfo->devRev > 0)
385 {
386 MEDIA_WR_SKU(skuTable, FtrAV1VLDLSTDecoding, 1);
387 }
388 MEDIA_WR_SKU(skuTable, FtrIntelVP8VLDDecoding, 0);
389
390 bool enableCodecMMC = false;
391 bool enableVPMMC = false;
392
393 // Disable MMC for all components if set reg key
394 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
395 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
396 MOS_UserFeature_ReadValue_ID(
397 nullptr,
398 __VPHAL_ENABLE_MMC_ID,
399 &userFeatureData,
400 (MOS_CONTEXT_HANDLE)nullptr);
401 if (userFeatureData.bData)
402 {
403 enableVPMMC = true;
404 }
405
406 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
407 MOS_UserFeature_ReadValue_ID(
408 nullptr,
409 __MEDIA_USER_FEATURE_VALUE_CODEC_MMC_ENABLE_ID,
410 &userFeatureData,
411 (MOS_CONTEXT_HANDLE)nullptr);
412 if (userFeatureData.bData)
413 {
414 enableCodecMMC = true;
415 }
416
417 if (!enableCodecMMC && !enableVPMMC)
418 {
419 MEDIA_WR_SKU(skuTable, FtrE2ECompression, 0);
420 }
421
422 return true;
423 }
424
425 static bool InitDG1MediaWa(struct GfxDeviceInfo *devInfo,
426 MediaWaTable *waTable,
427 struct LinuxDriverInfo *drvInfo)
428 {
429 if (!InitTglMediaWa(devInfo, waTable, drvInfo))
430 {
431 DEVINFO_ERROR("InitMediaWA failed\n");
432 return false;
433 }
434
435 /* Turn off MMC for codec, need to remove once turn it on */
436 MEDIA_WR_WA(waTable, WaDisableCodecMmc, 1);
437
438 /* Turn off MMC for VPP, need to remove once turn it on */
439 MEDIA_WR_WA(waTable, WaDisableVPMmc, 1);
440
441 /* Enable VPP copy */
442 MEDIA_WR_WA(waTable, WaEnableVPPCopy, 1);
443
444 MEDIA_WR_WA(waTable, WaDisableSetObjectCapture, 1);
445
446 return true;
447 }
448
449 static struct LinuxDeviceInit dg1DeviceInit =
450 {
451 .productFamily = IGFX_DG1,
452 .InitMediaFeature = InitDG1MediaSku,
453 .InitMediaWa = InitDG1MediaWa,
454 };
455
456 static bool dg1DeviceRegister = DeviceInfoFactory<LinuxDeviceInit>::
457 RegisterDevice(IGFX_DG1, &dg1DeviceInit);
458
459 #endif
460
461 #ifdef IGFX_GEN12_RKL_SUPPORTED
462 static bool InitRKLMediaSku(struct GfxDeviceInfo *devInfo,
463 MediaFeatureTable * skuTable,
464 struct LinuxDriverInfo *drvInfo,
465 MediaUserSettingSharedPtr userSettingPtr)
466 {
467 if (!InitTglMediaSku(devInfo, skuTable, drvInfo, userSettingPtr))
468 {
469 return false;
470 }
471
472 if (devInfo->eGTType == GTTYPE_GT0_5)
473 {
474 MEDIA_WR_SKU(skuTable, FtrGT0_5, 1);
475 }
476
477 MEDIA_WR_SKU(skuTable, FtrSfcScalability, 0);
478 MEDIA_WR_SKU(skuTable, FtrIntelVP8VLDDecoding, 0);
479
480 // turn off Compression on RKL as HW known issue
481 MEDIA_WR_SKU(skuTable, FtrE2ECompression, 0);
482 return true;
483 }
484
485 static bool InitRKLMediaWa(struct GfxDeviceInfo *devInfo,
486 MediaWaTable * waTable,
487 struct LinuxDriverInfo * drvInfo)
488 {
489 if (!InitTglMediaWa(devInfo, waTable, drvInfo))
490 {
491 return false;
492 }
493
494 return true;
495 }
496
497 static struct LinuxDeviceInit rklDeviceInit =
498 {
499 .productFamily = IGFX_ROCKETLAKE,
500 .InitMediaFeature = InitRKLMediaSku,
501 .InitMediaWa = InitRKLMediaWa,
502 };
503
504 static bool rklDeviceRegister = DeviceInfoFactory<LinuxDeviceInit>::
505 RegisterDevice(IGFX_ROCKETLAKE, &rklDeviceInit);
506
507 #endif
508
509 #ifdef IGFX_GEN12_ADLS_SUPPORTED
510 static bool InitAdlsMediaSku(struct GfxDeviceInfo *devInfo,
511 MediaFeatureTable *skuTable,
512 struct LinuxDriverInfo *drvInfo,
513 MediaUserSettingSharedPtr userSettingPtr)
514 {
515 if (!InitTglMediaSku(devInfo, skuTable, drvInfo, userSettingPtr))
516 {
517 return false;
518 }
519
520 if (devInfo->eGTType == GTTYPE_GT0_5)
521 {
522 MEDIA_WR_SKU(skuTable, FtrGT0_5, 1);
523 }
524
525 MEDIA_WR_SKU(skuTable, FtrAV1VLDLSTDecoding, 1);
526
527 MEDIA_WR_SKU(skuTable, FtrHeight8AlignVE3DLUTDualPipe, 1);
528
529 //Disable VP8 for ADLS
530 MEDIA_WR_SKU(skuTable, FtrIntelVP8VLDDecoding, 0);
531
532 // Disable HEVC 422 Virtual Tile Scalability
533 MEDIA_WR_SKU(skuTable, FtrDecodeHEVC422VTScalaDisable, 1);
534
535 MEDIA_WR_SKU(skuTable, FtrVirtualTileScalabilityDisable, 1);
536 MEDIA_WR_SKU(skuTable, FtrE2ECompression, 1);
537
538 //RPL-S
539 if (drvInfo->devId == 0xA780 ||
540 drvInfo->devId == 0xA781 ||
541 drvInfo->devId == 0xA782 ||
542 drvInfo->devId == 0xA783 ||
543 drvInfo->devId == 0xA788 ||
544 drvInfo->devId == 0xA789 ||
545 drvInfo->devId == 0xA78A ||
546 drvInfo->devId == 0xA78B)
547 {
548 MEDIA_WR_SKU(skuTable, FtrGucSubmission, 1);
549 }
550
551 return true;
552 }
553
554 static bool InitAdlsMediaWa(struct GfxDeviceInfo* devInfo,
555 MediaWaTable* waTable,
556 struct LinuxDriverInfo* drvInfo)
557 {
558 if (!InitTglMediaWa(devInfo, waTable, drvInfo))
559 {
560 return false;
561 }
562
563 //ADL-S not need this
564 MEDIA_WR_WA(waTable, Wa_1409820462, 0);
565
566 //ADL-S need enable MMC for all stepping
567 MEDIA_WR_WA(waTable, WaDisableCodecMmc, 0);
568 MEDIA_WR_WA(waTable, WaDisableVPMmc, 0);
569 MEDIA_WR_WA(waTable, WaDisableClearCCS, 1);
570
571 return true;
572 }
573
574 static struct LinuxDeviceInit adlsDeviceInit =
575 {
576 .productFamily = IGFX_ALDERLAKE_S,
577 .InitMediaFeature = InitAdlsMediaSku,
578 .InitMediaWa = InitAdlsMediaWa,
579 };
580
581 static bool adlsDeviceRegister = DeviceInfoFactory<LinuxDeviceInit>::
582 RegisterDevice(IGFX_ALDERLAKE_S, &adlsDeviceInit);
583 #endif
584
585
586 #ifdef IGFX_GEN12_ADLP_SUPPORTED
587 static bool InitAdlpMediaSku(struct GfxDeviceInfo *devInfo,
588 MediaFeatureTable * skuTable,
589 struct LinuxDriverInfo *drvInfo,
590 MediaUserSettingSharedPtr userSettingPtr)
591 {
592 if (!InitTglMediaSku(devInfo, skuTable, drvInfo, userSettingPtr))
593 {
594 return false;
595 }
596
597 if (devInfo->eGTType == GTTYPE_GT0_5)
598 {
599 MEDIA_WR_SKU(skuTable, FtrGT0_5, 1);
600 }
601
602 MEDIA_WR_SKU(skuTable, FtrAV1VLDLSTDecoding, 1);
603 MEDIA_WR_SKU(skuTable, FtrGucSubmission, 1);
604 MEDIA_WR_SKU(skuTable, FtrDecodeHEVC422VTScalaDisable, 1);
605 MEDIA_WR_SKU(skuTable, FtrVirtualTileScalabilityDisable, 1);
606
607 return true;
608 }
609
610 static bool InitAdlpMediaWa(struct GfxDeviceInfo *devInfo,
611 MediaWaTable * waTable,
612 struct LinuxDriverInfo * drvInfo)
613 {
614 if (!InitTglMediaWa(devInfo, waTable, drvInfo))
615 {
616 return false;
617 }
618
619 //ADL-P not need this
620 MEDIA_WR_WA(waTable, Wa_1409820462, 0);
621 MEDIA_WR_WA(waTable, WaDisableClearCCS, 1);
622
623 return true;
624 }
625
626 static struct LinuxDeviceInit adlpDeviceInit =
627 {
628 .productFamily = IGFX_ALDERLAKE_P,
629 .InitMediaFeature = InitAdlpMediaSku,
630 .InitMediaWa = InitAdlpMediaWa,
631 };
632
633 static bool adlpDeviceRegister = DeviceInfoFactory<LinuxDeviceInit>::
634 RegisterDevice(IGFX_ALDERLAKE_P, &adlpDeviceInit);
635
636 #endif
637
638 #ifdef IGFX_GEN12_ADLN_SUPPORTED
639 static bool InitAdlnMediaSku(struct GfxDeviceInfo *devInfo,
640 MediaFeatureTable * skuTable,
641 struct LinuxDriverInfo *drvInfo,
642 MediaUserSettingSharedPtr userSettingPtr)
643 {
644 if (!InitTglMediaSku(devInfo, skuTable, drvInfo, userSettingPtr))
645 {
646 return false;
647 }
648
649 if (devInfo->eGTType == GTTYPE_GT0_5)
650 {
651 MEDIA_WR_SKU(skuTable, FtrGT0_5, 1);
652 }
653
654 MEDIA_WR_SKU(skuTable, FtrHeight8AlignVE3DLUTDualPipe, 1);
655 MEDIA_WR_SKU(skuTable, FtrAV1VLDLSTDecoding, 1);
656 MEDIA_WR_SKU(skuTable, FtrGucSubmission, 1);
657 MEDIA_WR_SKU(skuTable, FtrDecodeHEVC422VTScalaDisable, 1);
658 MEDIA_WR_SKU(skuTable, FtrE2ECompression, 1);
659
660 return true;
661 }
662
663 static bool InitAdlnMediaWa(struct GfxDeviceInfo *devInfo,
664 MediaWaTable * waTable,
665 struct LinuxDriverInfo * drvInfo)
666 {
667 if (!InitTglMediaWa(devInfo, waTable, drvInfo))
668 {
669 return false;
670 }
671
672 //ADL-N keeps below setting same as ADL-S/ADL-P
673 MEDIA_WR_WA(waTable, Wa_1409820462, 0);
674
675 //ADL-N need enable MMC for all stepping
676 MEDIA_WR_WA(waTable, WaDisableCodecMmc, 0);
677 MEDIA_WR_WA(waTable, WaDisableVPMmc, 0);
678 MEDIA_WR_WA(waTable, WaDisableClearCCS, 1);
679
680 return true;
681 }
682
683 static struct LinuxDeviceInit adlnDeviceInit =
684 {
685 .productFamily = IGFX_ALDERLAKE_N,
686 .InitMediaFeature = InitAdlnMediaSku,
687 .InitMediaWa = InitAdlnMediaWa,
688 };
689
690 static bool adlnDeviceRegister = DeviceInfoFactory<LinuxDeviceInit>::
691 RegisterDevice(IGFX_ALDERLAKE_N, &adlnDeviceInit);
692
693 #endif
694
695 static struct LinuxDeviceInit tgllpDeviceInit =
696 {
697 .productFamily = IGFX_TIGERLAKE_LP,
698 .InitMediaFeature = InitTglMediaSku,
699 .InitMediaWa = InitTglMediaWa,
700 };
701
702 static bool tgllpDeviceRegister = DeviceInfoFactory<LinuxDeviceInit>::
703 RegisterDevice(IGFX_TIGERLAKE_LP, &tgllpDeviceInit);
704
705