1 /*
2 * Copyright (c) 2009-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 //! \file mos_interface.cpp
24 //! \brief MOS interface implementation
25 //!
26
27 #include "mos_interface.h"
28 #include "mos_os_cp_interface_specific.h"
29 #include "mos_context_specific_next.h"
30 #include "mos_gpucontext_specific_next.h"
31 #include "media_libva_common.h"
32 #include "mos_auxtable_mgr.h"
33 #include "mos_os_virtualengine_singlepipe_specific_next.h"
34 #include "mos_os_virtualengine_scalability_specific_next.h"
35 #include "mos_graphicsresource_specific_next.h"
36 #include "mos_bufmgr_priv.h"
37 #include "drm_device.h"
38 #include "media_fourcc.h"
39 #include "mos_oca_rtlog_mgr.h"
40
41 #if (_DEBUG || _RELEASE_INTERNAL)
42 #include <stdlib.h> //for simulate random OS API failure
43 #include <time.h> //for simulate random OS API failure
44 #endif
45
46 #if MOS_COMMAND_BUFFER_DUMP_SUPPORTED
47 #include <fstream>
48 #include <sstream>
49 #include <iomanip>
50 #endif
51
InitOsUtilities(DDI_DEVICE_CONTEXT ddiDeviceContext)52 MOS_STATUS MosInterface::InitOsUtilities(DDI_DEVICE_CONTEXT ddiDeviceContext)
53 {
54 MediaUserSettingSharedPtr userSettingPtr = MosGetUserSettingInstance((PMOS_CONTEXT)ddiDeviceContext);
55
56 MosUtilities::MosUtilitiesInit(userSettingPtr);
57
58 // MOS_OS_FUNCTION_ENTER need mos utilities init
59 MOS_OS_FUNCTION_ENTER;
60
61 #if (_DEBUG || _RELEASE_INTERNAL)
62 //Init MOS OS API fail simulate flags
63 MosInitOsApiFailSimulateFlag(userSettingPtr);
64 #endif
65
66 //Read user feature key here for Per Utility Tool Enabling
67 if (!g_perfutility->bPerfUtilityKey)
68 {
69 g_perfutility->dwPerfUtilityIsEnabled = 0;
70 ReadUserSetting(
71 userSettingPtr,
72 g_perfutility->dwPerfUtilityIsEnabled,
73 __MEDIA_USER_FEATURE_VALUE_PERF_UTILITY_TOOL_ENABLE,
74 MediaUserSetting::Group::Device);
75
76
77 MOS_STATUS eStatus_Perf = MOS_STATUS_SUCCESS;
78 std::string perfOutputDir = "";
79
80 eStatus_Perf = ReadUserSetting(
81 userSettingPtr,
82 perfOutputDir,
83 __MEDIA_USER_FEATURE_VALUE_PERF_OUTPUT_DIRECTORY,
84 MediaUserSetting::Group::Device);
85 if (eStatus_Perf == MOS_STATUS_SUCCESS)
86 {
87 g_perfutility->setupFilePath(perfOutputDir.c_str());
88 }
89 else
90 {
91 g_perfutility->setupFilePath();
92 }
93
94 g_perfutility->bPerfUtilityKey = true;
95 }
96
97 return MOS_STATUS_SUCCESS;
98 }
99
CloseOsUtilities(PMOS_CONTEXT mosCtx)100 MOS_STATUS MosInterface::CloseOsUtilities(PMOS_CONTEXT mosCtx)
101 {
102 MOS_OS_FUNCTION_ENTER;
103
104 MediaUserSettingSharedPtr userSettingPtr = MosInterface::MosGetUserSettingInstance(mosCtx);
105
106 // Close MOS utlities
107 MosUtilities::MosUtilitiesClose(userSettingPtr);
108
109 #if (_DEBUG || _RELEASE_INTERNAL)
110 //reset MOS init OS API simulate flags
111 MosDeinitOsApiFailSimulateFlag();
112 #endif
113
114 return MOS_STATUS_SUCCESS;
115 }
116
CreateOsDeviceContext(DDI_DEVICE_CONTEXT ddiDeviceContext,MOS_DEVICE_HANDLE * deviceContext)117 MOS_STATUS MosInterface::CreateOsDeviceContext(DDI_DEVICE_CONTEXT ddiDeviceContext, MOS_DEVICE_HANDLE *deviceContext)
118 {
119 MOS_OS_FUNCTION_ENTER;
120
121 MOS_OS_CHK_NULL_RETURN(deviceContext);
122 MOS_OS_CHK_NULL_RETURN(ddiDeviceContext);
123
124 *deviceContext = MOS_New(OsContextSpecificNext);
125
126 MOS_OS_CHK_NULL_RETURN(*deviceContext);
127
128 MOS_OS_CHK_STATUS_RETURN((*deviceContext)->Init((PMOS_CONTEXT)ddiDeviceContext));
129
130 return MOS_STATUS_SUCCESS;
131 }
132
DestroyOsDeviceContext(MOS_DEVICE_HANDLE deviceContext)133 MOS_STATUS MosInterface::DestroyOsDeviceContext(MOS_DEVICE_HANDLE deviceContext)
134 {
135 MOS_OS_FUNCTION_ENTER;
136
137 if (deviceContext)
138 {
139 deviceContext->CleanUp();
140 MOS_Delete(deviceContext);
141 deviceContext = nullptr;
142 }
143
144 return MOS_STATUS_SUCCESS;
145 }
146
CreateOsStreamState(MOS_STREAM_HANDLE * streamState,MOS_DEVICE_HANDLE deviceContext,MOS_INTERFACE_HANDLE osInterface,MOS_COMPONENT component,EXTRA_PARAMS extraParams)147 MOS_STATUS MosInterface::CreateOsStreamState(
148 MOS_STREAM_HANDLE *streamState,
149 MOS_DEVICE_HANDLE deviceContext,
150 MOS_INTERFACE_HANDLE osInterface,
151 MOS_COMPONENT component,
152 EXTRA_PARAMS extraParams)
153 {
154 MOS_STATUS eStatusUserFeature = MOS_STATUS_SUCCESS;
155 uint32_t regValue = 0;
156 MediaUserSettingSharedPtr userSettingPtr = nullptr;
157
158 MOS_OS_FUNCTION_ENTER;
159 MOS_OS_CHK_NULL_RETURN(streamState);
160 MOS_OS_CHK_NULL_RETURN(deviceContext);
161
162 *streamState = MOS_New(MosStreamState);
163 MOS_OS_CHK_NULL_RETURN(*streamState);
164
165 (*streamState)->osDeviceContext = deviceContext;
166 (*streamState)->component = component;
167 (*streamState)->currentGpuContextHandle = 0;
168
169 (*streamState)->simIsActive = false;
170 (*streamState)->mediaReset = false;
171
172 (*streamState)->usesPatchList = true;
173 (*streamState)->usesGfxAddress = !(*streamState)->usesPatchList;
174
175 userSettingPtr = MosInterface::MosGetUserSettingInstance((PMOS_CONTEXT)extraParams);
176
177 #if (_DEBUG || _RELEASE_INTERNAL)
178 ReadUserSettingForDebug(
179 userSettingPtr,
180 (*streamState)->simIsActive,
181 __MEDIA_USER_FEATURE_VALUE_SIM_ENABLE,
182 MediaUserSetting::Group::Device);
183
184 // Null HW Driver
185 // 0: Disabled
186 ReadUserSettingForDebug(
187 userSettingPtr,
188 (*streamState)->nullHwAccelerationEnable.Value,
189 __MEDIA_USER_FEATURE_VALUE_NULL_HW_ACCELERATION_ENABLE,
190 MediaUserSetting::Group::Device);
191
192 #endif
193
194 // SupportVirtualEngine flag is set by Hals
195 (*streamState)->supportVirtualEngine = false;
196 (*streamState)->useHwSemaForResSyncInVe = false;
197 (*streamState)->virtualEngineInterface = nullptr;
198 (*streamState)->veEnable = false;
199 (*streamState)->phasedSubmission = true;
200
201 auto skuTable = GetSkuTable(*streamState);
202 MOS_OS_CHK_NULL_RETURN(skuTable);
203 if (MEDIA_IS_SKU(skuTable, FtrGucSubmission))
204 {
205 (*streamState)->bParallelSubmission = true;
206 }
207
208 #if (_DEBUG || _RELEASE_INTERNAL)
209 // read the "Force VDBOX" user feature key
210 // 0: not force
211 ReadUserSettingForDebug(
212 userSettingPtr,
213 (*streamState)->eForceVdbox,
214 __MEDIA_USER_FEATURE_VALUE_FORCE_VDBOX,
215 MediaUserSetting::Group::Device);
216
217 //Read Scalable/Legacy Decode mode on Gen11+
218 //1:by default for scalable decode mode
219 //0:for legacy decode mode
220 regValue = 0;
221 eStatusUserFeature = ReadUserSetting(
222 userSettingPtr,
223 regValue,
224 __MEDIA_USER_FEATURE_VALUE_ENABLE_HCP_SCALABILITY_DECODE,
225 MediaUserSetting::Group::Device);
226
227 (*streamState)->hcpDecScalabilityMode = regValue ? MOS_SCALABILITY_ENABLE_MODE_DEFAULT : MOS_SCALABILITY_ENABLE_MODE_FALSE;
228 if((*streamState)->hcpDecScalabilityMode
229 && (eStatusUserFeature == MOS_STATUS_SUCCESS))
230 {
231 //user's value to enable scalability
232 (*streamState)->hcpDecScalabilityMode = MOS_SCALABILITY_ENABLE_MODE_USER_FORCE;
233 }
234
235 (*streamState)->frameSplit = false;
236 ReadUserSettingForDebug(
237 userSettingPtr,
238 (*streamState)->frameSplit,
239 __MEDIA_USER_FEATURE_VALUE_ENABLE_LINUX_FRAME_SPLIT,
240 MediaUserSetting::Group::Device);
241
242 regValue = 0;
243 ReadUserSettingForDebug(
244 userSettingPtr,
245 regValue,
246 __MEDIA_USER_FEATURE_VALUE_ENABLE_GUC_SUBMISSION,
247 MediaUserSetting::Group::Device);
248 (*streamState)->bParallelSubmission = (*streamState)->bParallelSubmission && regValue;
249
250 //KMD Virtual Engine DebugOverride
251 // 0: not Override
252 ReadUserSettingForDebug(
253 userSettingPtr,
254 (*streamState)->enableDbgOvrdInVirtualEngine,
255 __MEDIA_USER_FEATURE_VALUE_ENABLE_VE_DEBUG_OVERRIDE,
256 MediaUserSetting::Group::Device);
257 #endif
258
259 if (component == COMPONENT_VPCommon ||
260 component == COMPONENT_VPreP ||
261 component == COMPONENT_LibVA)
262 {
263 // UMD Vebox Virtual Engine Scalability Mode
264 // 0: disable. can set to 1 only when KMD VE is enabled.
265 regValue = 0;
266 eStatusUserFeature = ReadUserSetting(
267 userSettingPtr,
268 regValue,
269 __MEDIA_USER_FEATURE_VALUE_ENABLE_VEBOX_SCALABILITY_MODE,
270 MediaUserSetting::Group::Device);
271 (*streamState)->veboxScalabilityMode = regValue ? MOS_SCALABILITY_ENABLE_MODE_DEFAULT : MOS_SCALABILITY_ENABLE_MODE_FALSE;
272
273 #if (_DEBUG || _RELEASE_INTERNAL)
274 if((*streamState)->veboxScalabilityMode
275 && (eStatusUserFeature == MOS_STATUS_SUCCESS))
276 {
277 //user's value to enable scalability
278 (*streamState)->veboxScalabilityMode = MOS_SCALABILITY_ENABLE_MODE_USER_FORCE;
279 (*streamState)->enableDbgOvrdInVirtualEngine = true;
280
281 if ((*streamState)->eForceVebox == MOS_FORCE_VEBOX_NONE)
282 {
283 (*streamState)->eForceVebox = MOS_FORCE_VEBOX_1_2;
284 }
285 }
286 else if ((!(*streamState)->veboxScalabilityMode)
287 && (eStatusUserFeature == MOS_STATUS_SUCCESS))
288 {
289 (*streamState)->enableDbgOvrdInVirtualEngine = true;
290 (*streamState)->eForceVebox = MOS_FORCE_VEBOX_NONE;
291 }
292
293 // read the "Force VEBOX" user feature key
294 // 0: not force
295 regValue = 0;
296 ReadUserSettingForDebug(
297 userSettingPtr,
298 regValue,
299 __MEDIA_USER_FEATURE_VALUE_FORCE_VEBOX,
300 MediaUserSetting::Group::Device);
301 (*streamState)->eForceVebox = (MOS_FORCE_VEBOX)regValue;
302 #endif
303 }
304 #if (_DEBUG || _RELEASE_INTERNAL)
305 ReportUserSettingForDebug(
306 userSettingPtr,
307 __MEDIA_USER_FEATURE_VALUE_SIM_IN_USE,
308 (*streamState)->simIsActive,
309 MediaUserSetting::Group::Device);
310 #endif
311
312 MOS_OS_CHK_STATUS_RETURN(MosInterface::InitStreamParameters(*streamState, extraParams));
313
314 #if MOS_COMMAND_BUFFER_DUMP_SUPPORTED
315 DumpCommandBufferInit(*streamState);
316 #endif // MOS_COMMAND_BUFFER_DUMP_SUPPORTED
317
318 return MOS_STATUS_SUCCESS;
319 }
320
DestroyOsStreamState(MOS_STREAM_HANDLE streamState)321 MOS_STATUS MosInterface::DestroyOsStreamState(
322 MOS_STREAM_HANDLE streamState)
323 {
324 MOS_OS_FUNCTION_ENTER;
325
326 MOS_OS_CHK_NULL_RETURN(streamState);
327
328 if (streamState->mosDecompression)
329 {
330 MOS_Delete(streamState->mosDecompression);
331 streamState->mosDecompression = nullptr;
332 }
333
334 MOS_Delete(streamState);
335 streamState = nullptr;
336
337 return MOS_STATUS_SUCCESS;
338 }
339
InitStreamParameters(MOS_STREAM_HANDLE streamState,EXTRA_PARAMS extraParams)340 MOS_STATUS MosInterface::InitStreamParameters(
341 MOS_STREAM_HANDLE streamState,
342 EXTRA_PARAMS extraParams)
343 {
344 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
345 PMOS_CONTEXT context = nullptr;
346 uint32_t resetCount = 0;
347 int32_t ret = 0;
348 MOS_BUFMGR *bufMgr = nullptr;
349 int32_t fd = -1;
350 OsContextSpecificNext *osDeviceContext = nullptr;
351
352 MOS_OS_FUNCTION_ENTER;
353
354 MOS_OS_CHK_NULL_RETURN(streamState);
355 MOS_OS_CHK_NULL_RETURN(streamState->osDeviceContext);
356 MOS_OS_CHK_NULL_RETURN(extraParams);
357
358 osDeviceContext = (OsContextSpecificNext *)streamState->osDeviceContext;
359 fd = osDeviceContext->GetFd();
360 if (0 > fd)
361 {
362 MOS_OS_ASSERTMESSAGE("Invalid fd");
363 return MOS_STATUS_INVALID_HANDLE;
364 }
365
366 bufMgr = osDeviceContext->GetBufMgr();
367 MOS_OS_CHK_NULL_RETURN(bufMgr);
368
369 context = MOS_New(MOS_OS_CONTEXT);
370 MOS_OS_CHK_NULL_RETURN(context);
371
372 context->m_apoMosEnabled = true;
373 context->m_osDeviceContext = streamState->osDeviceContext;
374 context->bSimIsActive = streamState->simIsActive;
375
376 streamState->perStreamParameters = (OS_PER_STREAM_PARAMETERS)context;
377
378 context->pGmmClientContext = streamState->osDeviceContext->GetGmmClientContext();;
379
380 context->bufmgr = bufMgr;
381 context->m_gpuContextMgr = osDeviceContext->GetGpuContextMgr();
382 context->m_cmdBufMgr = osDeviceContext->GetCmdBufferMgr();
383 context->fd = fd;
384 context->pPerfData = ((PMOS_CONTEXT)extraParams)->pPerfData;
385
386 context->m_userSettingPtr = ((PMOS_CONTEXT)extraParams)->m_userSettingPtr;
387 context->m_auxTableMgr = osDeviceContext->GetAuxTableMgr();
388
389 mos_bufmgr_enable_reuse(bufMgr);
390
391 context->m_skuTable = *osDeviceContext->GetSkuTable();
392 context->m_waTable = *osDeviceContext->GetWaTable();
393 context->m_gtSystemInfo = *osDeviceContext->GetGtSysInfo();
394 context->m_platform = *osDeviceContext->GetPlatformInfo();
395 context->m_protectedGEMContext = ((PMOS_CONTEXT)extraParams)->m_protectedGEMContext;
396
397 context->bUse64BitRelocs = true;
398 context->bUseSwSwizzling = context->bSimIsActive || MEDIA_IS_SKU(&context->m_skuTable, FtrUseSwSwizzling);
399 context->bTileYFlag = MEDIA_IS_SKU(&context->m_skuTable, FtrTileY);
400
401 if (MEDIA_IS_SKU(&context->m_skuTable, FtrContextBasedScheduling))
402 {
403 MOS_TraceEventExt(EVENT_GPU_CONTEXT_CREATE, EVENT_TYPE_START,
404 &eStatus, sizeof(eStatus), nullptr, 0);
405 context->intel_context = mos_context_create_ext(context->bufmgr, 0, context->m_protectedGEMContext);
406 MOS_OS_CHK_NULL_RETURN(context->intel_context);
407 context->intel_context->vm_id = mos_vm_create(context->bufmgr);
408 if (context->intel_context->vm_id == INVALID_VM)
409 {
410 MOS_OS_ASSERTMESSAGE("Failed to create vm.\n");
411 return MOS_STATUS_UNKNOWN;
412 }
413 MOS_TraceEventExt(EVENT_GPU_CONTEXT_CREATE, EVENT_TYPE_END,
414 &context->intel_context, sizeof(void *),
415 &eStatus, sizeof(eStatus));
416 }
417 else //use legacy context create ioctl for pre-gen11 platforms
418 {
419 MOS_OS_ASSERTMESSAGE("Do not support the legacy context creation.\n");
420 MOS_FreeMemAndSetNull(context->pPerfData);
421 MOS_Delete(context);
422 streamState->perStreamParameters = nullptr;
423 return MOS_STATUS_UNIMPLEMENTED;
424 }
425 context->intel_context->pOsContext = context;
426 ret = mos_get_reset_stats(context->intel_context, &resetCount, nullptr, nullptr);
427 if (ret)
428 {
429 MOS_OS_NORMALMESSAGE("mos_get_reset_stats return error(%d)\n", ret);
430 resetCount = 0;
431 }
432 streamState->ctxPriority = 0;
433 streamState->gpuResetCount = resetCount;
434 streamState->gpuActiveBatch = 0;
435 streamState->gpuPendingBatch = 0;
436
437 context->bIsAtomSOC = false;
438 context->bFreeContext = true;
439
440 streamState->enableDecomp = true;
441
442 #ifndef ANDROID
443 {
444 context->bKMDHasVCS2 = mos_has_bsd2(context->bufmgr);
445 }
446 #endif
447 #if (_DEBUG || _RELEASE_INTERNAL)
448 // read "Linux PerformanceTag Enable" user feature key
449 uint32_t regValue = 0;
450 ReadUserSettingForDebug(
451 context->m_userSettingPtr,
452 regValue,
453 __MEDIA_USER_FEATURE_VALUE_LINUX_PERFORMANCETAG_ENABLE,
454 MediaUserSetting::Group::Device);
455
456 context->uEnablePerfTag = regValue;
457 #endif
458
459 return MOS_STATUS_SUCCESS;
460 }
461
GetInterfaceVersion(MOS_DEVICE_HANDLE deviceContext)462 uint32_t MosInterface::GetInterfaceVersion(MOS_DEVICE_HANDLE deviceContext)
463 {
464 MOS_OS_FUNCTION_ENTER;
465
466 // No interface version to get in Linux
467
468 return 0;
469 }
470
GetPlatform(MOS_STREAM_HANDLE streamState)471 PLATFORM *MosInterface::GetPlatform(MOS_STREAM_HANDLE streamState)
472 {
473 MOS_OS_FUNCTION_ENTER;
474
475 if (streamState && streamState->osDeviceContext)
476 {
477 return streamState->osDeviceContext->GetPlatformInfo();
478 }
479
480 return nullptr;
481 }
482
GetSkuTable(MOS_STREAM_HANDLE streamState)483 MEDIA_FEATURE_TABLE *MosInterface::GetSkuTable(MOS_STREAM_HANDLE streamState)
484 {
485 MOS_OS_FUNCTION_ENTER;
486
487 if (streamState && streamState->osDeviceContext)
488 {
489 return streamState->osDeviceContext->GetSkuTable();
490 }
491
492 return nullptr;
493 }
494
GetWaTable(MOS_STREAM_HANDLE streamState)495 MEDIA_WA_TABLE *MosInterface::GetWaTable(MOS_STREAM_HANDLE streamState)
496 {
497 MOS_OS_FUNCTION_ENTER;
498
499 if (streamState && streamState->osDeviceContext)
500 {
501 return streamState->osDeviceContext->GetWaTable();
502 }
503
504 return nullptr;
505 }
506
GetGtSystemInfo(MOS_STREAM_HANDLE streamState)507 MEDIA_SYSTEM_INFO *MosInterface::GetGtSystemInfo(MOS_STREAM_HANDLE streamState)
508 {
509 MOS_OS_FUNCTION_ENTER;
510
511 if (streamState && streamState->osDeviceContext)
512 {
513 return streamState->osDeviceContext->GetGtSysInfo();
514 }
515
516 return nullptr;
517 }
518
GetMediaEngineInfo(MOS_STREAM_HANDLE streamState,MEDIA_ENGINE_INFO & info)519 MOS_STATUS MosInterface::GetMediaEngineInfo(MOS_STREAM_HANDLE streamState, MEDIA_ENGINE_INFO &info)
520 {
521 MOS_OS_FUNCTION_ENTER;
522
523 auto systemInfo = MosInterface::GetGtSystemInfo(streamState);
524 MOS_OS_CHK_NULL_RETURN(systemInfo);
525
526 MosUtilities::MosZeroMemory(&info, sizeof(info));
527 info.VDBoxInfo = systemInfo->VDBoxInfo;
528 info.VEBoxInfo = systemInfo->VEBoxInfo;
529
530 return MOS_STATUS_SUCCESS;
531 }
532
GetAdapterInfo(MOS_STREAM_HANDLE streamState)533 ADAPTER_INFO *MosInterface::GetAdapterInfo(MOS_STREAM_HANDLE streamState)
534 {
535 MOS_OS_FUNCTION_ENTER;
536
537 // No adapter Info in Linux
538
539 return nullptr;
540 }
541
CreateGpuContext(MOS_STREAM_HANDLE streamState,GpuContextCreateOption & createOption,GPU_CONTEXT_HANDLE & gpuContextHandle)542 MOS_STATUS MosInterface::CreateGpuContext(
543 MOS_STREAM_HANDLE streamState,
544 GpuContextCreateOption &createOption,
545 GPU_CONTEXT_HANDLE &gpuContextHandle)
546 {
547 MOS_OS_FUNCTION_ENTER;
548
549 MOS_OS_CHK_NULL_RETURN(streamState);
550 MOS_OS_CHK_NULL_RETURN(streamState->osDeviceContext);
551
552 auto osDeviceContext = streamState->osDeviceContext;
553
554 auto gpuContextMgr = osDeviceContext->GetGpuContextMgr();
555 MOS_OS_CHK_NULL_RETURN(gpuContextMgr);
556
557 auto cmdBufMgr = osDeviceContext->GetCmdBufferMgr();
558 MOS_OS_CHK_NULL_RETURN(cmdBufMgr);
559
560 auto osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
561 MOS_OS_CHK_NULL_RETURN(osParameters);
562
563 if (createOption.gpuNode == MOS_GPU_NODE_3D && createOption.SSEUValue != 0)
564 {
565 struct drm_i915_gem_context_param_sseu sseu;
566 MosUtilities::MosZeroMemory(&sseu, sizeof(sseu));
567 sseu.engine.engine_class = I915_ENGINE_CLASS_RENDER;
568 sseu.engine.engine_instance = 0;
569
570 if (mos_get_context_param_sseu(osParameters->intel_context, &sseu))
571 {
572 MOS_OS_ASSERTMESSAGE("Failed to get sseu configuration.");
573 return MOS_STATUS_UNKNOWN;
574 };
575
576 if (mos_hweight8(osParameters->intel_context, sseu.subslice_mask) > createOption.packed.SubSliceCount)
577 {
578 sseu.subslice_mask = mos_switch_off_n_bits(osParameters->intel_context, sseu.subslice_mask,
579 mos_hweight8(osParameters->intel_context, sseu.subslice_mask) - createOption.packed.SubSliceCount);
580 }
581
582 if (mos_set_context_param_sseu(osParameters->intel_context, sseu))
583 {
584 MOS_OS_ASSERTMESSAGE("Failed to set sseu configuration.");
585 return MOS_STATUS_UNKNOWN;
586 };
587 }
588
589 MOS_GPU_NODE gpuNode = MOS_GPU_NODE_3D;
590 gpuNode = static_cast<MOS_GPU_NODE>(createOption.gpuNode);
591
592 auto gpuContext = gpuContextMgr->CreateGpuContext(gpuNode, cmdBufMgr);
593 MOS_OS_CHK_NULL_RETURN(gpuContext);
594
595 auto gpuContextSpecific = static_cast<GpuContextSpecificNext *>(gpuContext);
596 MOS_OS_CHK_NULL_RETURN(gpuContextSpecific);
597
598 MOS_OS_CHK_STATUS_RETURN(gpuContextSpecific->Init(gpuContextMgr->GetOsContext(), streamState, &createOption));
599
600 gpuContextHandle = gpuContextSpecific->GetGpuContextHandle();
601
602 return MOS_STATUS_SUCCESS;
603 }
604
GetAdapterBDF(PMOS_CONTEXT mosCtx,ADAPTER_BDF * adapterBDF)605 MOS_STATUS MosInterface::GetAdapterBDF(PMOS_CONTEXT mosCtx, ADAPTER_BDF *adapterBDF)
606 {
607 MOS_OS_FUNCTION_ENTER;
608
609 drmDevicePtr device;
610
611 MOS_OS_CHK_NULL_RETURN(mosCtx);
612 if (drmGetDevice(mosCtx->fd, &device) == 0)
613 {
614 adapterBDF->Bus = device->businfo.pci->bus;
615 adapterBDF->Device = device->businfo.pci->dev;
616 adapterBDF->Function = device->businfo.pci->func;
617 drmFreeDevice(&device);
618 }
619 else
620 {
621 adapterBDF->Data = 0;
622 }
623
624 return MOS_STATUS_SUCCESS;
625 }
626
DestroyGpuContext(MOS_STREAM_HANDLE streamState,GPU_CONTEXT_HANDLE gpuContext)627 MOS_STATUS MosInterface::DestroyGpuContext(
628 MOS_STREAM_HANDLE streamState,
629 GPU_CONTEXT_HANDLE gpuContext)
630 {
631 MOS_OS_FUNCTION_ENTER;
632
633 MOS_STATUS eStatus;
634
635 eStatus = MOS_STATUS_SUCCESS;
636
637 MOS_OS_CHK_NULL_RETURN(streamState);
638 MOS_OS_CHK_NULL_RETURN(streamState->osDeviceContext);
639 MOS_OS_ASSERT(gpuContext != MOS_GPU_CONTEXT_INVALID_HANDLE);
640
641 auto gpuContextMgr = streamState->osDeviceContext->GetGpuContextMgr();
642 MOS_OS_CHK_NULL_RETURN(gpuContextMgr);
643 auto gpuContextInstance = gpuContextMgr->GetGpuContext(gpuContext);
644 MOS_OS_CHK_NULL_RETURN(gpuContextInstance);
645
646 gpuContextMgr->DestroyGpuContext(gpuContextInstance);
647
648 return MOS_STATUS_SUCCESS;
649 }
650
SetGpuContext(MOS_STREAM_HANDLE streamState,GPU_CONTEXT_HANDLE gpuContext)651 MOS_STATUS MosInterface::SetGpuContext(
652 MOS_STREAM_HANDLE streamState,
653 GPU_CONTEXT_HANDLE gpuContext)
654 {
655 MOS_OS_FUNCTION_ENTER;
656
657 auto gpuContextMgr = streamState->osDeviceContext->GetGpuContextMgr();
658 MOS_OS_CHK_NULL_RETURN(gpuContextMgr);
659 auto gpuContextPtr = gpuContextMgr->GetGpuContext(gpuContext);
660 MOS_OS_CHK_NULL_RETURN(gpuContextPtr);
661
662 streamState->currentGpuContextHandle = gpuContext;
663
664 return MOS_STATUS_SUCCESS;
665 }
666
SetObjectCapture(PMOS_RESOURCE osResource)667 MOS_STATUS MosInterface:: SetObjectCapture(
668 PMOS_RESOURCE osResource)
669 {
670 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
671
672 //---------------------------------------
673 MOS_OS_CHK_NULL_RETURN(osResource);
674 MOS_OS_CHK_NULL_RETURN(osResource->bo);
675 //---------------------------------------
676
677 mos_bo_set_object_capture(osResource->bo);
678
679 return eStatus;
680 }
681
AddCommand(COMMAND_BUFFER_HANDLE cmdBuffer,const void * cmd,uint32_t cmdSize)682 MOS_STATUS MosInterface::AddCommand(
683 COMMAND_BUFFER_HANDLE cmdBuffer,
684 const void *cmd,
685 uint32_t cmdSize)
686 {
687 MOS_OS_FUNCTION_ENTER;
688
689 uint32_t cmdSizeDwAligned = 0;
690
691 MOS_OS_CHK_NULL_RETURN(cmdBuffer);
692 MOS_OS_CHK_NULL_RETURN(cmd);
693
694 if (cmdSize == 0)
695 {
696 MOS_OS_ASSERTMESSAGE("Incorrect command size to add to command buffer.");
697 return MOS_STATUS_INVALID_PARAMETER;
698 }
699
700 cmdSizeDwAligned = MOS_ALIGN_CEIL(cmdSize, sizeof(uint32_t));
701
702 cmdBuffer->iOffset += cmdSizeDwAligned;
703 cmdBuffer->iRemaining -= cmdSizeDwAligned;
704
705 if (cmdBuffer->iRemaining < 0)
706 {
707 cmdBuffer->iOffset -= cmdSizeDwAligned;
708 cmdBuffer->iRemaining += cmdSizeDwAligned;
709 MOS_OS_ASSERTMESSAGE("Unable to add command: remaining space = %d, command size = %d.",
710 cmdBuffer->iRemaining,
711 cmdSizeDwAligned);
712 return MOS_STATUS_UNKNOWN;
713 }
714
715 MOS_OS_VERBOSEMESSAGE("The command was successfully added: remaining space = %d, buffer size = %d.",
716 cmdBuffer->iRemaining,
717 cmdBuffer->iOffset + cmdBuffer->iRemaining);
718
719 MosUtilities::MosSecureMemcpy(cmdBuffer->pCmdPtr, cmdSize, cmd, cmdSize);
720 cmdBuffer->pCmdPtr += (cmdSizeDwAligned / sizeof(uint32_t));
721
722 return MOS_STATUS_SUCCESS;
723 }
724
725 #if MOS_COMMAND_BUFFER_DUMP_SUPPORTED
DumpIndirectStates(MOS_STREAM_HANDLE streamState,const char * filePathPrefix,std::time_t currentTime)726 MOS_STATUS MosInterface::DumpIndirectStates(MOS_STREAM_HANDLE streamState, const char *filePathPrefix, std::time_t currentTime)
727 {
728 MOS_OS_CHK_NULL_RETURN(streamState);
729 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
730 auto &inDirectStateInfoArray = streamState->indirectStateInfo;
731 const uint32_t SIZE_OF_ONE_WORD = 9;
732
733 for (auto &lastElement : inDirectStateInfoArray)
734 {
735 if (lastElement.indirectState == nullptr)
736 {
737 MOS_OS_NORMALMESSAGE("IndirectState pointer is nullptr");
738 continue;
739 }
740 uint32_t *data = (uint32_t *)lastElement.indirectState;
741 uint32_t dwordCount = lastElement.stateSize / 4;
742 uint32_t dwBytesWritten = 0;
743 uint32_t dwSizeToAllocate = 0;
744 char *outputBuffer = nullptr;
745 std::stringstream fileName;
746
747 dwSizeToAllocate = dwordCount * (SIZE_OF_ONE_WORD + 1); // Add 1 byte for the space following each Dword.
748 outputBuffer = (char *)MOS_AllocAndZeroMemory(dwSizeToAllocate); // Alloc output buffer.
749 if (outputBuffer == nullptr)
750 {
751 MOS_OS_NORMALMESSAGE("Alloc outputBuffer failed");
752 inDirectStateInfoArray.clear();
753 return MOS_STATUS_SUCCESS;
754 }
755 for (uint32_t i = 0; i < dwordCount; ++i)
756 {
757 dwBytesWritten += MosUtilities::MosSecureStringPrint(
758 outputBuffer + dwBytesWritten,
759 SIZE_OF_ONE_WORD + 1,
760 SIZE_OF_ONE_WORD + 1,
761 "%.8x ",
762 data[i]);
763 }
764 fileName << filePathPrefix << "_" << std::hex << *lastElement.gfxAddressBottom << "_" << *lastElement.gfxAddressTop << "_" << lastElement.stateName << ".txt";
765 eStatus = MosUtilities::MosAppendFileFromPtr((const char *)fileName.str().c_str(), outputBuffer, dwBytesWritten);
766 if (eStatus != MOS_STATUS_SUCCESS)
767 {
768 MOS_OS_NORMALMESSAGE("DumpIndirectStates %s failed", fileName.str().c_str());
769 }
770 MOS_FreeMemory(outputBuffer);
771 }
772 inDirectStateInfoArray.clear();
773 return eStatus;
774 }
775
DumpBindingTable(MOS_STREAM_HANDLE streamState,COMMAND_BUFFER_HANDLE cmdBuffer,MOS_GPU_NODE gpuNode,const char * filePathPrefix)776 MOS_STATUS MosInterface::DumpBindingTable(
777 MOS_STREAM_HANDLE streamState,
778 COMMAND_BUFFER_HANDLE cmdBuffer,
779 MOS_GPU_NODE gpuNode,
780 const char *filePathPrefix)
781 {
782 MOS_OS_CHK_NULL_RETURN(filePathPrefix);
783
784 if (MOS_GPU_NODE_COMPUTE == gpuNode || MOS_GPU_NODE_3D == gpuNode)
785 {
786 uint8_t *indirectState = nullptr;
787 uint32_t offset = 0;
788 uint32_t size = 0;
789 MosInterface::GetIndirectState(streamState, &indirectState, offset, size);
790
791 if (indirectState)
792 {
793 std::stringstream ss;
794 uint32_t dwordCount = size / 4;
795 uint32_t *data = (uint32_t *)indirectState;
796
797 for (uint32_t i = 0; i < dwordCount; ++i)
798 {
799 if (0 == i % 4)
800 {
801 if (0 != i)
802 {
803 ss << std::endl;
804 }
805 ss << "#0 #0";
806 }
807 ss << " " << std::hex << std::setw(8) << std::setfill('0') << data[i];
808 }
809
810 std::stringstream fileName;
811 fileName << filePathPrefix << "_binding_table.txt";
812 std::fstream fs;
813 fs.open(fileName.str(), std::ios_base::out | std::ios_base::app);
814 fs << ss.str();
815 fs.close();
816 }
817 else
818 {
819 MOS_OS_NORMALMESSAGE("nullptr == indirectState");
820 }
821 }
822
823 return MOS_STATUS_SUCCESS;
824 }
825
DumpCommandBuffer(MOS_STREAM_HANDLE streamState,COMMAND_BUFFER_HANDLE cmdBuffer)826 MOS_STATUS MosInterface::DumpCommandBuffer(
827 MOS_STREAM_HANDLE streamState,
828 COMMAND_BUFFER_HANDLE cmdBuffer)
829 {
830 MOS_OS_FUNCTION_ENTER;
831
832 static uint32_t dwCommandBufferNumber = 0;
833 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
834 char * pOutputBuffer = nullptr;
835 // Each hex value should have 9 chars.
836 uint32_t SIZE_OF_ONE_WORD = 9;
837 uint32_t dwBytesWritten = 0;
838 uint32_t dwNumberOfDwords = 0;
839 uint32_t dwSizeToAllocate = 0;
840 char sFileName[MOS_MAX_HLT_FILENAME_LEN] = {0};
841 // Maximum length of engine name is 6
842 char sEngName[6];
843 size_t nSizeFileNamePrefix = 0;
844 std::time_t currentTime = std::time(nullptr);
845
846 MOS_OS_CHK_NULL_RETURN(streamState);
847 MOS_OS_CHK_NULL_RETURN(cmdBuffer);
848
849 // Set the name of the engine that is going to be used.
850 auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
851 MOS_OS_CHK_NULL_RETURN(gpuContext);
852 MOS_GPU_NODE gpuNode = gpuContext->GetContextNode();
853 switch (gpuNode)
854 {
855 case MOS_GPU_NODE_VIDEO:
856 case MOS_GPU_NODE_VIDEO2:
857 MosUtilities::MosSecureStrcpy(sEngName, sizeof(sEngName), MOS_COMMAND_BUFFER_VIDEO_ENGINE);
858 break;
859 case MOS_GPU_NODE_COMPUTE:
860 case MOS_GPU_NODE_BLT:
861 MosUtilities::MosSecureStrcpy(sEngName, sizeof(sEngName), MOS_COMMAND_BUFFER_RENDER_ENGINE);
862 break;
863 case MOS_GPU_NODE_VE:
864 MosUtilities::MosSecureStrcpy(sEngName, sizeof(sEngName), MOS_COMMAND_BUFFER_VEBOX_ENGINE);
865 break;
866 case MOS_GPU_NODE_3D:
867 MosUtilities::MosSecureStrcpy(sEngName, sizeof(sEngName), MOS_COMMAND_BUFFER_RENDER_ENGINE);
868 break;
869 default:
870 MOS_OS_ASSERTMESSAGE("Unsupported GPU context.");
871 return eStatus;
872 }
873
874 dwNumberOfDwords = cmdBuffer->iOffset / sizeof(uint32_t);
875
876 dwSizeToAllocate =
877 dwNumberOfDwords * (SIZE_OF_ONE_WORD + 1) // Add 1 byte for the space following each Dword.
878 + 3 * SIZE_OF_ONE_WORD; // For engine and platform names.
879
880 // Alloc output buffer.
881 pOutputBuffer = (char *)MOS_AllocAndZeroMemory(dwSizeToAllocate);
882 MOS_OS_CHK_NULL_RETURN(pOutputBuffer);
883
884 dwBytesWritten = MosUtilities::MosSecureStringPrint(
885 pOutputBuffer,
886 SIZE_OF_ONE_WORD * 3,
887 SIZE_OF_ONE_WORD * 3,
888 "Eng=%s ",
889 sEngName);
890
891 if (streamState->dumpCommandBufferToFile)
892 {
893 MosUtilities::MosSecureMemcpy(sFileName, MOS_MAX_HLT_FILENAME_LEN, streamState->sDirName, MOS_MAX_HLT_FILENAME_LEN);
894
895 nSizeFileNamePrefix = strnlen(sFileName, sizeof(sFileName));
896 MosUtilities::MosSecureStringPrint(
897 sFileName + nSizeFileNamePrefix,
898 sizeof(sFileName) - nSizeFileNamePrefix,
899 sizeof(sFileName) - nSizeFileNamePrefix,
900 "%c%s%c%s_%d_%d.txt",
901 MOS_DIR_SEPERATOR,
902 MOS_COMMAND_BUFFER_OUT_DIR,
903 MOS_DIR_SEPERATOR,
904 MOS_COMMAND_BUFFER_OUT_FILE,
905 dwCommandBufferNumber,
906 currentTime);
907
908 // Write the output buffer to file.
909 if((eStatus = MosUtilities::MosWriteFileFromPtr((const char *)sFileName, pOutputBuffer, dwBytesWritten)) != MOS_STATUS_SUCCESS)
910 {
911 MOS_FreeMemory(pOutputBuffer);
912 MOS_OS_CHK_STATUS_RETURN(eStatus);
913 }
914 }
915
916 if (streamState->dumpCommandBufferAsMessages)
917 {
918 MOS_OS_NORMALMESSAGE(pOutputBuffer);
919 }
920
921 MosUtilities::MosZeroMemory(pOutputBuffer, dwBytesWritten);
922 dwBytesWritten = 0;
923
924 // Fill in the output buffer with the command buffer dwords.
925 for (uint32_t dwIndex = 0; dwIndex < dwNumberOfDwords; dwIndex++)
926 {
927 dwBytesWritten += MosUtilities::MosSecureStringPrint(
928 pOutputBuffer + dwBytesWritten,
929 SIZE_OF_ONE_WORD + 1,
930 SIZE_OF_ONE_WORD + 1,
931 "%.8x ",
932 cmdBuffer->pCmdBase[dwIndex]);
933
934 if (dwBytesWritten % (SIZE_OF_ONE_WORD + 1) == 0)
935 {
936 if (streamState->dumpCommandBufferToFile)
937 {
938 if((eStatus = MosUtilities::MosAppendFileFromPtr((const char *)sFileName, pOutputBuffer, dwBytesWritten)) != MOS_STATUS_SUCCESS)
939 {
940 MOS_FreeMemory(pOutputBuffer);
941 MOS_OS_CHK_STATUS_RETURN(eStatus);
942 }
943 }
944 if (streamState->dumpCommandBufferAsMessages)
945 {
946 MOS_OS_NORMALMESSAGE(pOutputBuffer);
947 }
948
949 MosUtilities::MosZeroMemory(pOutputBuffer, dwBytesWritten);
950 dwBytesWritten = 0;
951 }
952 }
953
954 if (streamState->dumpCommandBufferToFile)
955 {
956 if((eStatus = MosUtilities::MosAppendFileFromPtr((const char *)sFileName, pOutputBuffer, dwBytesWritten)) != MOS_STATUS_SUCCESS)
957 {
958 MOS_FreeMemory(pOutputBuffer);
959 MOS_OS_CHK_STATUS_RETURN(eStatus);
960 }
961 if ((eStatus = DumpBindingTable(streamState, cmdBuffer, gpuNode, sFileName)) != MOS_STATUS_SUCCESS)
962 {
963 MOS_FreeMemory(pOutputBuffer);
964 return eStatus;
965 }
966 if ((eStatus = DumpIndirectStates(streamState, sFileName, currentTime)) != MOS_STATUS_SUCCESS)
967 {
968 MOS_FreeMemory(pOutputBuffer);
969 return eStatus;
970 }
971 }
972
973 if (streamState->dumpCommandBufferAsMessages)
974 {
975 MOS_OS_NORMALMESSAGE(pOutputBuffer);
976 }
977
978 dwCommandBufferNumber++;
979 MOS_FreeMemory(pOutputBuffer);
980 eStatus = MOS_STATUS_SUCCESS;
981
982 return eStatus;
983
984 }
985 #endif // MOS_COMMAND_BUFFER_DUMP_SUPPORTED
986
GetCommandBuffer(MOS_STREAM_HANDLE streamState,COMMAND_BUFFER_HANDLE & cmdBuffer,uint32_t pipeIdx)987 MOS_STATUS MosInterface::GetCommandBuffer(
988 MOS_STREAM_HANDLE streamState,
989 COMMAND_BUFFER_HANDLE &cmdBuffer,
990 uint32_t pipeIdx)
991 {
992 MOS_OS_FUNCTION_ENTER;
993
994 MOS_OS_CHK_NULL_RETURN(streamState);
995
996 auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
997 MOS_OS_CHK_NULL_RETURN(gpuContext);
998
999 return (gpuContext->GetCommandBuffer(cmdBuffer, pipeIdx));
1000 }
1001
ReturnCommandBuffer(MOS_STREAM_HANDLE streamState,COMMAND_BUFFER_HANDLE cmdBuffer,uint32_t pipeIdx)1002 MOS_STATUS MosInterface::ReturnCommandBuffer(
1003 MOS_STREAM_HANDLE streamState,
1004 COMMAND_BUFFER_HANDLE cmdBuffer,
1005 uint32_t pipeIdx)
1006 {
1007 MOS_OS_FUNCTION_ENTER;
1008
1009 MOS_OS_CHK_NULL_RETURN(streamState);
1010
1011 auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
1012 MOS_OS_CHK_NULL_RETURN(gpuContext);
1013
1014 (gpuContext->ReturnCommandBuffer(cmdBuffer, pipeIdx));
1015
1016 return MOS_STATUS_SUCCESS;
1017 }
1018
SubmitCommandBuffer(MOS_STREAM_HANDLE streamState,COMMAND_BUFFER_HANDLE cmdBuffer,bool nullRendering)1019 MOS_STATUS MosInterface::SubmitCommandBuffer(
1020 MOS_STREAM_HANDLE streamState,
1021 COMMAND_BUFFER_HANDLE cmdBuffer,
1022 bool nullRendering)
1023 {
1024 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1025
1026 MOS_OS_CHK_NULL_RETURN(streamState);
1027
1028 auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
1029 MOS_OS_CHK_NULL_RETURN(gpuContext);
1030
1031 gpuContext->UpdatePriority(streamState->ctxPriority);
1032
1033 return (gpuContext->SubmitCommandBuffer(streamState, cmdBuffer, nullRendering));
1034 }
1035
ResetCommandBuffer(MOS_STREAM_HANDLE streamState,COMMAND_BUFFER_HANDLE cmdBuffer)1036 MOS_STATUS MosInterface::ResetCommandBuffer(
1037 MOS_STREAM_HANDLE streamState,
1038 COMMAND_BUFFER_HANDLE cmdBuffer)
1039 {
1040 MOS_OS_FUNCTION_ENTER;
1041
1042 MOS_OS_CHK_NULL_RETURN(streamState);
1043
1044 auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
1045 MOS_OS_CHK_NULL_RETURN(gpuContext);
1046
1047 // Reset the explicitly provided cmd buffer, or reset GPU context states
1048 if (cmdBuffer)
1049 {
1050 MOS_OS_CHK_STATUS_RETURN(gpuContext->ResetCommandBuffer());
1051 }
1052 else
1053 {
1054 gpuContext->ResetGpuContextStatus();
1055 }
1056
1057 return MOS_STATUS_SUCCESS;
1058 }
1059
VerifyCommandBufferSize(MOS_STREAM_HANDLE streamState,COMMAND_BUFFER_HANDLE cmdBuffer,uint32_t requestedSize,uint32_t pipeIdx)1060 MOS_STATUS MosInterface::VerifyCommandBufferSize(
1061 MOS_STREAM_HANDLE streamState,
1062 COMMAND_BUFFER_HANDLE cmdBuffer,
1063 uint32_t requestedSize,
1064 uint32_t pipeIdx)
1065 {
1066 MOS_OS_FUNCTION_ENTER;
1067
1068 MOS_OS_CHK_NULL_RETURN(streamState);
1069
1070 auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
1071 MOS_OS_CHK_NULL_RETURN(gpuContext);
1072
1073 return (gpuContext->VerifyCommandBufferSize(requestedSize));
1074 }
1075
ResizeCommandBufferAndPatchList(MOS_STREAM_HANDLE streamState,COMMAND_BUFFER_HANDLE cmdBuffer,uint32_t requestedSize,uint32_t requestedPatchListSize,uint32_t pipeIdx)1076 MOS_STATUS MosInterface::ResizeCommandBufferAndPatchList(
1077 MOS_STREAM_HANDLE streamState,
1078 COMMAND_BUFFER_HANDLE cmdBuffer,
1079 uint32_t requestedSize,
1080 uint32_t requestedPatchListSize,
1081 uint32_t pipeIdx)
1082 {
1083 MOS_OS_FUNCTION_ENTER;
1084
1085 auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
1086 MOS_OS_CHK_NULL_RETURN(gpuContext);
1087
1088 return (gpuContext->ResizeCommandBufferAndPatchList(requestedSize, requestedPatchListSize, pipeIdx));
1089 }
1090
SetPatchEntry(MOS_STREAM_HANDLE streamState,PMOS_PATCH_ENTRY_PARAMS params)1091 MOS_STATUS MosInterface::SetPatchEntry(
1092 MOS_STREAM_HANDLE streamState,
1093 PMOS_PATCH_ENTRY_PARAMS params)
1094 {
1095 MOS_OS_FUNCTION_ENTER;
1096
1097 MOS_OS_CHK_NULL_RETURN(params);
1098 MOS_OS_CHK_NULL_RETURN(streamState);
1099
1100 auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
1101 MOS_OS_CHK_NULL_RETURN(gpuContext);
1102
1103 MOS_OS_CHK_STATUS_RETURN(gpuContext->SetPatchEntry(streamState, params));
1104
1105 return MOS_STATUS_SUCCESS;
1106 }
1107
GetIndirectState(MOS_STREAM_HANDLE streamState,uint8_t ** indirectState,uint32_t & offset,uint32_t & size)1108 MOS_STATUS MosInterface::GetIndirectState(
1109 MOS_STREAM_HANDLE streamState,
1110 uint8_t **indirectState,
1111 uint32_t &offset,
1112 uint32_t &size)
1113 {
1114 MOS_OS_FUNCTION_ENTER;
1115
1116 auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
1117 MOS_OS_CHK_NULL_RETURN(gpuContext);
1118
1119 MOS_OS_CHK_STATUS_RETURN(gpuContext->GetIndirectState(offset, size));
1120 if (indirectState)
1121 {
1122 MOS_OS_CHK_STATUS_RETURN(gpuContext->GetIndirectStatePointer(indirectState));
1123 }
1124
1125 return MOS_STATUS_SUCCESS;
1126 }
1127
SetupIndirectState(MOS_STREAM_HANDLE streamState,uint32_t size)1128 MOS_STATUS MosInterface::SetupIndirectState(
1129 MOS_STREAM_HANDLE streamState,
1130 uint32_t size)
1131 {
1132 MOS_OS_FUNCTION_ENTER;
1133
1134 auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
1135 MOS_OS_CHK_NULL_RETURN(gpuContext);
1136
1137 MOS_OS_CHK_STATUS_RETURN(gpuContext->SetIndirectStateSize(size));
1138
1139 return MOS_STATUS_SUCCESS;
1140 }
1141
SetupAttributeVeBuffer(MOS_STREAM_HANDLE streamState,COMMAND_BUFFER_HANDLE cmdBuffer)1142 MOS_STATUS MosInterface::SetupAttributeVeBuffer(
1143 MOS_STREAM_HANDLE streamState,
1144 COMMAND_BUFFER_HANDLE cmdBuffer)
1145 {
1146 MOS_OS_FUNCTION_ENTER;
1147
1148 // no VE attribute buffer to setup
1149
1150 return MOS_STATUS_SUCCESS;
1151 }
1152
GetAttributeVeBuffer(COMMAND_BUFFER_HANDLE cmdBuffer)1153 MOS_CMD_BUF_ATTRI_VE *MosInterface::GetAttributeVeBuffer(
1154 COMMAND_BUFFER_HANDLE cmdBuffer)
1155 {
1156 MOS_OS_FUNCTION_ENTER;
1157
1158 // no VE attribute buffer to get
1159 return nullptr;
1160 }
1161
1162 static constexpr GMM_RESOURCE_USAGE_TYPE GmmResourceUsage[MOS_HW_RESOURCE_DEF_MAX] =
1163 {
1164 //
1165 // CODEC USAGES
1166 //
1167 GMM_RESOURCE_USAGE_BEGIN_CODEC,
1168 GMM_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC,
1169 GMM_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC_PARTIALENCSURFACE,
1170 GMM_RESOURCE_USAGE_POST_DEBLOCKING_CODEC,
1171 GMM_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_ENCODE,
1172 GMM_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_DECODE,
1173 GMM_RESOURCE_USAGE_STREAMOUT_DATA_CODEC,
1174 GMM_RESOURCE_USAGE_INTRA_ROWSTORE_SCRATCH_BUFFER_CODEC,
1175 GMM_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC,
1176 GMM_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC,
1177 GMM_RESOURCE_USAGE_MACROBLOCK_STATUS_BUFFER_CODEC,
1178 GMM_RESOURCE_USAGE_MFX_INDIRECT_BITSTREAM_OBJECT_DECODE,
1179 GMM_RESOURCE_USAGE_MFX_INDIRECT_MV_OBJECT_CODEC,
1180 GMM_RESOURCE_USAGE_MFD_INDIRECT_IT_COEF_OBJECT_DECODE,
1181 GMM_RESOURCE_USAGE_MFC_INDIRECT_PAKBASE_OBJECT_CODEC,
1182 GMM_RESOURCE_USAGE_BSDMPC_ROWSTORE_SCRATCH_BUFFER_CODEC,
1183 GMM_RESOURCE_USAGE_MPR_ROWSTORE_SCRATCH_BUFFER_CODEC,
1184 GMM_RESOURCE_USAGE_BITPLANE_READ_CODEC,
1185 GMM_RESOURCE_USAGE_DIRECTMV_BUFFER_CODEC,
1186 GMM_RESOURCE_USAGE_SURFACE_CURR_ENCODE,
1187 GMM_RESOURCE_USAGE_SURFACE_REF_ENCODE,
1188 GMM_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE,
1189 GMM_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE,
1190 GMM_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE_FF,
1191 GMM_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE_DST,
1192 GMM_RESOURCE_USAGE_SURFACE_ME_DISTORTION_ENCODE,
1193 GMM_RESOURCE_USAGE_SURFACE_BRC_ME_DISTORTION_ENCODE,
1194 GMM_RESOURCE_USAGE_PAK_OBJECT_ENCODE,
1195 GMM_RESOURCE_USAGE_SURFACE_FLATNESS_CHECK_ENCODE,
1196 GMM_RESOURCE_USAGE_SURFACE_MBENC_CURBE_ENCODE,
1197 GMM_RESOURCE_USAGE_SURFACE_MAD_ENCODE,
1198 GMM_RESOURCE_USAGE_VP8_BLOCK_MODE_COST_ENCODE,
1199 GMM_RESOURCE_USAGE_VP8_MB_MODE_COST_ENCODE,
1200 GMM_RESOURCE_USAGE_VP8_MBENC_OUTPUT_ENCODE,
1201 GMM_RESOURCE_USAGE_VP8_HISTOGRAM_ENCODE,
1202 GMM_RESOURCE_USAGE_VP8_L3_LLC_ENCODE,
1203 GMM_RESOURCE_USAGE_MFX_STANDALONE_DEBLOCKING_CODEC,
1204 GMM_RESOURCE_USAGE_HCP_MD_CODEC,
1205 GMM_RESOURCE_USAGE_HCP_SAO_CODEC,
1206 GMM_RESOURCE_USAGE_HCP_MV_CODEC,
1207 GMM_RESOURCE_USAGE_HCP_STATUS_ERROR_CODEC,
1208 GMM_RESOURCE_USAGE_HCP_LCU_ILDB_STREAMOUT_CODEC,
1209 GMM_RESOURCE_USAGE_VP9_PROBABILITY_BUFFER_CODEC,
1210 GMM_RESOURCE_USAGE_VP9_SEGMENT_ID_BUFFER_CODEC,
1211 GMM_RESOURCE_USAGE_VP9_HVD_ROWSTORE_BUFFER_CODEC,
1212 GMM_RESOURCE_USAGE_MBDISABLE_SKIPMAP_CODEC,
1213 GMM_RESOURCE_USAGE_VDENC_ROW_STORE_BUFFER_CODEC,
1214 GMM_RESOURCE_USAGE_VDENC_STREAMIN_CODEC,
1215 GMM_RESOURCE_USAGE_SURFACE_MB_QP_CODEC,
1216 GMM_RESOURCE_USAGE_MACROBLOCK_ILDB_STREAM_OUT_BUFFER_CODEC,
1217 GMM_RESOURCE_USAGE_SSE_SRC_PIXEL_ROW_STORE_BUFFER_CODEC,
1218 GMM_RESOURCE_USAGE_SLICE_STATE_STREAM_OUT_BUFFER_CODEC,
1219 GMM_RESOURCE_USAGE_CABAC_SYNTAX_STREAM_OUT_BUFFER_CODEC,
1220 GMM_RESOURCE_USAGE_PRED_COL_STORE_BUFFER_CODEC,
1221 GMM_RESOURCE_USAGE_SURFACE_PAK_IMAGESTATE_ENCODE,
1222 GMM_RESOURCE_USAGE_SURFACE_MBENC_BRC_ENCODE,
1223 GMM_RESOURCE_USAGE_SURFACE_MB_BRC_CONST_ENCODE,
1224 GMM_RESOURCE_USAGE_SURFACE_BRC_MB_QP_ENCODE,
1225 GMM_RESOURCE_USAGE_SURFACE_BRC_ROI_ENCODE,
1226 GMM_RESOURCE_USAGE_SURFACE_SLICE_MAP_ENCODE,
1227 GMM_RESOURCE_USAGE_SURFACE_WP_DOWNSAMPLED_ENCODE,
1228 GMM_RESOURCE_USAGE_SURFACE_VDENC_IMAGESTATE_ENCODE,
1229 GMM_RESOURCE_USAGE_SURFACE_UNCACHED,
1230 GMM_RESOURCE_USAGE_SURFACE_ELLC_ONLY,
1231 GMM_RESOURCE_USAGE_SURFACE_ELLC_LLC_ONLY,
1232 GMM_RESOURCE_USAGE_SURFACE_ELLC_LLC_L3,
1233 GMM_RESOURCE_USAGE_SURFACE_BRC_HISTORY_ENCODE,
1234 GMM_RESOURCE_USAGE_SURFACE_SOFTWARE_SCOREBOARD_ENCODE,
1235 GMM_RESOURCE_USAGE_SURFACE_ME_MV_DATA_ENCODE,
1236 GMM_RESOURCE_USAGE_SURFACE_MV_DISTORTION_ENCODE,
1237 GMM_RESOURCE_USAGE_SURFACE_4XME_DISTORTION_ENCODE,
1238 GMM_RESOURCE_USAGE_SURFACE_INTRA_DISTORTION_ENCODE,
1239 GMM_RESOURCE_USAGE_MB_STATS_ENCODE,
1240 GMM_RESOURCE_USAGE_SURFACE_PAK_STATS_ENCODE,
1241 GMM_RESOURCE_USAGE_SURFACE_PIC_STATE_READ_ENCODE,
1242 GMM_RESOURCE_USAGE_SURFACE_PIC_STATE_WRITE_ENCODE,
1243 GMM_RESOURCE_USAGE_SURFACE_COMBINED_ENC_ENCODE,
1244 GMM_RESOURCE_USAGE_SURFACE_BRC_CONSTANT_DATA_ENCODE,
1245 GMM_RESOURCE_USAGE_SURFACE_INTERMEDIATE_CU_RECORD_SURFACE_ENCODE,
1246 GMM_RESOURCE_USAGE_SURFACE_SCRATCH_ENCODE,
1247 GMM_RESOURCE_USAGE_SURFACE_LCU_LEVEL_DATA_ENCODE,
1248 GMM_RESOURCE_USAGE_SURFACE_ENC_HISTORY_INPUT_ENCODE,
1249 GMM_RESOURCE_USAGE_SURFACE_ENC_HISTORY_OUTPUT_ENCODE,
1250 GMM_RESOURCE_USAGE_SURFACE_DEBUG_ENCODE,
1251 GMM_RESOURCE_USAGE_SURFACE_ENC_CONSTANT_TABLE_ENCODE,
1252 GMM_RESOURCE_USAGE_SURFACE_ENC_CU_RECORD_ENCODE,
1253 GMM_RESOURCE_USAGE_SURFACE_ENC_MV_TEMPORAL_BUFFER_ENCODE,
1254 GMM_RESOURCE_USAGE_SURFACE_ENC_CU_PACKET_FOR_PAK_ENCODE,
1255 GMM_RESOURCE_USAGE_SURFACE_ENC_BCOMBINED1_ENCODE,
1256 GMM_RESOURCE_USAGE_SURFACE_ENC_BCOMBINED2_ENCODE,
1257 GMM_RESOURCE_USAGE_FRAME_STATS_STREAMOUT_DATA_CODEC,
1258 GMM_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_TILE_LINE_BUFFER_CODEC,
1259 GMM_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_TILE_COLUMN_BUFFER_CODEC,
1260 GMM_RESOURCE_USAGE_HCP_MD_TILE_LINE_CODEC,
1261 GMM_RESOURCE_USAGE_HCP_MD_TILE_COLUMN_CODEC,
1262 GMM_RESOURCE_USAGE_HCP_SAO_TILE_LINE_CODEC,
1263 GMM_RESOURCE_USAGE_HCP_SAO_TILE_COLUMN_CODEC,
1264 GMM_RESOURCE_USAGE_VP9_PROBABILITY_COUNTER_BUFFER_CODEC,
1265 GMM_RESOURCE_USAGE_HUC_VIRTUAL_ADDR_REGION_BUFFER_CODEC,
1266 GMM_RESOURCE_USAGE_SIZE_STREAMOUT_CODEC,
1267 GMM_RESOURCE_USAGE_COMPRESSED_HEADER_BUFFER_CODEC,
1268 GMM_RESOURCE_USAGE_PROBABILITY_DELTA_BUFFER_CODEC,
1269 GMM_RESOURCE_USAGE_TILE_RECORD_BUFFER_CODEC,
1270 GMM_RESOURCE_USAGE_TILE_SIZE_STAS_BUFFER_CODEC,
1271 GMM_RESOURCE_USAGE_END_CODEC,
1272
1273 //
1274 // CM USAGES
1275 //
1276 CM_RESOURCE_USAGE_SurfaceState,
1277 CM_RESOURCE_USAGE_StateHeap,
1278 CM_RESOURCE_USAGE_NO_L3_SurfaceState,
1279 CM_RESOURCE_USAGE_NO_LLC_ELLC_SurfaceState,
1280 CM_RESOURCE_USAGE_NO_LLC_SurfaceState,
1281 CM_RESOURCE_USAGE_NO_ELLC_SurfaceState,
1282 CM_RESOURCE_USAGE_NO_LLC_L3_SurfaceState,
1283 CM_RESOURCE_USAGE_NO_ELLC_L3_SurfaceState,
1284 CM_RESOURCE_USAGE_NO_CACHE_SurfaceState,
1285 CM_RESOURCE_USAGE_L1_Enabled_SurfaceState,
1286
1287 //
1288 // MP USAGES
1289 //
1290 MP_RESOURCE_USAGE_BEGIN,
1291 MP_RESOURCE_USAGE_DEFAULT,
1292 MP_RESOURCE_USAGE_DEFAULT_FF,
1293 MP_RESOURCE_USAGE_DEFAULT_RCS,
1294 MP_RESOURCE_USAGE_SurfaceState,
1295 MP_RESOURCE_USAGE_SurfaceState_FF,
1296 MP_RESOURCE_USAGE_SurfaceState_RCS,
1297 MP_RESOURCE_USAGE_AGE3_SurfaceState,
1298 MP_RESOURCE_USAGE_EDRAM_SurfaceState,
1299 MP_RESOURCE_USAGE_EDRAM_AGE3_SurfaceState,
1300 MP_RESOURCE_USAGE_No_L3_SurfaceState,
1301 MP_RESOURCE_USAGE_No_LLC_L3_SurfaceState,
1302 MP_RESOURCE_USAGE_No_LLC_L3_AGE_SurfaceState,
1303 MP_RESOURCE_USAGE_No_LLC_eLLC_L3_AGE_SurfaceState,
1304 MP_RESOURCE_USAGE_PartialEnc_No_LLC_L3_AGE_SurfaceState,
1305 MP_RESOURCE_USAGE_END,
1306
1307 // MHW - SFC
1308 MHW_RESOURCE_USAGE_Sfc_CurrentOutputSurface, //!< SFC output surface
1309 MHW_RESOURCE_USAGE_Sfc_CurrentOutputSurface_PartialEncSurface, //!< SFC output surface for partial secure surfaces
1310 MHW_RESOURCE_USAGE_Sfc_AvsLineBufferSurface, //!< SFC AVS Line buffer Surface
1311 MHW_RESOURCE_USAGE_Sfc_IefLineBufferSurface, //!< SFC IEF Line buffer Surface
1312
1313 // Camera caputure.
1314 GMM_RESOURCE_USAGE_CAMERA_CAPTURE,
1315 // Media GMM Resource USAGES
1316 GMM_RESOURCE_USAGE_CCS_MEDIA_WRITABLE,
1317
1318 // Media BLT copy USAGES
1319 GMM_RESOURCE_USAGE_BLT_SOURCE,
1320 GMM_RESOURCE_USAGE_BLT_DESTINATION,
1321
1322 // PAT Media Usages
1323 GMM_RESOURCE_USAGE_MEDIA_BATCH_BUFFERS,
1324 // DECODE
1325 GMM_RESOURCE_USAGE_DECODE_INPUT_BITSTREAM,
1326 GMM_RESOURCE_USAGE_DECODE_INPUT_REFERENCE,
1327 GMM_RESOURCE_USAGE_DECODE_INTERNAL_READ,
1328 GMM_RESOURCE_USAGE_DECODE_INTERNAL_WRITE,
1329 GMM_RESOURCE_USAGE_DECODE_INTERNAL_READ_WRITE_CACHE,
1330 GMM_RESOURCE_USAGE_DECODE_INTERNAL_READ_WRITE_NOCACHE,
1331 GMM_RESOURCE_USAGE_DECODE_OUTPUT_PICTURE,
1332 GMM_RESOURCE_USAGE_DECODE_OUTPUT_STATISTICS_WRITE,
1333 GMM_RESOURCE_USAGE_DECODE_OUTPUT_STATISTICS_READ_WRITE,
1334 // ENCODE
1335 GMM_RESOURCE_USAGE_ENCODE_INPUT_RAW,
1336 GMM_RESOURCE_USAGE_ENCODE_INPUT_RECON,
1337 GMM_RESOURCE_USAGE_ENCODE_INTERNAL_READ,
1338 GMM_RESOURCE_USAGE_ENCODE_INTERNAL_WRITE,
1339 GMM_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE,
1340 GMM_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_NOCACHE,
1341 GMM_RESOURCE_USAGE_ENCODE_EXTERNAL_READ,
1342 GMM_RESOURCE_USAGE_ENCODE_OUTPUT_PICTURE,
1343 GMM_RESOURCE_USAGE_ENCODE_OUTPUT_BITSTREAM,
1344 GMM_RESOURCE_USAGE_ENCODE_OUTPUT_STATISTICS_WRITE,
1345 GMM_RESOURCE_USAGE_ENCODE_OUTPUT_STATISTICS_READ_WRITE,
1346 // VP
1347 GMM_RESOURCE_USAGE_VP_INPUT_PICTURE_FF,
1348 GMM_RESOURCE_USAGE_VP_INPUT_REFERENCE_FF,
1349 GMM_RESOURCE_USAGE_VP_INTERNAL_READ_FF,
1350 GMM_RESOURCE_USAGE_VP_INTERNAL_WRITE_FF,
1351 GMM_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_FF,
1352 GMM_RESOURCE_USAGE_VP_OUTPUT_PICTURE_FF,
1353 GMM_RESOURCE_USAGE_VP_INPUT_PICTURE_RENDER,
1354 GMM_RESOURCE_USAGE_VP_INPUT_REFERENCE_RENDER,
1355 GMM_RESOURCE_USAGE_VP_INTERNAL_READ_RENDER,
1356 GMM_RESOURCE_USAGE_VP_INTERNAL_WRITE_RENDER,
1357 GMM_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_RENDER,
1358 GMM_RESOURCE_USAGE_VP_OUTPUT_PICTURE_RENDER,
1359 // CP
1360 GMM_RESOURCE_USAGE_CP_EXTERNAL_READ,
1361 GMM_RESOURCE_USAGE_CP_INTERNAL_WRITE,
1362 };
1363
GetGmmResourceUsageType(MOS_HW_RESOURCE_DEF resUsage)1364 GMM_RESOURCE_USAGE_TYPE MosInterface::GetGmmResourceUsageType(
1365 MOS_HW_RESOURCE_DEF resUsage)
1366 {
1367 if (resUsage >= (sizeof(GmmResourceUsage) / sizeof(GmmResourceUsage[0])))
1368 return GMM_RESOURCE_USAGE_UNKNOWN;
1369
1370 return GmmResourceUsage[resUsage];
1371 }
1372
GmmToMosResourceUsageType(GMM_RESOURCE_USAGE_TYPE gmmResUsage)1373 MOS_HW_RESOURCE_DEF MosInterface::GmmToMosResourceUsageType(
1374 GMM_RESOURCE_USAGE_TYPE gmmResUsage)
1375 {
1376 MOS_HW_RESOURCE_DEF mosResUsage = MOS_HW_RESOURCE_DEF_MAX;
1377 switch (gmmResUsage)
1378 {
1379 case GMM_RESOURCE_USAGE_DECODE_INPUT_BITSTREAM:
1380 mosResUsage = MOS_HW_RESOURCE_USAGE_DECODE_INPUT_BITSTREAM;
1381 break;
1382 case GMM_RESOURCE_USAGE_DECODE_INPUT_REFERENCE:
1383 mosResUsage = MOS_HW_RESOURCE_USAGE_DECODE_INPUT_REFERENCE;
1384 break;
1385 case GMM_RESOURCE_USAGE_DECODE_INTERNAL_READ:
1386 mosResUsage = MOS_HW_RESOURCE_USAGE_DECODE_INTERNAL_READ;
1387 break;
1388 case GMM_RESOURCE_USAGE_DECODE_INTERNAL_WRITE:
1389 mosResUsage = MOS_HW_RESOURCE_USAGE_DECODE_INTERNAL_WRITE;
1390 break;
1391 case GMM_RESOURCE_USAGE_DECODE_INTERNAL_READ_WRITE_CACHE:
1392 mosResUsage = MOS_HW_RESOURCE_USAGE_DECODE_INTERNAL_READ_WRITE_CACHE;
1393 break;
1394 case GMM_RESOURCE_USAGE_DECODE_INTERNAL_READ_WRITE_NOCACHE:
1395 mosResUsage = MOS_HW_RESOURCE_USAGE_DECODE_INTERNAL_READ_WRITE_NOCACHE;
1396 break;
1397 case GMM_RESOURCE_USAGE_DECODE_OUTPUT_PICTURE:
1398 mosResUsage = MOS_HW_RESOURCE_USAGE_DECODE_OUTPUT_PICTURE;
1399 break;
1400 case GMM_RESOURCE_USAGE_DECODE_OUTPUT_STATISTICS_WRITE:
1401 mosResUsage = MOS_HW_RESOURCE_USAGE_DECODE_OUTPUT_STATISTICS_WRITE;
1402 break;
1403 case GMM_RESOURCE_USAGE_DECODE_OUTPUT_STATISTICS_READ_WRITE:
1404 mosResUsage = MOS_HW_RESOURCE_USAGE_DECODE_OUTPUT_STATISTICS_READ_WRITE;
1405 break;
1406 default:
1407 mosResUsage = MOS_HW_RESOURCE_DEF_MAX;
1408 }
1409 return mosResUsage;
1410 }
1411
GetGmmCachePolicyMemoryObject(GMM_CLIENT_CONTEXT * gmmClientContext,GMM_RESOURCE_USAGE_TYPE gmmUsage)1412 MEMORY_OBJECT_CONTROL_STATE MosInterface::GetGmmCachePolicyMemoryObject(
1413 GMM_CLIENT_CONTEXT *gmmClientContext,
1414 GMM_RESOURCE_USAGE_TYPE gmmUsage)
1415 {
1416 MOS_OS_FUNCTION_ENTER;
1417 if (!gmmClientContext)
1418 {
1419 return {0};
1420 }
1421
1422 if (gmmClientContext->GetCachePolicyElement(gmmUsage).Initialized)
1423 {
1424 return gmmClientContext->CachePolicyGetMemoryObject(nullptr, gmmUsage);
1425 }
1426 else
1427 {
1428 return GetDefaultCachePolicyMemoryObject(gmmClientContext);
1429 }
1430 }
1431
GetDefaultCachePolicyMemoryObject(GMM_CLIENT_CONTEXT * gmmClientContext)1432 MEMORY_OBJECT_CONTROL_STATE MosInterface::GetDefaultCachePolicyMemoryObject(
1433 GMM_CLIENT_CONTEXT *gmmClientContext)
1434 {
1435 MOS_OS_FUNCTION_ENTER;
1436 if (!gmmClientContext)
1437 {
1438 return {0};
1439 }
1440 if (gmmClientContext->GetCachePolicyElement(GMM_RESOURCE_USAGE_DECODE_INTERNAL_READ_WRITE_NOCACHE).Initialized) //For arch usage, use GMM_RESOURCE_USAGE_DECODE_INTERNAL_READ_WRITE_NOCACHE as the default setting.
1441 {
1442 MOS_OS_NORMALMESSAGE("use GMM_RESOURCE_USAGE_DECODE_INTERNAL_READ_WRITE_NOCACHE");
1443 return gmmClientContext->CachePolicyGetMemoryObject(nullptr, GMM_RESOURCE_USAGE_DECODE_INTERNAL_READ_WRITE_NOCACHE);
1444 }
1445 else if (gmmClientContext->GetCachePolicyElement(MP_RESOURCE_USAGE_DEFAULT).Initialized)
1446 {
1447 MOS_OS_NORMALMESSAGE("use MP_RESOURCE_USAGE_DEFAULT");
1448 return gmmClientContext->CachePolicyGetMemoryObject(nullptr, MP_RESOURCE_USAGE_DEFAULT);
1449 }
1450 else
1451 {
1452 MOS_OS_NORMALMESSAGE("use GMM_RESOURCE_USAGE_UNKNOWN");
1453 return gmmClientContext->CachePolicyGetMemoryObject(nullptr, GMM_RESOURCE_USAGE_UNKNOWN);
1454 }
1455 }
1456
GetCachePolicyMemoryObject(GMM_CLIENT_CONTEXT * gmmClientContext,MOS_HW_RESOURCE_DEF mosUsage)1457 MEMORY_OBJECT_CONTROL_STATE MosInterface::GetCachePolicyMemoryObject(
1458 GMM_CLIENT_CONTEXT *gmmClientContext,
1459 MOS_HW_RESOURCE_DEF mosUsage)
1460 {
1461 MOS_OS_FUNCTION_ENTER;
1462
1463 GMM_RESOURCE_USAGE_TYPE usage = GmmResourceUsage[mosUsage];
1464 return MosInterface::GetGmmCachePolicyMemoryObject(gmmClientContext, usage);
1465 }
1466
GetCachePolicyL1Config(MOS_STREAM_HANDLE streamState,MOS_HW_RESOURCE_DEF mosUsage)1467 uint8_t MosInterface::GetCachePolicyL1Config(
1468 MOS_STREAM_HANDLE streamState,
1469 MOS_HW_RESOURCE_DEF mosUsage)
1470 {
1471 MOS_OS_FUNCTION_ENTER;
1472 return 0;
1473 }
1474
GetReservedFromResource(MOS_RESOURCE_HANDLE resource,uint32_t & val)1475 MOS_STATUS MosInterface::GetReservedFromResource(MOS_RESOURCE_HANDLE resource, uint32_t &val)
1476 {
1477 return MOS_STATUS_UNIMPLEMENTED;
1478 }
1479
GetReservedFromStream(MOS_STREAM_HANDLE stream,uint32_t & val)1480 MOS_STATUS MosInterface::GetReservedFromStream(MOS_STREAM_HANDLE stream, uint32_t &val)
1481 {
1482 return MOS_STATUS_UNIMPLEMENTED;
1483 }
1484
GetReservedFromDevice(MOS_DEVICE_HANDLE device,uint32_t & val)1485 MOS_STATUS MosInterface::GetReservedFromDevice(MOS_DEVICE_HANDLE device, uint32_t &val)
1486 {
1487 MOS_OS_CHK_NULL_RETURN(device);
1488 OsContextSpecificNext *osDevice = dynamic_cast<OsContextSpecificNext*>(device);
1489 MOS_OS_CHK_NULL_RETURN(osDevice);
1490 if (osDevice->GetBufMgr()->get_reserved)
1491 {
1492 val = *(osDevice->GetBufMgr()->get_reserved);
1493 return MOS_STATUS_SUCCESS;
1494 }
1495 else
1496 {
1497 return MOS_STATUS_UNIMPLEMENTED;
1498 }
1499 }
1500
GetperStreamParameters(MOS_STREAM_HANDLE stream,void ** perStreamParameters)1501 MOS_STATUS MosInterface::GetperStreamParameters(MOS_STREAM_HANDLE stream, void **perStreamParameters)
1502 {
1503 MOS_OS_CHK_NULL_RETURN(stream);
1504 *perStreamParameters = (void*)stream->perStreamParameters;
1505 return MOS_STATUS_SUCCESS;
1506 }
1507
ConvertResourceFromDdi(OsSpecificRes osResource,MOS_RESOURCE_HANDLE & resource,uint32_t firstArraySlice,uint32_t mipSlice)1508 MOS_STATUS MosInterface::ConvertResourceFromDdi(
1509 OsSpecificRes osResource,
1510 MOS_RESOURCE_HANDLE &resource,
1511 uint32_t firstArraySlice,
1512 uint32_t mipSlice)
1513 {
1514 MOS_OS_FUNCTION_ENTER;
1515
1516 if (firstArraySlice == OS_SPECIFIC_RESOURCE_INVALID || firstArraySlice >= OS_SPECIFIC_RESOURCE_MAX)
1517 {
1518 MOS_OS_ASSERTMESSAGE("Cannot Convert Resource From Ddi, invalid ddi resource type!");
1519 return MOS_STATUS_INVALID_PARAMETER;
1520 }
1521
1522 MOS_OS_CHK_NULL_RETURN(osResource);
1523 MOS_OS_CHK_NULL_RETURN(resource);
1524
1525 if (firstArraySlice == OS_SPECIFIC_RESOURCE_SURFACE)
1526 {
1527 DDI_MEDIA_SURFACE *mediaSurface = (DDI_MEDIA_SURFACE *)osResource;
1528
1529 switch (mediaSurface->format)
1530 {
1531 case Media_Format_NV12:
1532 resource->Format = Format_NV12;
1533 break;
1534 case Media_Format_NV21:
1535 resource->Format = Format_NV21;
1536 break;
1537 case Media_Format_YUY2:
1538 resource->Format = Format_YUY2;
1539 break;
1540 case Media_Format_X8R8G8B8:
1541 resource->Format = Format_X8R8G8B8;
1542 break;
1543 case Media_Format_X8B8G8R8:
1544 resource->Format = Format_X8B8G8R8;
1545 break;
1546 case Media_Format_A8B8G8R8:
1547 case Media_Format_R8G8B8A8:
1548 resource->Format = Format_A8B8G8R8;
1549 break;
1550 case Media_Format_A8R8G8B8:
1551 resource->Format = Format_A8R8G8B8;
1552 break;
1553 case Media_Format_R5G6B5:
1554 resource->Format = Format_R5G6B5;
1555 break;
1556 case Media_Format_R8G8B8:
1557 resource->Format = Format_R8G8B8;
1558 break;
1559 case Media_Format_RGBP:
1560 resource->Format = Format_RGBP;
1561 break;
1562 case Media_Format_BGRP:
1563 resource->Format = Format_BGRP;
1564 break;
1565 case Media_Format_444P:
1566 resource->Format = Format_444P;
1567 break;
1568 case Media_Format_411P:
1569 resource->Format = Format_411P;
1570 break;
1571 case Media_Format_IMC3:
1572 resource->Format = Format_IMC3;
1573 break;
1574 case Media_Format_400P:
1575 resource->Format = Format_400P;
1576 break;
1577 case Media_Format_422H:
1578 resource->Format = Format_422H;
1579 break;
1580 case Media_Format_422V:
1581 resource->Format = Format_422V;
1582 break;
1583 case Media_Format_Buffer:
1584 resource->Format = Format_Any;
1585 break;
1586 case Media_Format_P010:
1587 resource->Format = Format_P010;
1588 break;
1589 case Media_Format_P012:
1590 case Media_Format_P016:
1591 resource->Format = Format_P016;
1592 break;
1593 case Media_Format_Y210:
1594 resource->Format = Format_Y210;
1595 break;
1596 #if VA_CHECK_VERSION(1, 9, 0)
1597 case Media_Format_Y212:
1598 #endif
1599 case Media_Format_Y216:
1600 resource->Format = Format_Y216;
1601 break;
1602 case Media_Format_AYUV:
1603 #if VA_CHECK_VERSION(1, 13, 0)
1604 case Media_Format_XYUV:
1605 #endif
1606 resource->Format = Format_AYUV;
1607 break;
1608 case Media_Format_Y410:
1609 resource->Format = Format_Y410;
1610 break;
1611 #if VA_CHECK_VERSION(1, 9, 0)
1612 case Media_Format_Y412:
1613 #endif
1614 case Media_Format_Y416:
1615 resource->Format = Format_Y416;
1616 break;
1617 case Media_Format_Y8:
1618 resource->Format = Format_Y8;
1619 break;
1620 case Media_Format_Y16S:
1621 resource->Format = Format_Y16S;
1622 break;
1623 case Media_Format_Y16U:
1624 resource->Format = Format_Y16U;
1625 break;
1626 case Media_Format_R10G10B10A2:
1627 case Media_Format_R10G10B10X2:
1628 resource->Format = Format_R10G10B10A2;
1629 break;
1630 case Media_Format_B10G10R10A2:
1631 case Media_Format_B10G10R10X2:
1632 resource->Format = Format_B10G10R10A2;
1633 break;
1634 case Media_Format_UYVY:
1635 resource->Format = Format_UYVY;
1636 break;
1637 case Media_Format_VYUY:
1638 resource->Format = Format_VYUY;
1639 break;
1640 case Media_Format_YVYU:
1641 resource->Format = Format_YVYU;
1642 break;
1643 case Media_Format_A16R16G16B16:
1644 resource->Format = Format_A16R16G16B16;
1645 break;
1646 case Media_Format_A16B16G16R16:
1647 resource->Format = Format_A16B16G16R16;
1648 break;
1649 case Media_Format_I420:
1650 resource->Format = Format_I420;
1651 break;
1652 case Media_Format_YV12:
1653 resource->Format = Format_YV12;
1654 break;
1655 default:
1656 MOS_OS_ASSERTMESSAGE("MOS: unsupported media format for surface.");
1657 break;
1658 }
1659 resource->iWidth = mediaSurface->iWidth;
1660 resource->iHeight = mediaSurface->iHeight;
1661 resource->iPitch = mediaSurface->iPitch;
1662 // Use surface bo size as resource size since we need real bounds checking when fill padding for the surface.
1663 resource->iSize = mediaSurface->bo->size;
1664 resource->iCount = mediaSurface->iRefCount;
1665 resource->isTiled = mediaSurface->isTiled;
1666 resource->TileType = LinuxToMosTileType(mediaSurface->TileType);
1667 resource->bo = mediaSurface->bo;
1668 resource->name = mediaSurface->name;
1669
1670 resource->ppCurrentFrameSemaphore = &mediaSurface->pCurrentFrameSemaphore;
1671 resource->ppReferenceFrameSemaphore = &mediaSurface->pReferenceFrameSemaphore;
1672 resource->bSemInitialized = false;
1673 resource->bMapped = false;
1674
1675 if (mediaSurface->bMapped == true)
1676 {
1677 resource->pData = mediaSurface->pData;
1678 }
1679 else
1680 {
1681 resource->pData = nullptr;
1682 }
1683 resource->pGmmResInfo = mediaSurface->pGmmResourceInfo;
1684 resource->dwGfxAddress = 0;
1685 }
1686 else if (firstArraySlice == OS_SPECIFIC_RESOURCE_BUFFER)
1687 {
1688 DDI_MEDIA_BUFFER *mediaBuffer = (DDI_MEDIA_BUFFER *)osResource;
1689 switch (mediaBuffer->format)
1690 {
1691 case Media_Format_Buffer:
1692 resource->Format = Format_Buffer;
1693 resource->iWidth = mediaBuffer->iSize;
1694 resource->iHeight = 1;
1695 resource->iPitch = mediaBuffer->iSize;
1696 break;
1697 case Media_Format_Perf_Buffer:
1698 resource->Format = Format_Buffer;
1699 resource->iWidth = mediaBuffer->iSize;
1700 resource->iHeight = 1;
1701 resource->iPitch = mediaBuffer->iSize;
1702 break;
1703 case Media_Format_2DBuffer:
1704 resource->Format = Format_Buffer_2D;
1705 resource->iWidth = mediaBuffer->uiWidth;
1706 resource->iHeight = mediaBuffer->uiHeight;
1707 resource->iPitch = mediaBuffer->uiPitch;
1708 break;
1709 case Media_Format_CPU:
1710 return MOS_STATUS_SUCCESS;
1711 default:
1712 resource->iWidth = mediaBuffer->iSize;
1713 resource->iHeight = 1;
1714 resource->iPitch = mediaBuffer->iSize;
1715 MOS_OS_ASSERTMESSAGE("MOS: unsupported media format for surface.");
1716 break;
1717 }
1718 resource->iSize = mediaBuffer->bo->size;
1719 resource->iCount = mediaBuffer->iRefCount;
1720 resource->isTiled = 0;
1721 resource->TileType = LinuxToMosTileType(mediaBuffer->TileType);
1722 resource->bo = mediaBuffer->bo;
1723 resource->name = mediaBuffer->name;
1724 resource->bMapped = false;
1725
1726 if (mediaBuffer->bMapped == true)
1727 {
1728 resource->pData = mediaBuffer->pData;
1729 }
1730 else
1731 {
1732 resource->pData = nullptr;
1733 }
1734 resource->dwGfxAddress = 0;
1735 resource->pGmmResInfo = mediaBuffer->pGmmResourceInfo;
1736 }
1737
1738 resource->bConvertedFromDDIResource = true;
1739 resource->memObjCtrlState.DwordValue = 0;
1740 resource->mocsMosResUsageType = MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC;
1741
1742 return MOS_STATUS_SUCCESS;
1743 }
1744
CreateOsSpecificResourceInfo(OsSpecificRes resource,bool isInternal)1745 MOS_STATUS MosInterface::CreateOsSpecificResourceInfo(OsSpecificRes resource, bool isInternal)
1746 {
1747 MOS_OS_FUNCTION_ENTER;
1748
1749 // No OsSpecificResourceInfo in Linux
1750
1751 return MOS_STATUS_SUCCESS;
1752 }
1753
DestroySpecificResourceInfo(OsSpecificRes resource)1754 MOS_STATUS MosInterface::DestroySpecificResourceInfo(OsSpecificRes resource)
1755 {
1756 MOS_OS_FUNCTION_ENTER;
1757
1758 // No OsSpecificResourceInfo in Linux
1759
1760 return MOS_STATUS_SUCCESS;
1761 }
1762
AllocateResource(MOS_STREAM_HANDLE streamState,PMOS_ALLOC_GFXRES_PARAMS params,MOS_RESOURCE_HANDLE & resource,const char * functionName,const char * filename,int32_t line)1763 MOS_STATUS MosInterface::AllocateResource(
1764 MOS_STREAM_HANDLE streamState,
1765 PMOS_ALLOC_GFXRES_PARAMS params,
1766 MOS_RESOURCE_HANDLE &resource
1767 #if MOS_MESSAGES_ENABLED
1768 ,
1769 const char *functionName,
1770 const char *filename,
1771 int32_t line
1772 #endif
1773 )
1774 {
1775 MOS_STATUS estatus = MOS_STATUS_SUCCESS;
1776 MOS_OS_FUNCTION_ENTER;
1777
1778 MOS_OS_CHK_NULL_RETURN(resource);
1779 MOS_OS_CHK_NULL_RETURN(streamState);
1780 MOS_OS_CHK_NULL_RETURN(streamState->osDeviceContext);
1781
1782 #if (_DEBUG || _RELEASE_INTERNAL)
1783 if (MosSimulateOsApiFail(OS_FAIL_ALLOC_GFX_RES, __FUNCTION__, __FILE__, __LINE__))
1784 {
1785 return MOS_STATUS_NO_SPACE;
1786 }
1787 #endif
1788
1789 resource->bConvertedFromDDIResource = false;
1790 if (!params->bBypassMODImpl)
1791 {
1792 resource->pGfxResourceNext = GraphicsResourceNext::CreateGraphicResource(GraphicsResourceNext::osSpecificResource);
1793 MOS_OS_CHK_NULL_RETURN(resource->pGfxResourceNext);
1794
1795 GraphicsResourceNext::CreateParams createParams(params);
1796 auto eStatus = resource->pGfxResourceNext->Allocate(streamState->osDeviceContext, createParams);
1797 MOS_OS_CHK_STATUS_MESSAGE_RETURN(eStatus, "Allocate graphic resource failed");
1798
1799 eStatus = resource->pGfxResourceNext->ConvertToMosResource(resource);
1800 MOS_OS_CHK_STATUS_MESSAGE_RETURN(eStatus, "Convert graphic resource failed");
1801 }
1802 else
1803 {
1804 estatus = GraphicsResourceSpecificNext::AllocateExternalResource(streamState, params, resource);
1805 MOS_OS_CHK_STATUS_MESSAGE_RETURN(estatus, "Allocate external graphic resource failed");
1806 }
1807
1808 MOS_OS_CHK_NULL_RETURN(resource->pGmmResInfo);
1809 MosUtilities::MosAtomicIncrement(MosUtilities::m_mosMemAllocCounterGfx);
1810
1811 MOS_MEMNINJA_GFX_ALLOC_MESSAGE(
1812 resource->pGmmResInfo,
1813 params->pBufName,
1814 streamState->component,
1815 (uint32_t)resource->pGmmResInfo->GetSizeSurface(),
1816 params->dwArraySize,
1817 functionName,
1818 filename,
1819 line);
1820
1821 return MOS_STATUS_SUCCESS;
1822 }
1823
1824 //The input bit definition in MOS_GFXRES_FREE_FLAGS
ConvertHalFreeFlagsToOsFreeFlags(uint32_t halFreeFlag)1825 uint32_t MosInterface::ConvertHalFreeFlagsToOsFreeFlags(
1826 uint32_t halFreeFlag)
1827 {
1828 return halFreeFlag;
1829 }
1830
FreeResource(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE resource,uint32_t flag,const char * functionName,const char * filename,int32_t line)1831 MOS_STATUS MosInterface::FreeResource(
1832 MOS_STREAM_HANDLE streamState,
1833 MOS_RESOURCE_HANDLE resource,
1834 uint32_t flag
1835 #if MOS_MESSAGES_ENABLED
1836 ,
1837 const char *functionName,
1838 const char *filename,
1839 int32_t line
1840 #endif // MOS_MESSAGES_ENABLED
1841 )
1842 {
1843 MOS_OS_FUNCTION_ENTER;
1844
1845 MOS_OS_CHK_NULL_RETURN(resource);
1846 MOS_OS_CHK_NULL_RETURN(streamState);
1847 MOS_OS_CHK_NULL_RETURN(streamState->osDeviceContext);
1848
1849 bool osContextValid = streamState->osDeviceContext->GetOsContextValid();
1850
1851 bool byPassMod = !((!resource->bConvertedFromDDIResource) && (osContextValid == true) && (resource->pGfxResourceNext));
1852
1853 if (!byPassMod)
1854 {
1855 if (resource && resource->pGfxResourceNext)
1856 {
1857 resource->pGfxResourceNext->Free(streamState->osDeviceContext);
1858 }
1859 else
1860 {
1861 MOS_OS_VERBOSEMESSAGE("Received an empty Graphics Resource, skip free");
1862 }
1863 MOS_Delete(resource->pGfxResourceNext);
1864 resource->pGfxResourceNext = nullptr;
1865
1866 MosUtilities::MosAtomicDecrement(MosUtilities::m_mosMemAllocCounterGfx);
1867 MOS_MEMNINJA_GFX_FREE_MESSAGE(resource->pGmmResInfo, functionName, filename, line);
1868 MosUtilities::MosZeroMemory(resource, sizeof(*resource));
1869
1870 return MOS_STATUS_SUCCESS;
1871 }
1872
1873 MOS_STATUS status = GraphicsResourceSpecificNext::FreeExternalResource(streamState, resource, flag);
1874
1875 if (resource->pGmmResInfo != nullptr &&
1876 streamState->perStreamParameters != nullptr)
1877 {
1878 PMOS_CONTEXT perStreamParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
1879 if (perStreamParameters && perStreamParameters->pGmmClientContext)
1880 {
1881 MosUtilities::MosAtomicDecrement(MosUtilities::m_mosMemAllocCounterGfx);
1882 MOS_MEMNINJA_GFX_FREE_MESSAGE(resource->pGmmResInfo, functionName, filename, line);
1883
1884 perStreamParameters->pGmmClientContext->DestroyResInfoObject(resource->pGmmResInfo);
1885
1886 resource->pGmmResInfo = nullptr;
1887 }
1888 }
1889
1890 return status;
1891 }
1892
FreeResource(OsDeviceContext * osDeviceContext,MOS_RESOURCE_HANDLE resource,uint32_t flag,const char * functionName,const char * filename,int32_t line)1893 MOS_STATUS MosInterface::FreeResource(
1894 OsDeviceContext *osDeviceContext,
1895 MOS_RESOURCE_HANDLE resource,
1896 uint32_t flag
1897 #if MOS_MESSAGES_ENABLED
1898 ,
1899 const char *functionName,
1900 const char *filename,
1901 int32_t line
1902 #endif // MOS_MESSAGES_ENABLED
1903 )
1904 {
1905 MOS_OS_FUNCTION_ENTER;
1906 return MOS_STATUS_UNIMPLEMENTED;
1907 }
1908
GetResourceInfo(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE resource,MosResourceInfo & details)1909 MOS_STATUS MosInterface::GetResourceInfo(
1910 MOS_STREAM_HANDLE streamState,
1911 MOS_RESOURCE_HANDLE resource,
1912 MosResourceInfo &details) //MOS_SURFACE
1913 {
1914 MOS_OS_FUNCTION_ENTER;
1915
1916 GMM_RESOURCE_INFO * gmmResourceInfo = nullptr;
1917 GMM_DISPLAY_FRAME gmmChannel = GMM_DISPLAY_FRAME_MAX;
1918 GMM_REQ_OFFSET_INFO reqInfo[3] = {};
1919 GMM_RESOURCE_FLAG gmmFlags = {};
1920 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1921
1922 MOS_UNUSED(streamState);
1923 MOS_OS_CHK_NULL_RETURN(resource);
1924
1925 // Get Gmm resource info
1926 gmmResourceInfo = (GMM_RESOURCE_INFO*)resource->pGmmResInfo;
1927 MOS_OS_CHK_NULL_RETURN(gmmResourceInfo);
1928
1929 gmmFlags = gmmResourceInfo->GetResFlags();
1930
1931 // Get resource information
1932 details.dwWidth = GFX_ULONG_CAST(gmmResourceInfo->GetBaseWidth());
1933 details.dwHeight = gmmResourceInfo->GetBaseHeight();
1934 details.dwPitch = GFX_ULONG_CAST(gmmResourceInfo->GetRenderPitch());
1935 details.dwSize = GFX_ULONG_CAST(gmmResourceInfo->GetSizeSurface());
1936 details.dwDepth = MOS_MAX(1, gmmResourceInfo->GetBaseDepth());
1937 details.dwLockPitch = GFX_ULONG_CAST(gmmResourceInfo->GetRenderPitch());
1938
1939 details.dwQPitch = gmmResourceInfo->GetQPitch();
1940
1941 details.bCompressible = gmmFlags.Gpu.MMC ?
1942 (gmmResourceInfo->GetMmcHint(0) == GMM_MMC_HINT_ON) : false;
1943 details.bIsCompressed = gmmResourceInfo->IsMediaMemoryCompressed(0);
1944 details.CompressionMode = (MOS_RESOURCE_MMC_MODE)gmmResourceInfo->GetMmcMode(0);
1945
1946 auto skuTable = MosInterface::GetSkuTable(streamState);
1947 if(skuTable && MEDIA_IS_SKU(skuTable, FtrXe2Compression))
1948 {
1949 if (gmmResourceInfo->GetResFlags().Info.MediaCompressed == 1)
1950 {
1951 details.CompressionMode = MOS_MMC_MC;
1952 details.bIsCompressed = 1;
1953 details.bCompressible = (details.CompressionMode != MOS_MMC_DISABLED) ? true : false;
1954 }
1955 }
1956
1957 if (0 == details.dwPitch)
1958 {
1959 MOS_OS_ASSERTMESSAGE("Pitch from GmmResource is 0, unexpected.");
1960 return MOS_STATUS_INVALID_PARAMETER;
1961 }
1962 // check resource's tile type
1963 details.TileModeGMM = (MOS_TILE_MODE_GMM)gmmResourceInfo->GetTileModeSurfaceState();
1964 details.bGMMTileEnabled = true;
1965 switch (gmmResourceInfo->GetTileType())
1966 {
1967 case GMM_TILED_Y:
1968 if (gmmFlags.Info.TiledYf)
1969 {
1970 details.TileType = MOS_TILE_YF;
1971 }
1972 else if (gmmFlags.Info.TiledYs)
1973 {
1974 details.TileType = MOS_TILE_YS;
1975 }
1976 else
1977 {
1978 details.TileType = MOS_TILE_Y;
1979 }
1980 break;
1981 case GMM_TILED_X:
1982 details.TileType = MOS_TILE_X;
1983 break;
1984 case GMM_NOT_TILED:
1985 details.TileType = MOS_TILE_LINEAR;
1986 break;
1987 default:
1988 details.TileType = MOS_TILE_Y;
1989 break;
1990 }
1991 details.Format = resource->Format;
1992
1993 // Get planes
1994 MosUtilities::MosZeroMemory(reqInfo, sizeof(reqInfo));
1995 gmmChannel = GMM_DISPLAY_BASE;
1996 // Get the base offset of the surface (plane Y)
1997 reqInfo[2].ReqRender = true;
1998 reqInfo[2].Plane = GMM_PLANE_Y;
1999 reqInfo[2].Frame = gmmChannel;
2000 reqInfo[2].CubeFace = __GMM_NO_CUBE_MAP;
2001 reqInfo[2].ArrayIndex = 0;
2002 gmmResourceInfo->GetOffset(reqInfo[2]);
2003 details.RenderOffset.YUV.Y.BaseOffset = reqInfo[2].Render.Offset;
2004 details.RenderOffset.YUV.Y.XOffset = reqInfo[2].Render.XOffset;
2005 details.RenderOffset.YUV.Y.YOffset = reqInfo[2].Render.YOffset;
2006 details.LockOffset.YUV.Y = reqInfo[2].Lock.Offset;
2007
2008 // Get U/UV plane information (plane offset, X/Y offset)
2009 reqInfo[0].ReqRender = true;
2010 reqInfo[0].Plane = GMM_PLANE_U;
2011 reqInfo[0].Frame = gmmChannel;
2012 reqInfo[0].CubeFace = __GMM_NO_CUBE_MAP;
2013 reqInfo[0].ArrayIndex = 0;
2014 gmmResourceInfo->GetOffset(reqInfo[0]);
2015
2016 details.RenderOffset.YUV.U.BaseOffset = reqInfo[0].Render.Offset;
2017 details.RenderOffset.YUV.U.XOffset = reqInfo[0].Render.XOffset;
2018 details.RenderOffset.YUV.U.YOffset = reqInfo[0].Render.YOffset;
2019 details.LockOffset.YUV.U = reqInfo[0].Lock.Offset;
2020
2021 // Get V plane information (plane offset, X/Y offset)
2022 reqInfo[1].ReqRender = true;
2023 reqInfo[1].Plane = GMM_PLANE_V;
2024 reqInfo[1].Frame = gmmChannel;
2025 reqInfo[1].CubeFace = __GMM_NO_CUBE_MAP;
2026 reqInfo[1].ArrayIndex = 0;
2027 gmmResourceInfo->GetOffset(reqInfo[1]);
2028
2029 details.RenderOffset.YUV.V.BaseOffset = reqInfo[1].Render.Offset;
2030 details.RenderOffset.YUV.V.XOffset = reqInfo[1].Render.XOffset;
2031 details.RenderOffset.YUV.V.YOffset = reqInfo[1].Render.YOffset;
2032 details.LockOffset.YUV.V = reqInfo[1].Lock.Offset;
2033
2034 // Get Y plane information (plane offset, X / Y offset)
2035 details.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
2036 details.YPlaneOffset.iSurfaceOffset = details.RenderOffset.YUV.Y.BaseOffset;
2037 details.YPlaneOffset.iXOffset = details.RenderOffset.YUV.Y.XOffset;
2038 details.YPlaneOffset.iYOffset = details.RenderOffset.YUV.Y.YOffset;
2039 details.YPlaneOffset.iLockSurfaceOffset = details.LockOffset.YUV.Y;
2040
2041 // Get U/UV plane information (plane offset, X/Y offset)
2042 details.UPlaneOffset.iSurfaceOffset = details.RenderOffset.YUV.U.BaseOffset;
2043 details.UPlaneOffset.iXOffset = details.RenderOffset.YUV.U.XOffset;
2044 details.UPlaneOffset.iYOffset = details.RenderOffset.YUV.U.YOffset;
2045 details.UPlaneOffset.iLockSurfaceOffset = details.LockOffset.YUV.U;
2046
2047 // Get V plane information (plane offset, X/Y offset)
2048 details.VPlaneOffset.iSurfaceOffset = details.RenderOffset.YUV.V.BaseOffset;
2049 details.VPlaneOffset.iXOffset = details.RenderOffset.YUV.V.XOffset;
2050 details.VPlaneOffset.iYOffset = details.RenderOffset.YUV.V.YOffset;
2051 details.VPlaneOffset.iLockSurfaceOffset = details.LockOffset.YUV.V;
2052
2053 details.YoffsetForUplane = (details.UPlaneOffset.iSurfaceOffset - details.dwOffset) / details.dwPitch +
2054 details.UPlaneOffset.iYOffset;
2055 details.YoffsetForVplane = (details.VPlaneOffset.iSurfaceOffset - details.dwOffset) / details.dwPitch +
2056 details.VPlaneOffset.iYOffset;
2057
2058 // Update Uncompressed write request from resources
2059 if (gmmResourceInfo->GetMmcHint(0) == GMM_MMC_HINT_OFF)
2060 {
2061 resource->bUncompressedWriteNeeded = true;
2062 }
2063
2064 return eStatus;
2065 }
2066
LockMosResource(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE resource,PMOS_LOCK_PARAMS flags)2067 void *MosInterface::LockMosResource(
2068 MOS_STREAM_HANDLE streamState,
2069 MOS_RESOURCE_HANDLE resource,
2070 PMOS_LOCK_PARAMS flags)
2071 {
2072 MOS_OS_FUNCTION_ENTER;
2073
2074 void *pData = nullptr;
2075
2076 if (nullptr == streamState)
2077 {
2078 MOS_OS_ASSERTMESSAGE("input parameter streamState is NULL.");
2079 return nullptr;
2080 }
2081
2082 if (nullptr == resource)
2083 {
2084 MOS_OS_ASSERTMESSAGE("input parameter resource is NULL.");
2085 return nullptr;
2086 }
2087
2088 if ((!resource->bConvertedFromDDIResource) && (resource->pGfxResourceNext))
2089 {
2090 if (nullptr == streamState->osDeviceContext)
2091 {
2092 MOS_OS_ASSERTMESSAGE("invalid osDeviceContext, skip lock");
2093 return nullptr;
2094 }
2095
2096 if (resource->pGfxResourceNext)
2097 {
2098 GraphicsResourceNext::LockParams params(flags);
2099 pData = resource->pGfxResourceNext->Lock(streamState->osDeviceContext, params);
2100 }
2101 else
2102 {
2103 MOS_OS_ASSERTMESSAGE("Received an empty Graphics Resource, skip lock");
2104 return nullptr;
2105 }
2106 return pData;
2107 }
2108
2109 pData = GraphicsResourceSpecificNext::LockExternalResource(streamState, resource, flags);
2110 return pData;
2111 }
2112
LockMosResource(OsDeviceContext * osDeviceContext,MOS_RESOURCE_HANDLE resource,PMOS_LOCK_PARAMS flags,bool isDumpPacket)2113 void *MosInterface::LockMosResource(
2114 OsDeviceContext *osDeviceContext,
2115 MOS_RESOURCE_HANDLE resource,
2116 PMOS_LOCK_PARAMS flags,
2117 bool isDumpPacket)
2118 {
2119 MOS_OS_FUNCTION_ENTER;
2120 return nullptr;
2121 }
2122
UnlockMosResource(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE resource)2123 MOS_STATUS MosInterface::UnlockMosResource(
2124 MOS_STREAM_HANDLE streamState,
2125 MOS_RESOURCE_HANDLE resource)
2126 {
2127 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2128
2129 MOS_OS_FUNCTION_ENTER;
2130
2131 MOS_OS_CHK_NULL_RETURN(resource);
2132 MOS_OS_CHK_NULL_RETURN(streamState);
2133 MOS_OS_CHK_NULL_RETURN(streamState->osDeviceContext);
2134
2135 if ((!resource->bConvertedFromDDIResource) && (resource->pGfxResourceNext))
2136 {
2137 if (resource->pGfxResourceNext)
2138 {
2139 eStatus = resource->pGfxResourceNext->Unlock(streamState->osDeviceContext);
2140 }
2141 else
2142 {
2143 MOS_OS_VERBOSEMESSAGE("Received an empty Graphics Resource, skip unlock");
2144 }
2145 return eStatus;
2146 }
2147
2148 eStatus = GraphicsResourceSpecificNext::UnlockExternalResource(streamState, resource);
2149
2150 return eStatus;
2151 }
2152
UnlockMosResource(OsDeviceContext * osDeviceContext,MOS_RESOURCE_HANDLE resource)2153 MOS_STATUS MosInterface::UnlockMosResource(
2154 OsDeviceContext *osDeviceContext,
2155 MOS_RESOURCE_HANDLE resource)
2156 {
2157 MOS_OS_FUNCTION_ENTER;
2158 return MOS_STATUS_UNIMPLEMENTED;
2159 }
2160
UpdateResourceUsageType(PMOS_RESOURCE pOsResource,MOS_HW_RESOURCE_DEF resUsageType)2161 MOS_STATUS MosInterface::UpdateResourceUsageType(
2162 PMOS_RESOURCE pOsResource,
2163 MOS_HW_RESOURCE_DEF resUsageType)
2164 {
2165 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2166
2167 //---------------------------------
2168 MOS_OS_CHK_NULL_RETURN(pOsResource);
2169 MOS_OS_CHK_NULL_RETURN(pOsResource->pGmmResInfo);
2170 //---------------------------------
2171
2172 pOsResource->mocsMosResUsageType = resUsageType;
2173 pOsResource->pGmmResInfo->OverrideCachePolicyUsage(GetGmmResourceUsageType(resUsageType));
2174
2175 return eStatus;
2176 }
2177
RegisterResource(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE resource,bool write)2178 MOS_STATUS MosInterface::RegisterResource(
2179 MOS_STREAM_HANDLE streamState,
2180 MOS_RESOURCE_HANDLE resource,
2181 bool write)
2182 {
2183 MOS_OS_FUNCTION_ENTER;
2184
2185 MOS_OS_CHK_NULL_RETURN(streamState);
2186 MOS_OS_CHK_NULL_RETURN(resource);
2187 MOS_OS_CHK_NULL_RETURN(streamState->osDeviceContext);
2188
2189 #if (_DEBUG || _RELEASE_INTERNAL)
2190 if (MosSimulateOsApiFail(OS_FAIL_REGISTER_GFX_RES, __FUNCTION__, __FILE__, __LINE__))
2191 {
2192 return MOS_STATUS_NO_SPACE;
2193 }
2194 #endif
2195
2196 auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
2197 MOS_OS_CHK_NULL_RETURN(gpuContext);
2198
2199 return (gpuContext->RegisterResource(resource, write));
2200 }
2201
GetResourceGfxAddress(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE resource)2202 uint64_t MosInterface::GetResourceGfxAddress(
2203 MOS_STREAM_HANDLE streamState,
2204 MOS_RESOURCE_HANDLE resource)
2205 {
2206 MOS_OS_FUNCTION_ENTER;
2207
2208 MOS_OS_CHK_NULL_RETURN(streamState);
2209 MOS_OS_CHK_NULL_RETURN(resource);
2210
2211 if (!mos_bo_is_softpin(resource->bo))
2212 {
2213 mos_bo_set_softpin(resource->bo);
2214 }
2215 return resource->bo->offset64;
2216 }
2217
GetResourceAllocationHandle(MOS_RESOURCE_HANDLE resource)2218 uint32_t MosInterface::GetResourceAllocationHandle(
2219 MOS_RESOURCE_HANDLE resource)
2220 {
2221 MOS_OS_FUNCTION_ENTER;
2222
2223 if (resource && resource->bo)
2224 {
2225 return resource->bo->handle;
2226 }
2227 else
2228 {
2229 return 0;
2230 }
2231 }
2232
GetResourceAllocationIndex(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE resource)2233 uint32_t MosInterface::GetResourceAllocationIndex(
2234 MOS_STREAM_HANDLE streamState,
2235 MOS_RESOURCE_HANDLE resource)
2236 {
2237 MOS_OS_FUNCTION_ENTER;
2238
2239 return 0;
2240 }
2241
SkipResourceSync(MOS_RESOURCE_HANDLE resource)2242 MOS_STATUS MosInterface::SkipResourceSync(
2243 MOS_RESOURCE_HANDLE resource)
2244 {
2245 MOS_OS_FUNCTION_ENTER;
2246
2247 // No resource sync to skip
2248
2249 return MOS_STATUS_SUCCESS;
2250 }
2251
SyncOnResource(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE resource,bool writeOperation,GPU_CONTEXT_HANDLE requsetorGpuContext)2252 MOS_STATUS SyncOnResource(
2253 MOS_STREAM_HANDLE streamState,
2254 MOS_RESOURCE_HANDLE resource,
2255 bool writeOperation,
2256 GPU_CONTEXT_HANDLE requsetorGpuContext)
2257 {
2258 MOS_OS_FUNCTION_ENTER;
2259
2260 // No need to do sync on resource
2261
2262 return MOS_STATUS_SUCCESS;
2263 }
2264
ResourceSyncCallback(OsSpecificRes resource,MOS_DEVICE_HANDLE deviceContext,uint32_t index,SYNC_HAZARD hazardType,GPU_CONTEXT_HANDLE busyCtx,GPU_CONTEXT_HANDLE requestorCtx,OS_HANDLE osHandle,SYNC_FENCE_INFO_TRINITY * fenceInfoTrinity)2265 MOS_STATUS MosInterface::ResourceSyncCallback(
2266 OsSpecificRes resource,
2267 MOS_DEVICE_HANDLE deviceContext,
2268 uint32_t index,
2269 SYNC_HAZARD hazardType,
2270 GPU_CONTEXT_HANDLE busyCtx,
2271 GPU_CONTEXT_HANDLE requestorCtx,
2272 OS_HANDLE osHandle,
2273 SYNC_FENCE_INFO_TRINITY *fenceInfoTrinity)
2274 {
2275 MOS_OS_FUNCTION_ENTER;
2276
2277 // No need to do resource sync
2278
2279 return MOS_STATUS_SUCCESS;
2280 }
2281
LockSyncCallback(OsSpecificRes resource,MOS_DEVICE_HANDLE deviceContext,uint32_t index,SYNC_HAZARD hazardType,GPU_CONTEXT_HANDLE busyCtx,bool doNotWait)2282 MOS_STATUS MosInterface::LockSyncCallback(
2283 OsSpecificRes resource,
2284 MOS_DEVICE_HANDLE deviceContext,
2285 uint32_t index,
2286 SYNC_HAZARD hazardType,
2287 GPU_CONTEXT_HANDLE busyCtx,
2288 bool doNotWait)
2289 {
2290 MOS_OS_FUNCTION_ENTER;
2291
2292 // No need to do Lock sync
2293
2294 return MOS_STATUS_SUCCESS;
2295 }
2296
WaitForCmdCompletion(MOS_STREAM_HANDLE streamState,GPU_CONTEXT_HANDLE gpuCtx)2297 MOS_STATUS MosInterface::WaitForCmdCompletion(
2298 MOS_STREAM_HANDLE streamState,
2299 GPU_CONTEXT_HANDLE gpuCtx)
2300 {
2301 MOS_OS_FUNCTION_ENTER;
2302
2303 // No need to do WaitForCmdCompletion
2304
2305 return MOS_STATUS_SUCCESS;
2306 }
2307
TrimResidency(MOS_DEVICE_HANDLE device,bool periodicTrim,bool restartPeriodicTrim,uint64_t & numBytesToTrim,bool trimToMinimum,bool trimOnlyMediaResources)2308 MOS_STATUS MosInterface::TrimResidency(
2309 MOS_DEVICE_HANDLE device,
2310 bool periodicTrim,
2311 bool restartPeriodicTrim,
2312 uint64_t &numBytesToTrim,
2313 bool trimToMinimum,
2314 bool trimOnlyMediaResources)
2315 {
2316 MOS_OS_FUNCTION_ENTER;
2317
2318 // No residency to trim
2319
2320 return MOS_STATUS_SUCCESS;
2321 }
2322
UpdateResidency(MOS_DEVICE_HANDLE device,OsSpecificRes resInfo,uint32_t index)2323 MOS_STATUS UpdateResidency(
2324 MOS_DEVICE_HANDLE device,
2325 OsSpecificRes resInfo,
2326 uint32_t index)
2327 {
2328 MOS_OS_FUNCTION_ENTER;
2329
2330 // No residency to update
2331
2332 return MOS_STATUS_SUCCESS;
2333 }
2334
SetMemoryCompressionMode(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE resource,MOS_MEMCOMP_STATE resMmcMode)2335 MOS_STATUS MosInterface::SetMemoryCompressionMode(
2336 MOS_STREAM_HANDLE streamState,
2337 MOS_RESOURCE_HANDLE resource,
2338 MOS_MEMCOMP_STATE resMmcMode)
2339 {
2340 MOS_OS_FUNCTION_ENTER;
2341
2342 PGMM_RESOURCE_INFO pGmmResourceInfo = nullptr;
2343 GMM_RESOURCE_MMC_INFO GmmResMmcMode = GMM_MMC_DISABLED;
2344 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
2345
2346 MOS_OS_CHK_NULL_RETURN(resource);
2347
2348 // Get Gmm resource info
2349 pGmmResourceInfo = (GMM_RESOURCE_INFO *)resource->pGmmResInfo;
2350 MOS_OS_CHK_NULL_RETURN(pGmmResourceInfo);
2351
2352 switch (resMmcMode)
2353 {
2354 case MOS_MEMCOMP_HORIZONTAL:
2355 GmmResMmcMode = GMM_MMC_HORIZONTAL;
2356 break;
2357 case MOS_MEMCOMP_VERTICAL:
2358 GmmResMmcMode = GMM_MMC_VERTICAL;
2359 break;
2360 case MOS_MEMCOMP_DISABLED:
2361 default:
2362 GmmResMmcMode = GMM_MMC_DISABLED;
2363 break;
2364 }
2365
2366 pGmmResourceInfo->SetMmcMode(GmmResMmcMode, 0);
2367
2368 eStatus = MOS_STATUS_SUCCESS;
2369
2370 return eStatus;
2371 }
2372
GetMemoryCompressionMode(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE resource,MOS_MEMCOMP_STATE & resMmcMode)2373 MOS_STATUS MosInterface::GetMemoryCompressionMode(
2374 MOS_STREAM_HANDLE streamState,
2375 MOS_RESOURCE_HANDLE resource,
2376 MOS_MEMCOMP_STATE &resMmcMode)
2377 {
2378 MOS_OS_FUNCTION_ENTER;
2379
2380 PGMM_RESOURCE_INFO gmmResourceInfo = nullptr;
2381 GMM_RESOURCE_FLAG flags;
2382 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
2383
2384 MOS_OS_CHK_NULL_RETURN(resource);
2385 MosUtilities::MosZeroMemory(&flags, sizeof(GMM_RESOURCE_FLAG));
2386
2387 // Get Gmm resource info
2388 gmmResourceInfo = (GMM_RESOURCE_INFO *)resource->pGmmResInfo;
2389 MOS_OS_CHK_NULL_RETURN(gmmResourceInfo);
2390 auto skuTable = GetSkuTable(streamState);
2391 MOS_OS_CHK_NULL_RETURN(MosInterface::GetGmmClientContext(streamState));
2392 MOS_OS_CHK_NULL_RETURN(skuTable);
2393
2394 if (MEDIA_IS_SKU(skuTable, FtrXe2Compression))
2395 {
2396 // reusing MC to mark all media engins to turn on compression
2397 if (resource->pGmmResInfo->GetResFlags().Info.MediaCompressed == 1)
2398 {
2399 resMmcMode = MOS_MEMCOMP_MC;
2400 }
2401 else
2402 {
2403 resMmcMode = MOS_MEMCOMP_DISABLED;
2404 }
2405 return MOS_STATUS_SUCCESS;
2406 }
2407
2408 flags = resource->pGmmResInfo->GetResFlags();
2409
2410 if (!flags.Gpu.MMC || !flags.Gpu.CCS)
2411 {
2412 resMmcMode = MOS_MEMCOMP_DISABLED;
2413 return MOS_STATUS_SUCCESS;
2414 }
2415
2416 if (flags.Info.MediaCompressed || flags.Info.RenderCompressed)
2417 {
2418 resMmcMode = flags.Info.RenderCompressed ? MOS_MEMCOMP_RC : MOS_MEMCOMP_MC;
2419 }
2420 else
2421 {
2422 switch (gmmResourceInfo->GetMmcMode(0))
2423 {
2424 case GMM_MMC_HORIZONTAL:
2425 resMmcMode = MOS_MEMCOMP_HORIZONTAL;
2426 break;
2427 case GMM_MMC_VERTICAL:
2428 resMmcMode = MOS_MEMCOMP_VERTICAL;
2429 break;
2430 case GMM_MMC_DISABLED:
2431 default:
2432 resMmcMode = MOS_MEMCOMP_DISABLED;
2433 break;
2434 }
2435 }
2436
2437 uint32_t MmcFormat = 0;
2438 GMM_RESOURCE_FORMAT gmmResFmt;
2439 gmmResFmt = gmmResourceInfo->GetResourceFormat();
2440
2441 if (resMmcMode == MOS_MEMCOMP_MC)
2442 {
2443 MmcFormat = static_cast<uint32_t>(MosInterface::GetGmmClientContext(streamState)->GetMediaSurfaceStateCompressionFormat(gmmResFmt));
2444 resMmcMode = (MmcFormat > 0 && MmcFormat < 0x1f) ? resMmcMode : MOS_MEMCOMP_DISABLED;
2445 }
2446
2447 eStatus = MOS_STATUS_SUCCESS;
2448
2449 return eStatus;
2450 }
2451
SetMemoryCompressionHint(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE resource,bool hintOn)2452 MOS_STATUS MosInterface::SetMemoryCompressionHint(
2453 MOS_STREAM_HANDLE streamState,
2454 MOS_RESOURCE_HANDLE resource,
2455 bool hintOn)
2456 {
2457 MOS_OS_FUNCTION_ENTER;
2458
2459 PGMM_RESOURCE_INFO pGmmResourceInfo = nullptr;
2460 uint32_t uiArrayIndex = 0;
2461 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
2462 MOS_OS_CHK_NULL_RETURN(resource);
2463
2464 // Get Gmm resource info
2465 pGmmResourceInfo = (GMM_RESOURCE_INFO *)resource->pGmmResInfo;
2466 MOS_OS_CHK_NULL_RETURN(pGmmResourceInfo);
2467
2468 pGmmResourceInfo->SetMmcHint(hintOn ? GMM_MMC_HINT_ON : GMM_MMC_HINT_OFF, uiArrayIndex);
2469
2470 eStatus = MOS_STATUS_SUCCESS;
2471
2472 return eStatus;
2473 }
2474
GetMemoryCompressionFormat(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE resource,uint32_t * resMmcFormat)2475 MOS_STATUS MosInterface::GetMemoryCompressionFormat(
2476 MOS_STREAM_HANDLE streamState,
2477 MOS_RESOURCE_HANDLE resource,
2478 uint32_t * resMmcFormat)
2479 {
2480 MOS_OS_FUNCTION_ENTER;
2481
2482 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
2483 PGMM_RESOURCE_INFO pGmmResourceInfo;
2484
2485 MOS_OS_CHK_NULL_RETURN(streamState);
2486 MOS_OS_CHK_NULL_RETURN(resource);
2487 MOS_OS_CHK_NULL_RETURN(resMmcFormat);
2488
2489 pGmmResourceInfo = (GMM_RESOURCE_INFO *)resource->pGmmResInfo;
2490 MOS_OS_CHK_NULL_RETURN(pGmmResourceInfo);
2491 MOS_OS_CHK_NULL_RETURN(MosInterface::GetGmmClientContext(streamState));
2492 // Get compression format from GMM RESOURCE FORMAT
2493 GMM_RESOURCE_FORMAT gmmResFmt;
2494 gmmResFmt = pGmmResourceInfo->GetResourceFormat();
2495 MOS_MEMCOMP_STATE MmcMode = MOS_MEMCOMP_DISABLED;
2496 uint32_t MmcFormat = 0;
2497 MosInterface::GetMemoryCompressionMode(streamState, resource, MmcMode);
2498 switch (MmcMode)
2499 {
2500 case MOS_MEMCOMP_MC:
2501 MmcFormat = static_cast<uint32_t>(MosInterface::GetGmmClientContext(streamState)->GetMediaSurfaceStateCompressionFormat(gmmResFmt));
2502 break;
2503 case MOS_MEMCOMP_RC:
2504 MmcFormat = static_cast<uint32_t>(MosInterface::GetGmmClientContext(streamState)->GetSurfaceStateCompressionFormat(gmmResFmt));
2505 break;
2506 default:
2507 MmcFormat = 0;
2508 }
2509
2510 if (MmcFormat > 0x1F)
2511 {
2512 MOS_OS_ASSERTMESSAGE("Get a incorrect Compression format(%d) from GMM", MmcFormat);
2513 }
2514 else
2515 {
2516 *resMmcFormat = MmcFormat;
2517 MOS_OS_VERBOSEMESSAGE("GMM compression mode %d, compression format %d", MmcMode, MmcFormat);
2518 }
2519
2520 eStatus = MOS_STATUS_SUCCESS;
2521
2522 return eStatus;
2523 }
2524
UnifiedMediaCopyResource(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE inputResource,MOS_RESOURCE_HANDLE outputResource,int preferMethod)2525 MOS_STATUS MosInterface::UnifiedMediaCopyResource(
2526 MOS_STREAM_HANDLE streamState,
2527 MOS_RESOURCE_HANDLE inputResource,
2528 MOS_RESOURCE_HANDLE outputResource,
2529 int preferMethod)
2530 {
2531 auto pOsDeviceContext = streamState->osDeviceContext;
2532 MOS_OS_CHK_NULL_RETURN(pOsDeviceContext);
2533 auto pMosMediaCopy = pOsDeviceContext->GetMosMediaCopy();
2534 MOS_OS_CHK_NULL_RETURN(pMosMediaCopy);
2535
2536 return pMosMediaCopy->MediaCopy(inputResource, outputResource, (MCPY_METHOD)preferMethod);
2537 }
2538
DoubleBufferCopyResource(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE inputResource,MOS_RESOURCE_HANDLE outputResource,bool outputCompressed)2539 MOS_STATUS MosInterface::DoubleBufferCopyResource(
2540 MOS_STREAM_HANDLE streamState,
2541 MOS_RESOURCE_HANDLE inputResource,
2542 MOS_RESOURCE_HANDLE outputResource,
2543 bool outputCompressed)
2544 {
2545 MOS_OS_FUNCTION_ENTER;
2546
2547 MOS_STATUS status = MOS_STATUS_SUCCESS;
2548 MOS_OS_CHK_NULL_RETURN(inputResource);
2549 MOS_OS_CHK_NULL_RETURN(outputResource);
2550 MOS_OS_CHK_NULL_RETURN(streamState);
2551
2552 MosDecompression *mosDecompression = nullptr;
2553 auto lbdMemDecomp = [&]()
2554 {
2555 if (inputResource->bo && inputResource->pGmmResInfo &&
2556 outputResource->bo && outputResource->pGmmResInfo)
2557 {
2558 MOS_OS_CHK_STATUS_RETURN(MosInterface::GetMosDecompressionFromStreamState(streamState, mosDecompression));
2559 MOS_OS_CHK_NULL_RETURN(mosDecompression);
2560
2561 // Double Buffer Copy can support any tile status surface with/without compression
2562 return mosDecompression->MediaMemoryCopy(inputResource, outputResource, outputCompressed);
2563 }
2564 else
2565 {
2566 return MOS_STATUS_NULL_POINTER;
2567 }
2568 };
2569
2570 // If mmd device not registered, use media vebopx copy.
2571 if (lbdMemDecomp() != MOS_STATUS_SUCCESS && mosDecompression && !mosDecompression->GetMediaMemDecompState())
2572 {
2573 MOS_OS_CRITICALMESSAGE("MMD device not registered. Use media copy instead.");
2574 status = MosInterface::UnifiedMediaCopyResource(streamState, inputResource, outputResource, MCPY_METHOD_BALANCE);
2575 }
2576
2577 return status;
2578 }
2579
VerifyMosSurface(PMOS_SURFACE mosSurface,bool & bIsValid)2580 MOS_STATUS MosInterface::VerifyMosSurface(
2581 PMOS_SURFACE mosSurface,
2582 bool &bIsValid)
2583 {
2584 MOS_OS_FUNCTION_ENTER;
2585
2586 MOS_OS_CHK_NULL_RETURN(mosSurface);
2587 MOS_OS_CHK_NULL_RETURN(mosSurface->OsResource.pGmmResInfo);
2588
2589 if ((mosSurface->dwPitch * mosSurface->dwHeight > mosSurface->OsResource.pGmmResInfo->GetSizeMainSurface() && (mosSurface->Type != MOS_GFXRES_BUFFER)) ||
2590 (mosSurface->dwPitch > mosSurface->OsResource.pGmmResInfo->GetSizeMainSurface() && (mosSurface->Type == MOS_GFXRES_BUFFER)) ||
2591 mosSurface->dwHeight == 0 ||
2592 mosSurface->dwPitch == 0)
2593 {
2594 bIsValid = false;
2595 MOS_OS_ASSERTMESSAGE("Invalid arguments for mos surface copy: dwPitch %lu, dwHeight %lu, gmmMainSurfaceSize %llu, GFXRES Type %d",
2596 mosSurface->dwPitch,
2597 mosSurface->dwHeight,
2598 mosSurface->OsResource.pGmmResInfo->GetSizeMainSurface(),
2599 mosSurface->Type);
2600 }
2601 else
2602 {
2603 bIsValid = true;
2604 }
2605
2606 return MOS_STATUS_SUCCESS;
2607 }
2608
MediaCopyResource2D(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE inputResource,MOS_RESOURCE_HANDLE outputResource,uint32_t copyWidth,uint32_t copyHeight,uint32_t bpp,bool outputCompressed)2609 MOS_STATUS MosInterface::MediaCopyResource2D(
2610 MOS_STREAM_HANDLE streamState,
2611 MOS_RESOURCE_HANDLE inputResource,
2612 MOS_RESOURCE_HANDLE outputResource,
2613 uint32_t copyWidth,
2614 uint32_t copyHeight,
2615 uint32_t bpp,
2616 bool outputCompressed)
2617 {
2618 MOS_OS_FUNCTION_ENTER;
2619
2620 MOS_STATUS status = MOS_STATUS_SUCCESS;
2621 MOS_OS_CHK_NULL_RETURN(inputResource);
2622 MOS_OS_CHK_NULL_RETURN(outputResource);
2623 MOS_OS_CHK_NULL_RETURN(streamState);
2624
2625 MosDecompression *mosDecompression = nullptr;
2626 auto lbdMemDecomp = [&]()
2627 {
2628 if (inputResource->bo && inputResource->pGmmResInfo &&
2629 outputResource->bo && outputResource->pGmmResInfo)
2630 {
2631 MOS_OS_CHK_STATUS_RETURN(MosInterface::GetMosDecompressionFromStreamState(streamState, mosDecompression));
2632 MOS_OS_CHK_NULL_RETURN(mosDecompression);
2633
2634 // Double Buffer Copy can support any tile status surface with/without compression
2635 return mosDecompression->MediaMemoryCopy2D(inputResource, outputResource,
2636 copyWidth, copyHeight, 0, 0, bpp, outputCompressed);
2637 }
2638 else
2639 {
2640 return MOS_STATUS_NULL_POINTER;
2641 }
2642 };
2643
2644 // If mmd device not registered, use media vebopx copy.
2645 if (lbdMemDecomp() != MOS_STATUS_SUCCESS && mosDecompression && !mosDecompression->GetMediaMemDecompState())
2646 {
2647 MOS_OS_CRITICALMESSAGE("MMD device not registered. Use media copy instead.");
2648 status = MosInterface::UnifiedMediaCopyResource(streamState, inputResource, outputResource, MCPY_METHOD_BALANCE);
2649 }
2650
2651 return status;
2652 }
2653
MonoSurfaceCopy(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE inputResource,MOS_RESOURCE_HANDLE outputResource,uint32_t copyWidth,uint32_t copyHeight,uint32_t copyInputOffset,uint32_t copyOutputOffset,bool outputCompressed)2654 MOS_STATUS MosInterface::MonoSurfaceCopy(
2655 MOS_STREAM_HANDLE streamState,
2656 MOS_RESOURCE_HANDLE inputResource,
2657 MOS_RESOURCE_HANDLE outputResource,
2658 uint32_t copyWidth,
2659 uint32_t copyHeight,
2660 uint32_t copyInputOffset,
2661 uint32_t copyOutputOffset,
2662 bool outputCompressed)
2663 {
2664 MOS_OS_FUNCTION_ENTER;
2665
2666 MOS_STATUS status = MOS_STATUS_SUCCESS;
2667 MOS_OS_CHK_NULL_RETURN(inputResource);
2668 MOS_OS_CHK_NULL_RETURN(outputResource);
2669 MOS_OS_CHK_NULL_RETURN(streamState);
2670
2671 MosDecompression *mosDecompression = nullptr;
2672 auto lbdMemDecomp = [&]()
2673 {
2674 if (inputResource->bo && inputResource->pGmmResInfo &&
2675 outputResource->bo && outputResource->pGmmResInfo)
2676 {
2677 MOS_OS_CHK_STATUS_RETURN(MosInterface::GetMosDecompressionFromStreamState(streamState, mosDecompression));
2678 MOS_OS_CHK_NULL_RETURN(mosDecompression);
2679
2680 // Double Buffer Copy can support any tile status surface with/without compression
2681 return mosDecompression->MediaMemoryCopy2D(inputResource, outputResource,
2682 copyWidth, copyHeight, copyInputOffset, copyOutputOffset, 16, outputCompressed);
2683 }
2684 else
2685 {
2686 return MOS_STATUS_NULL_POINTER;
2687 }
2688 };
2689
2690 // If mmd device not registered, use media vebopx copy.
2691 if (lbdMemDecomp() != MOS_STATUS_SUCCESS && mosDecompression && !mosDecompression->GetMediaMemDecompState())
2692 {
2693 MOS_OS_CRITICALMESSAGE("MMD device not registered. Use media copy instead.");
2694 MOS_SURFACE inputResInfo, outputResInfo;
2695 MOS_ZeroMemory(&inputResInfo, sizeof(MOS_SURFACE));
2696 MOS_ZeroMemory(&outputResInfo, sizeof(MOS_SURFACE));
2697
2698 struct BackupResInfo
2699 {
2700 MOS_FORMAT format;
2701 uint32_t height;
2702 uint32_t width;
2703 uint32_t pitch;
2704 uint32_t offset;
2705 };
2706
2707 inputResInfo.Format = Format_Invalid;
2708 MOS_OS_CHK_STATUS_RETURN(MosInterface::GetResourceInfo(streamState, inputResource, inputResInfo));
2709 BackupResInfo bkIn = {inputResInfo.Format, inputResInfo.dwHeight, inputResInfo.dwWidth, inputResInfo.dwPitch};
2710
2711 outputResInfo.Format = Format_Invalid;
2712 MOS_OS_CHK_STATUS_RETURN(MosInterface::GetResourceInfo(streamState, outputResource, outputResInfo));
2713 BackupResInfo bkOut = {outputResInfo.Format, outputResInfo.dwHeight, outputResInfo.dwWidth, outputResInfo.dwPitch};
2714
2715 uint32_t pixelInByte = 2;
2716 MOS_FORMAT overrideFormat = Format_Y16U;
2717
2718 inputResource->pGmmResInfo->OverrideSurfaceFormat(MosInterface::MosFmtToGmmFmt(overrideFormat));
2719 inputResource->pGmmResInfo->OverrideBaseWidth(copyWidth / pixelInByte);
2720 inputResource->pGmmResInfo->OverridePitch(copyWidth);
2721 inputResource->pGmmResInfo->OverrideBaseHeight(copyHeight);
2722 outputResource->pGmmResInfo->OverrideSurfaceFormat(MosInterface::MosFmtToGmmFmt(overrideFormat));
2723 outputResource->pGmmResInfo->OverrideBaseWidth(copyWidth / pixelInByte);
2724 outputResource->pGmmResInfo->OverridePitch(copyWidth);
2725 outputResource->pGmmResInfo->OverrideBaseHeight(copyHeight);
2726
2727 uint32_t inOffset = inputResource->dwOffsetForMono;
2728 uint32_t outOffset = outputResource->dwOffsetForMono;
2729 inputResource->dwOffsetForMono = copyInputOffset;
2730 outputResource->dwOffsetForMono = copyOutputOffset;
2731
2732 status = MosInterface::UnifiedMediaCopyResource(streamState, inputResource, outputResource, MCPY_METHOD_BALANCE);
2733
2734 inputResource->pGmmResInfo->OverrideSurfaceFormat(MosInterface::MosFmtToGmmFmt(bkIn.format));
2735 inputResource->pGmmResInfo->OverrideBaseWidth(bkIn.width);
2736 inputResource->pGmmResInfo->OverrideBaseWidth(bkIn.pitch);
2737 inputResource->pGmmResInfo->OverrideBaseHeight(bkIn.height);
2738 outputResource->pGmmResInfo->OverrideSurfaceFormat(MosInterface::MosFmtToGmmFmt(bkOut.format));
2739 outputResource->pGmmResInfo->OverrideBaseWidth(bkOut.width);
2740 outputResource->pGmmResInfo->OverrideBaseWidth(bkOut.pitch);
2741 outputResource->pGmmResInfo->OverrideBaseHeight(bkOut.height);
2742
2743 inputResource->dwOffsetForMono = inOffset;
2744 outputResource->dwOffsetForMono = outOffset;
2745 }
2746
2747 return status;
2748 }
2749
DecompResource(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE resource)2750 MOS_STATUS MosInterface::DecompResource(
2751 MOS_STREAM_HANDLE streamState,
2752 MOS_RESOURCE_HANDLE resource)
2753 {
2754 MOS_OS_FUNCTION_ENTER;
2755 MOS_STATUS status = MOS_STATUS_SUCCESS;
2756
2757 MOS_OS_CHK_NULL_RETURN(streamState);
2758 MOS_OS_CHK_NULL_RETURN(resource);
2759 MOS_OS_CHK_NULL_RETURN(resource->bo);
2760 MOS_OS_CHK_NULL_RETURN(resource->pGmmResInfo);
2761
2762 MOS_LINUX_BO *bo = resource->bo;
2763 GMM_RESOURCE_FLAG gmmFlags;
2764 gmmFlags = resource->pGmmResInfo->GetResFlags();
2765 if (((gmmFlags.Gpu.MMC ||
2766 gmmFlags.Gpu.CCS) &&
2767 gmmFlags.Gpu.UnifiedAuxSurface) ||
2768 resource->pGmmResInfo->IsMediaMemoryCompressed(0))
2769 {
2770 MosDecompression *mosDecompression = nullptr;
2771 MOS_OS_CHK_STATUS_RETURN(MosInterface::GetMosDecompressionFromStreamState(streamState, mosDecompression));
2772
2773 MOS_OS_CHK_NULL_RETURN(mosDecompression);
2774 mosDecompression->MemoryDecompress(resource);
2775
2776 MOS_OS_CHK_STATUS_RETURN(MosInterface::SetMemoryCompressionHint(streamState, resource, false));
2777 }
2778
2779 return MOS_STATUS_SUCCESS;
2780 }
2781
GetMosDecompressionFromStreamState(MOS_STREAM_HANDLE streamState,MosDecompression * & mosDecompression)2782 MOS_STATUS MosInterface::GetMosDecompressionFromStreamState(
2783 MOS_STREAM_HANDLE streamState,
2784 MosDecompression* & mosDecompression)
2785 {
2786 MOS_OS_FUNCTION_ENTER;
2787 MOS_STATUS status = MOS_STATUS_SUCCESS;
2788
2789 MOS_OS_CHK_NULL_RETURN(streamState);
2790 mosDecompression = streamState->mosDecompression;
2791 if (!mosDecompression)
2792 {
2793 if (streamState->enableDecomp)
2794 {
2795 PMOS_CONTEXT mosContext = (PMOS_CONTEXT)streamState->perStreamParameters;
2796 MOS_OS_CHK_NULL_RETURN(mosContext);
2797 mosDecompression = streamState->mosDecompression = MOS_New(MosDecompression, mosContext);
2798 }
2799 else
2800 {
2801 OsContextNext *osCtx = streamState->osDeviceContext;
2802 MOS_OS_CHK_NULL_RETURN(osCtx);
2803 mosDecompression = osCtx->GetMosDecompression();
2804 }
2805 }
2806 MOS_OS_CHK_NULL_RETURN(mosDecompression);
2807
2808 return status;
2809 }
2810
SetDecompSyncRes(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE syncResource)2811 MOS_STATUS MosInterface::SetDecompSyncRes(
2812 MOS_STREAM_HANDLE streamState,
2813 MOS_RESOURCE_HANDLE syncResource)
2814 {
2815 return MOS_STATUS_SUCCESS;
2816 }
2817
GetGpuStatusTag(MOS_STREAM_HANDLE streamState,GPU_CONTEXT_HANDLE gpuContext)2818 uint32_t MosInterface::GetGpuStatusTag(
2819 MOS_STREAM_HANDLE streamState,
2820 GPU_CONTEXT_HANDLE gpuContext)
2821 {
2822 MOS_OS_FUNCTION_ENTER;
2823
2824 if (streamState)
2825 {
2826 auto gpuContextIns = MosInterface::GetGpuContext(streamState, gpuContext);
2827 if (gpuContextIns == nullptr)
2828 {
2829 MOS_OS_ASSERTMESSAGE("Get GPU Status Tag failed.");
2830 return 0;
2831 }
2832
2833 return gpuContextIns->GetGpuStatusTag();
2834 }
2835 MOS_OS_ASSERTMESSAGE("Get GPU Status Tag failed.");
2836
2837 return 0;
2838 }
2839
IncrementGpuStatusTag(MOS_STREAM_HANDLE streamState,GPU_CONTEXT_HANDLE gpuContext)2840 MOS_STATUS MosInterface::IncrementGpuStatusTag(
2841 MOS_STREAM_HANDLE streamState,
2842 GPU_CONTEXT_HANDLE gpuContext)
2843 {
2844 MOS_OS_FUNCTION_ENTER;
2845
2846 MOS_OS_CHK_NULL_RETURN(streamState);
2847 auto gpuContextIns = MosInterface::GetGpuContext(streamState, gpuContext);
2848 MOS_OS_CHK_NULL_RETURN(gpuContextIns);
2849
2850 gpuContextIns->IncrementGpuStatusTag();
2851
2852 return MOS_STATUS_SUCCESS;
2853 }
2854
GetGpuStatusSyncTag(MOS_STREAM_HANDLE streamState,GPU_CONTEXT_HANDLE gpuContext)2855 uint64_t MosInterface::GetGpuStatusSyncTag(
2856 MOS_STREAM_HANDLE streamState,
2857 GPU_CONTEXT_HANDLE gpuContext)
2858 {
2859 MOS_OS_FUNCTION_ENTER;
2860
2861 // No Gpu Status Sync Tag in Linux
2862
2863 return 0;
2864 }
2865
GetGpuStatusBufferResource(MOS_STREAM_HANDLE streamState,MOS_RESOURCE_HANDLE & resource,GPU_CONTEXT_HANDLE gpuContext)2866 MOS_STATUS MosInterface::GetGpuStatusBufferResource(
2867 MOS_STREAM_HANDLE streamState,
2868 MOS_RESOURCE_HANDLE &resource,
2869 GPU_CONTEXT_HANDLE gpuContext)
2870 {
2871 MOS_OS_FUNCTION_ENTER;
2872
2873 MOS_OS_CHK_NULL_RETURN(streamState);
2874
2875 auto gpuContextIns = MosInterface::GetGpuContext(streamState, gpuContext);
2876 MOS_OS_CHK_NULL_RETURN(gpuContextIns);
2877
2878 resource = gpuContextIns->GetStatusBufferResource();
2879
2880 return MOS_STATUS_SUCCESS;
2881 }
2882
GetGmmClientContext(MOS_STREAM_HANDLE streamState)2883 GMM_CLIENT_CONTEXT *MosInterface::GetGmmClientContext(
2884 MOS_STREAM_HANDLE streamState)
2885 {
2886 MOS_OS_FUNCTION_ENTER;
2887
2888 if (streamState && streamState->osDeviceContext)
2889 {
2890 return streamState->osDeviceContext->GetGmmClientContext();
2891 }
2892
2893 return nullptr;
2894 }
2895
GetPATIndexFromGmm(GMM_CLIENT_CONTEXT * gmmClient,GMM_RESOURCE_INFO * gmmResourceInfo)2896 unsigned int MosInterface::GetPATIndexFromGmm(
2897 GMM_CLIENT_CONTEXT *gmmClient,
2898 GMM_RESOURCE_INFO *gmmResourceInfo)
2899 {
2900 if (gmmClient && gmmResourceInfo)
2901 {
2902 auto IsFormatSupportCompression = [=]()->bool
2903 {
2904 // formats support compression match to copy supported formats except RGBP&BGRP
2905 switch(GmmFmtToMosFmt(gmmResourceInfo->GetResourceFormat()))
2906 {
2907 case Format_NV12:
2908 case Format_YV12:
2909 case Format_I420:
2910 case Format_P010:
2911 case Format_Y410:
2912 case Format_Y416:
2913 case Format_Y210:
2914 case Format_Y216:
2915 case Format_YUY2:
2916 case Format_R5G6B5:
2917 case Format_R8G8B8:
2918 case Format_A8R8G8B8:
2919 case Format_A8B8G8R8:
2920 case Format_X8R8G8B8:
2921 case Format_X8B8G8R8:
2922 case Format_AYUV:
2923 case Format_R10G10B10A2:
2924 case Format_B10G10R10A2:
2925 case Format_P8:
2926 case Format_L8:
2927 case Format_A8:
2928 case Format_Y16U:
2929 return true;
2930 case Format_P016:
2931 // For P016 format we use SW swizzle because of history with reason (some hard code plane offset calculation in vaGetImage/vaPutImage).
2932 return false;
2933 default:
2934 return false;
2935 }
2936 };
2937 // GetDriverProtectionBits funtion could hide gmm details info,
2938 // and we should use GetDriverProtectionBits to replace CachePolicyGetPATIndex in future.
2939 // isCompressionEnable could be false temparaily.
2940 bool isCompressionEnable = false;
2941 if (gmmResourceInfo->GetResFlags().Info.MediaCompressed &&
2942 IsFormatSupportCompression() &&
2943 gmmResourceInfo->GetResFlags().Info.Tile4 == 1 &&
2944 gmmResourceInfo->GetBaseWidth() > 64 &&
2945 gmmResourceInfo->GetBaseHeight() > 64)
2946 {
2947 isCompressionEnable = true;
2948 }
2949 return gmmClient->CachePolicyGetPATIndex(
2950 gmmResourceInfo,
2951 gmmResourceInfo->GetCachePolicyUsage(),
2952 &isCompressionEnable,
2953 gmmResourceInfo->GetResFlags().Info.Cacheable);
2954 }
2955 return PAT_INDEX_INVALID;
2956 }
2957
GetGpuPriority(MOS_STREAM_HANDLE streamState,int32_t * pPriority)2958 void MosInterface::GetGpuPriority(MOS_STREAM_HANDLE streamState, int32_t* pPriority)
2959 {
2960 MOS_OS_FUNCTION_ENTER;
2961
2962 if (streamState == nullptr)
2963 {
2964 MOS_OS_ASSERTMESSAGE("Failed to set the gpu priority");
2965 return;
2966 }
2967
2968 PMOS_OS_CONTEXT pOsContext = (PMOS_OS_CONTEXT)streamState->perStreamParameters;
2969 if (pOsContext == nullptr)
2970 {
2971 MOS_OS_ASSERTMESSAGE("Failed to set the gpu priority");
2972 return;
2973 }
2974
2975 uint64_t priority = 0;
2976 mos_get_context_param(pOsContext->intel_context, 0, DRM_CONTEXT_PARAM_PRIORITY, &priority);
2977 *pPriority = (int32_t)priority;
2978 }
2979
SetGpuPriority(MOS_STREAM_HANDLE streamState,int32_t priority)2980 void MosInterface::SetGpuPriority(MOS_STREAM_HANDLE streamState, int32_t priority)
2981 {
2982 MOS_OS_FUNCTION_ENTER;
2983
2984 if (streamState == nullptr)
2985 {
2986 MOS_OS_ASSERTMESSAGE("Failed to set the gpu priority");
2987 return;
2988 }
2989
2990 if (streamState->ctxPriority == priority)
2991 return;
2992
2993 PMOS_OS_CONTEXT pOsContext = (PMOS_OS_CONTEXT)streamState->perStreamParameters;
2994 if (pOsContext == nullptr)
2995 {
2996 MOS_OS_ASSERTMESSAGE("Failed to set the gpu priority");
2997 return;
2998 }
2999
3000 int32_t ret = mos_set_context_param(pOsContext->intel_context, 0, DRM_CONTEXT_PARAM_PRIORITY,(uint64_t)priority);
3001 if (ret != 0)
3002 {
3003 MOS_OS_ASSERTMESSAGE("failed to set the gpu priority, error is %d", ret);
3004 }
3005
3006 streamState->ctxPriority = priority;
3007 }
3008
GetAuxTableBaseAddr(MOS_STREAM_HANDLE streamState)3009 uint64_t MosInterface::GetAuxTableBaseAddr(
3010 MOS_STREAM_HANDLE streamState)
3011 {
3012 MOS_OS_FUNCTION_ENTER;
3013
3014 if (!streamState || !streamState->osDeviceContext)
3015 {
3016 return 0;
3017 }
3018 auto osDeviceContextSpecific = static_cast<OsContextSpecificNext *>(streamState->osDeviceContext);
3019 auto auxTableMgr = osDeviceContextSpecific->GetAuxTableMgr();
3020 if(!auxTableMgr)
3021 {
3022 return 0;
3023 }
3024 return auxTableMgr->GetAuxTableBase();
3025 }
3026
GetCpInterface(MOS_STREAM_HANDLE streamState)3027 MosCpInterface *MosInterface::GetCpInterface(MOS_STREAM_HANDLE streamState)
3028 {
3029 MOS_OS_FUNCTION_ENTER;
3030
3031 return streamState ? streamState->osCpInterface : nullptr;
3032 }
3033
GetVirtualEngineState(MOS_STREAM_HANDLE streamState)3034 MOS_VE_HANDLE MosInterface::GetVirtualEngineState(
3035 MOS_STREAM_HANDLE streamState)
3036 {
3037 MOS_OS_FUNCTION_ENTER;
3038
3039 return streamState ? streamState->virtualEngineInterface : nullptr;
3040 }
3041
SetVirtualEngineState(MOS_STREAM_HANDLE streamState,MOS_VE_HANDLE veState)3042 MOS_STATUS MosInterface::SetVirtualEngineState(
3043 MOS_STREAM_HANDLE streamState,
3044 MOS_VE_HANDLE veState)
3045 {
3046 MOS_OS_FUNCTION_ENTER;
3047
3048 MOS_OS_CHK_NULL_RETURN(streamState);
3049 MOS_OS_CHK_NULL_RETURN(veState);
3050
3051 streamState->virtualEngineInterface = veState;
3052
3053 return MOS_STATUS_SUCCESS;
3054 }
3055
CreateVirtualEngineState(MOS_STREAM_HANDLE streamState,PMOS_VIRTUALENGINE_INIT_PARAMS veInitParms,MOS_VE_HANDLE & veState)3056 MOS_STATUS MosInterface::CreateVirtualEngineState(
3057 MOS_STREAM_HANDLE streamState,
3058 PMOS_VIRTUALENGINE_INIT_PARAMS veInitParms,
3059 MOS_VE_HANDLE& veState)
3060 {
3061 MOS_OS_FUNCTION_ENTER;
3062
3063 MOS_OS_CHK_NULL_RETURN(streamState);
3064
3065 if (veInitParms->bScalabilitySupported)
3066 {
3067 streamState->virtualEngineInterface = MOS_New(MosOsVeScalabilitySpecific);
3068 }
3069 else
3070 {
3071 streamState->virtualEngineInterface = MOS_New(MosOsVeSinglePipeSpecific);
3072 }
3073 MOS_OS_CHK_NULL_RETURN(streamState->virtualEngineInterface);
3074
3075 MOS_OS_CHK_STATUS_RETURN(streamState->virtualEngineInterface->Initialize(streamState, veInitParms));
3076
3077 veState = streamState->virtualEngineInterface;
3078
3079 return MOS_STATUS_SUCCESS;
3080 }
3081
DestroyVirtualEngineState(MOS_STREAM_HANDLE streamState)3082 MOS_STATUS MosInterface::DestroyVirtualEngineState(
3083 MOS_STREAM_HANDLE streamState)
3084 {
3085 MOS_OS_FUNCTION_ENTER;
3086
3087 MOS_OS_CHK_NULL_RETURN(streamState);
3088 if (streamState->virtualEngineInterface)
3089 {
3090 streamState->virtualEngineInterface->Destroy();
3091 MOS_Delete(streamState->virtualEngineInterface);
3092 }
3093
3094 return MOS_STATUS_SUCCESS;
3095 }
3096
SetVeHintParams(MOS_STREAM_HANDLE streamState,PMOS_VIRTUALENGINE_SET_PARAMS veParams)3097 MOS_STATUS MosInterface::SetVeHintParams(
3098 MOS_STREAM_HANDLE streamState,
3099 PMOS_VIRTUALENGINE_SET_PARAMS veParams)
3100 {
3101 MOS_OS_FUNCTION_ENTER;
3102
3103 MOS_OS_CHK_NULL_RETURN(streamState);
3104 MOS_OS_CHK_NULL_RETURN(streamState->virtualEngineInterface);
3105
3106 return streamState->virtualEngineInterface->SetHintParams(veParams);
3107 }
3108
GetVeHintParams(MOS_STREAM_HANDLE streamState,bool scalableMode,PMOS_VIRTUALENGINE_HINT_PARAMS * hintParams)3109 MOS_STATUS MosInterface::GetVeHintParams(
3110 MOS_STREAM_HANDLE streamState,
3111 bool scalableMode,
3112 PMOS_VIRTUALENGINE_HINT_PARAMS* hintParams)
3113 {
3114 MOS_OS_CHK_NULL_RETURN(streamState);
3115 MOS_OS_CHK_NULL_RETURN(streamState->virtualEngineInterface);
3116 MOS_OS_CHK_NULL_RETURN(hintParams);
3117
3118 return streamState->virtualEngineInterface->GetHintParams(scalableMode, hintParams);
3119 }
3120
SetVeSubmissionType(MOS_STREAM_HANDLE streamState,COMMAND_BUFFER_HANDLE cmdBuf,MOS_SUBMISSION_TYPE type)3121 MOS_STATUS MosInterface::SetVeSubmissionType(
3122 MOS_STREAM_HANDLE streamState,
3123 COMMAND_BUFFER_HANDLE cmdBuf,
3124 MOS_SUBMISSION_TYPE type)
3125 {
3126 MOS_OS_CHK_NULL_RETURN(cmdBuf);
3127 MOS_OS_CHK_NULL_RETURN(streamState);
3128 MOS_OS_CHK_NULL_RETURN(streamState->virtualEngineInterface);
3129
3130 return streamState->virtualEngineInterface->SetSubmissionType(cmdBuf, type);
3131 }
3132
3133 #if _DEBUG || _RELEASE_INTERNAL
3134
GetVeEngineCount(MOS_STREAM_HANDLE streamState)3135 uint8_t MosInterface::GetVeEngineCount(
3136 MOS_STREAM_HANDLE streamState)
3137 {
3138 return streamState && streamState->virtualEngineInterface ?
3139 streamState->virtualEngineInterface->GetEngineCount() : 0;
3140 }
3141
GetEngineLogicId(MOS_STREAM_HANDLE streamState,uint32_t instanceIdx)3142 uint8_t MosInterface::GetEngineLogicId(
3143 MOS_STREAM_HANDLE streamState,
3144 uint32_t instanceIdx)
3145 {
3146 return streamState && streamState->virtualEngineInterface ?
3147 streamState->virtualEngineInterface->GetEngineLogicId(instanceIdx) : 0;
3148 }
3149
SetGpuVirtualAddress(PMOS_RESOURCE pResource,uint64_t address)3150 MOS_STATUS MosInterface::SetGpuVirtualAddress(
3151 PMOS_RESOURCE pResource,
3152 uint64_t address)
3153 {
3154 return MOS_STATUS_SUCCESS;
3155 }
3156
3157 #endif // _DEBUG || _RELEASE_INTERNAL
ComposeCommandBufferHeader(MOS_STREAM_HANDLE streamState,COMMAND_BUFFER_HANDLE cmdBuffer)3158 MOS_STATUS MosInterface::ComposeCommandBufferHeader(
3159 MOS_STREAM_HANDLE streamState,
3160 COMMAND_BUFFER_HANDLE cmdBuffer)
3161 {
3162 MOS_OS_FUNCTION_ENTER;
3163
3164 // No Command buffer header to compose
3165
3166 return MOS_STATUS_SUCCESS;
3167 }
3168
MosLoadLibrary(MOS_STREAM_HANDLE streamState,PCCHAR pFileName,PHMODULE ppvModule)3169 MOS_STATUS MosInterface::MosLoadLibrary(
3170 MOS_STREAM_HANDLE streamState,
3171 PCCHAR pFileName,
3172 PHMODULE ppvModule)
3173 {
3174 MOS_OS_FUNCTION_ENTER;
3175
3176 MOS_UNUSED(streamState);
3177 MOS_OS_ASSERT(pFileName);
3178 return MosUtilities::MosLoadLibrary(pFileName, ppvModule);
3179 }
3180
MosFreeLibrary(HMODULE hLibModule)3181 MOS_STATUS MosInterface::MosFreeLibrary(HMODULE hLibModule)
3182 {
3183 MOS_OS_ASSERT(hLibModule);
3184
3185 uint32_t ret = MosUtilities::MosFreeLibrary(hLibModule);
3186
3187 return (ret == true) ? MOS_STATUS_SUCCESS : MOS_STATUS_UNKNOWN;
3188 }
3189
GetGpuContext(MOS_STREAM_HANDLE streamState,GPU_CONTEXT_HANDLE handle)3190 GpuContextSpecificNext *MosInterface::GetGpuContext(MOS_STREAM_HANDLE streamState, GPU_CONTEXT_HANDLE handle)
3191 {
3192 MOS_OS_FUNCTION_ENTER;
3193
3194 if (streamState && streamState->osDeviceContext)
3195 {
3196 auto osDeviceContext = streamState->osDeviceContext;
3197
3198 auto gpuContextMgr = osDeviceContext->GetGpuContextMgr();
3199 if (gpuContextMgr)
3200 {
3201 GpuContextNext *gpuCtx = gpuContextMgr->GetGpuContext(handle);
3202
3203 return static_cast<GpuContextSpecificNext *>(gpuCtx);
3204 }
3205 }
3206
3207 MOS_OS_ASSERTMESSAGE("GetGpuContext failed!");
3208 return nullptr;
3209 }
3210
SetPerfTag(MOS_STREAM_HANDLE streamState,uint32_t perfTag)3211 void MosInterface::SetPerfTag(MOS_STREAM_HANDLE streamState, uint32_t perfTag)
3212 {
3213 MOS_OS_FUNCTION_ENTER;
3214
3215 uint32_t componentTag;
3216
3217 MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState);
3218 MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState->perStreamParameters);
3219
3220 auto osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
3221 PERF_DATA *perfData = osParameters->pPerfData;
3222 MOS_OS_CHK_NULL_NO_STATUS_RETURN(perfData);
3223
3224 switch (streamState->component)
3225 {
3226 case COMPONENT_VPreP:
3227 case COMPONENT_VPCommon:
3228 componentTag = PERFTAG_VPREP;
3229 break;
3230
3231 case COMPONENT_LibVA:
3232 componentTag = PERFTAG_LIBVA;
3233 break;
3234
3235 case COMPONENT_CM:
3236 componentTag = PERFTAG_CM;
3237 break;
3238
3239 case COMPONENT_Decode:
3240 componentTag = PERFTAG_DECODE;
3241 break;
3242
3243 case COMPONENT_Encode:
3244 componentTag = PERFTAG_ENCODE;
3245 break;
3246
3247 case COMPONENT_MCPY:
3248 componentTag = PERFTAG_VPREP;
3249 break;
3250
3251 default:
3252 componentTag = 0xF000 & perfData->dmaBufID;
3253 break;
3254 }
3255
3256 perfData->dmaBufID = componentTag | (perfTag & 0x0fff);
3257
3258 return;
3259 }
3260
IsPerfTagSet(MOS_STREAM_HANDLE streamState)3261 int32_t MosInterface::IsPerfTagSet(MOS_STREAM_HANDLE streamState)
3262 {
3263 uint32_t componentTag = 0;
3264 int32_t ret = false;
3265
3266 MOS_OS_FUNCTION_ENTER;
3267
3268 if (streamState == nullptr ||
3269 streamState->perStreamParameters == nullptr)
3270 {
3271 MOS_OS_ASSERTMESSAGE("streamState or perStreamParameters invalid nullptr");
3272 return false;
3273 }
3274
3275 auto osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
3276
3277 PERF_DATA *perfData = osParameters->pPerfData;
3278 if (perfData == nullptr)
3279 {
3280 MOS_OS_ASSERTMESSAGE("perfData invalid nullptr");
3281 return false;
3282 }
3283
3284 componentTag = 0xF000 & perfData->dmaBufID;
3285
3286 switch (componentTag)
3287 {
3288 case PERFTAG_ENCODE:
3289 case PERFTAG_DECODE:
3290 ret = true;
3291 break;
3292
3293 default:
3294 ret = false;
3295 break;
3296 }
3297
3298 return ret;
3299 }
3300
IncPerfFrameID(MOS_STREAM_HANDLE streamState)3301 void MosInterface::IncPerfFrameID(MOS_STREAM_HANDLE streamState)
3302 {
3303 MOS_OS_FUNCTION_ENTER;
3304
3305 MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState);
3306 MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState->perStreamParameters);
3307
3308 auto osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
3309
3310 MOS_OS_CHK_NULL_NO_STATUS_RETURN(osParameters->pPerfData);
3311
3312 osParameters->pPerfData->frameID++;
3313
3314 return;
3315 }
3316
GetPerfTag(MOS_STREAM_HANDLE streamState)3317 uint32_t MosInterface::GetPerfTag(MOS_STREAM_HANDLE streamState)
3318 {
3319 uint32_t perfTag;
3320
3321 MOS_OS_FUNCTION_ENTER;
3322
3323 if (streamState == nullptr ||
3324 streamState->perStreamParameters == nullptr)
3325 {
3326 MOS_OS_ASSERTMESSAGE("streamState or perStreamParameters invalid nullptr");
3327 return 0;
3328 }
3329
3330 auto osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
3331
3332 perfTag = *(uint32_t *)(osParameters->pPerfData);
3333 return perfTag;
3334 }
3335
SetPerfHybridKernelID(MOS_STREAM_HANDLE streamState,uint32_t kernelID)3336 void MosInterface::SetPerfHybridKernelID(
3337 MOS_STREAM_HANDLE streamState,
3338 uint32_t kernelID)
3339 {
3340 MOS_OS_FUNCTION_ENTER;
3341
3342 MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState);
3343 MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState->perStreamParameters);
3344
3345 auto osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
3346 PERF_DATA *perfData = osParameters->pPerfData;
3347 MOS_OS_CHK_NULL_NO_STATUS_RETURN(perfData);
3348
3349 perfData->dmaBufID = (perfData->dmaBufID & 0xF0FF) | ((kernelID << 8) & 0x0F00);
3350
3351 return;
3352 }
3353
ResetPerfBufferID(MOS_STREAM_HANDLE streamState)3354 void MosInterface::ResetPerfBufferID(
3355 MOS_STREAM_HANDLE streamState)
3356 {
3357 MOS_OS_FUNCTION_ENTER;
3358
3359 MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState);
3360 MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState->perStreamParameters);
3361
3362 auto osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
3363
3364 MOS_OS_CHK_NULL_NO_STATUS_RETURN(osParameters->pPerfData);
3365
3366 osParameters->pPerfData->bufferID = 0;
3367
3368 return;
3369 }
3370
IncPerfBufferID(MOS_STREAM_HANDLE streamState)3371 void MosInterface::IncPerfBufferID(
3372 MOS_STREAM_HANDLE streamState)
3373 {
3374 MOS_OS_FUNCTION_ENTER;
3375
3376 MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState);
3377 MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState->perStreamParameters);
3378
3379 auto osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
3380
3381 MOS_OS_CHK_NULL_NO_STATUS_RETURN(osParameters->pPerfData);
3382
3383 osParameters->pPerfData->bufferID++;
3384
3385 return;
3386 }
3387
IsGPUHung(MOS_STREAM_HANDLE streamState)3388 int32_t MosInterface::IsGPUHung(
3389 MOS_STREAM_HANDLE streamState)
3390 {
3391 uint32_t resetCount = 0;
3392 uint32_t activeBatch = 0;
3393 uint32_t pendingBatch = 0;
3394 int32_t result = false;
3395 int32_t ret = 0;
3396 PMOS_CONTEXT osParameters = nullptr;
3397
3398 MOS_OS_FUNCTION_ENTER;
3399
3400 if (!streamState || !streamState->perStreamParameters)
3401 {
3402 MOS_OS_ASSERTMESSAGE("invalid streamstate");
3403 return false;
3404 }
3405
3406 osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
3407
3408 MOS_LINUX_CONTEXT *intel_i915_ctx = osParameters->intel_context;
3409 auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
3410 if(gpuContext != nullptr && gpuContext->GetI915Context(0) != nullptr)
3411 {
3412 intel_i915_ctx = gpuContext->GetI915Context(0);
3413 }
3414
3415 ret = mos_get_reset_stats(intel_i915_ctx, &resetCount, &activeBatch, &pendingBatch);
3416 if (ret)
3417 {
3418 MOS_OS_NORMALMESSAGE("mos_get_reset_stats return error(%d)\n", ret);
3419 return false;
3420 }
3421
3422 //Chip reset will count this value, but maybe caused by ctx in other process.
3423 //In this case, reset has no impact on current process
3424 if (resetCount != streamState->gpuResetCount)
3425 {
3426 streamState->gpuResetCount = resetCount;
3427 }
3428
3429 //Thses two values are ctx specific, it must reset in current process if either changes
3430 if (activeBatch != streamState->gpuActiveBatch ||
3431 pendingBatch != streamState->gpuPendingBatch)
3432 {
3433 streamState->gpuActiveBatch = activeBatch;
3434 streamState->gpuPendingBatch = pendingBatch;
3435 result = true;
3436 }
3437 else
3438 {
3439 result = false;
3440 }
3441 return result;
3442 }
3443
IsSetMarkerEnabled(MOS_STREAM_HANDLE streamState)3444 bool MosInterface::IsSetMarkerEnabled(
3445 MOS_STREAM_HANDLE streamState)
3446 {
3447 return false;
3448 }
3449
GetMarkerResource(MOS_STREAM_HANDLE streamState)3450 PMOS_RESOURCE MosInterface::GetMarkerResource(
3451 MOS_STREAM_HANDLE streamState)
3452 {
3453 return nullptr;
3454 }
3455
MosResetResource(PMOS_RESOURCE resource)3456 void MosInterface::MosResetResource(PMOS_RESOURCE resource)
3457 {
3458 int32_t i = 0;
3459
3460 MOS_OS_FUNCTION_ENTER;
3461
3462 MOS_OS_CHK_NULL_NO_STATUS_RETURN(resource);
3463
3464 MOS_ZeroMemory(resource, sizeof(MOS_RESOURCE));
3465 resource->Format = Format_None;
3466 for (i = 0; i < MOS_GPU_CONTEXT_MAX; i++)
3467 {
3468 resource->iAllocationIndex[i] = MOS_INVALID_ALLOC_INDEX;
3469 }
3470 return;
3471 }
3472
MosResourceIsNull(PMOS_RESOURCE resource)3473 bool MosInterface::MosResourceIsNull(PMOS_RESOURCE resource)
3474 {
3475 if( nullptr == resource )
3476 {
3477 MOS_OS_NORMALMESSAGE("found pOsResource nullptr\n");
3478 return true;
3479 }
3480
3481 return ((resource->bo == nullptr)
3482 #if (_DEBUG || _RELEASE_INTERNAL)
3483 && ((resource->pData == nullptr) )
3484 #endif // (_DEBUG || _RELEASE_INTERNAL)
3485 );
3486 }
3487
GetGmmResourceInfo(PMOS_RESOURCE resource)3488 MOS_STATUS MosInterface::GetGmmResourceInfo(PMOS_RESOURCE resource)
3489 {
3490 return MOS_STATUS_SUCCESS;
3491 }
3492
GetPlaneSurfaceOffset(const MOS_PLANE_OFFSET & planeOffset)3493 int MosInterface::GetPlaneSurfaceOffset(const MOS_PLANE_OFFSET &planeOffset)
3494 {
3495 return planeOffset.iSurfaceOffset;
3496 }
3497
GetResourceArrayIndex(PMOS_RESOURCE resource)3498 uint32_t MosInterface::GetResourceArrayIndex(
3499 PMOS_RESOURCE resource)
3500 {
3501 return 0;
3502 }
3503
SetupCurrentCmdListAndPoolFromOsInterface(PMOS_INTERFACE pMosInterface,MOS_STREAM_HANDLE streamState)3504 MOS_STATUS MosInterface::SetupCurrentCmdListAndPoolFromOsInterface(
3505 PMOS_INTERFACE pMosInterface,
3506 MOS_STREAM_HANDLE streamState)
3507 {
3508 return MOS_STATUS_SUCCESS;
3509 }
3510
GetResourceHandle(MOS_STREAM_HANDLE streamState,PMOS_RESOURCE osResource)3511 uint64_t MosInterface::GetResourceHandle(MOS_STREAM_HANDLE streamState, PMOS_RESOURCE osResource)
3512 {
3513 if (osResource && osResource->bo)
3514 {
3515 return osResource->bo->handle;
3516 }
3517 else
3518 {
3519 return 0;
3520 }
3521 }
3522
MosGetUserSettingInstance(PMOS_CONTEXT osContext)3523 MediaUserSettingSharedPtr MosInterface::MosGetUserSettingInstance(
3524 PMOS_CONTEXT osContext)
3525 {
3526 if (osContext == nullptr)
3527 {
3528 MOS_OS_NORMALMESSAGE("Null usersetting PTR");
3529 return nullptr;
3530 }
3531
3532 return osContext->m_userSettingPtr;
3533 }
3534
MosGetUserSettingInstance(MOS_STREAM_HANDLE streamState)3535 MediaUserSettingSharedPtr MosInterface::MosGetUserSettingInstance(
3536 MOS_STREAM_HANDLE streamState)
3537 {
3538 PMOS_CONTEXT mosContext = nullptr;
3539 if (streamState == nullptr)
3540 {
3541 MOS_OS_NORMALMESSAGE("Null usersetting PTR");
3542 return nullptr;
3543 }
3544 mosContext = (PMOS_CONTEXT)streamState->perStreamParameters;
3545 return MosGetUserSettingInstance(mosContext);
3546 }
3547
3548 #if MOS_COMMAND_BUFFER_DUMP_SUPPORTED
DumpCommandBufferInit(MOS_STREAM_HANDLE streamState)3549 MOS_STATUS MosInterface::DumpCommandBufferInit(
3550 MOS_STREAM_HANDLE streamState)
3551 {
3552 char sFileName[MOS_MAX_HLT_FILENAME_LEN] = {0};
3553 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
3554 uint32_t value = 0;
3555 size_t nSizeFileNamePrefix = 0;
3556 MediaUserSettingSharedPtr userSettingPtr = MosInterface::MosGetUserSettingInstance(streamState);
3557
3558 MOS_OS_CHK_NULL_RETURN(streamState);
3559
3560 // Check if command buffer dump was enabled in user feature.
3561 ReadUserSetting(
3562 userSettingPtr,
3563 value,
3564 __MEDIA_USER_FEATURE_VALUE_DUMP_COMMAND_BUFFER_ENABLE,
3565 MediaUserSetting::Group::Device);
3566
3567 streamState->dumpCommandBuffer = (value != 0);
3568 streamState->dumpCommandBufferToFile = ((value & 1) != 0);
3569 streamState->dumpCommandBufferAsMessages = ((value & 2) != 0);
3570
3571 if (streamState->dumpCommandBufferToFile)
3572 {
3573 // Create output directory.
3574 eStatus = MosUtilDebug::MosLogFileNamePrefix(streamState->sDirName, userSettingPtr);
3575 if (eStatus != MOS_STATUS_SUCCESS)
3576 {
3577 MOS_OS_NORMALMESSAGE("Failed to create log file prefix. Status = %d", eStatus);
3578 return eStatus;
3579 }
3580
3581 memcpy(sFileName, streamState->sDirName, MOS_MAX_HLT_FILENAME_LEN);
3582 nSizeFileNamePrefix = strnlen(sFileName, sizeof(sFileName));
3583 MOS_SecureStringPrint(
3584 sFileName + nSizeFileNamePrefix,
3585 sizeof(sFileName) - nSizeFileNamePrefix,
3586 sizeof(sFileName) - nSizeFileNamePrefix,
3587 "%c%s",
3588 MOS_DIR_SEPERATOR,
3589 MOS_COMMAND_BUFFER_OUT_DIR);
3590
3591 eStatus = MosUtilities::MosCreateDirectory(sFileName);
3592 if (eStatus != MOS_STATUS_SUCCESS)
3593 {
3594 MOS_OS_NORMALMESSAGE("Failed to create output directory. Status = %d", eStatus);
3595 return eStatus;
3596 }
3597 }
3598
3599 return MOS_STATUS_SUCCESS;
3600 }
3601 #endif // MOS_COMMAND_BUFFER_DUMP_SUPPORTED
3602
3603 #if (_DEBUG || _RELEASE_INTERNAL)
3604
3605 uint32_t MosInterface::m_mosOsApiFailSimulateType = 0;
3606 uint32_t MosInterface::m_mosOsApiFailSimulateMode = 0;
3607 uint32_t MosInterface::m_mosOsApiFailSimulateFreq = 0;
3608 uint32_t MosInterface::m_mosOsApiFailSimulateHint = 0;
3609 uint32_t MosInterface::m_mosOsApiFailSimulateCounter = 0;
3610
MosInitOsApiFailSimulateFlag(MediaUserSettingSharedPtr userSettingPtr)3611 void MosInterface::MosInitOsApiFailSimulateFlag(MediaUserSettingSharedPtr userSettingPtr)
3612 {
3613 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3614 uint32_t value = 0;
3615
3616 //default off for simulate random fail
3617 m_mosOsApiFailSimulateType = OS_API_FAIL_TYPE_NONE;
3618 m_mosOsApiFailSimulateMode = OS_API_FAIL_SIMULATE_MODE_DEFAULT;
3619 m_mosOsApiFailSimulateFreq = 0;
3620 m_mosOsApiFailSimulateHint = 0;
3621 m_mosOsApiFailSimulateCounter = 0;
3622
3623 // Read Config : memory allocation failure simulate mode
3624 ReadUserSetting(
3625 userSettingPtr,
3626 value,
3627 __MEDIA_USER_FEATURE_VALUE_OS_API_FAIL_SIMULATE_TYPE,
3628 MediaUserSetting::Group::Device);
3629
3630 if (value & OS_API_FAIL_TYPE_MAX)
3631 {
3632 m_mosOsApiFailSimulateType = value;
3633 MOS_OS_NORMALMESSAGE("Init MosSimulateOsApiFailSimulateType as %d \n ", m_mosOsApiFailSimulateType);
3634 }
3635 else
3636 {
3637 m_mosOsApiFailSimulateType = OS_API_FAIL_TYPE_NONE;
3638 MOS_OS_NORMALMESSAGE("Invalid OS API Fail Simulate Type from config: %d \n ", value);
3639 }
3640
3641 // Read Config : memory allocation failure simulate mode
3642 value = 0;
3643 ReadUserSetting(
3644 userSettingPtr,
3645 value,
3646 __MEDIA_USER_FEATURE_VALUE_OS_API_FAIL_SIMULATE_MODE,
3647 MediaUserSetting::Group::Device);
3648 if ((value == OS_API_FAIL_SIMULATE_MODE_DEFAULT) ||
3649 (value == OS_API_FAIL_SIMULATE_MODE_RANDOM) ||
3650 (value == OS_API_FAIL_SIMULATE_MODE_TRAVERSE))
3651 {
3652 m_mosOsApiFailSimulateMode = value;
3653 MOS_OS_NORMALMESSAGE("Init MosSimulateOsApiFailSimulateMode as %d \n ", m_mosOsApiFailSimulateMode);
3654 }
3655 else
3656 {
3657 m_mosOsApiFailSimulateMode = OS_API_FAIL_SIMULATE_MODE_DEFAULT;
3658 MOS_OS_NORMALMESSAGE("Invalid OS API Fail Simulate Mode from config: %d \n ", value);
3659 }
3660
3661 // Read Config : memory allocation failure simulate frequence
3662 value = 0;
3663 ReadUserSetting(
3664 userSettingPtr,
3665 value,
3666 __MEDIA_USER_FEATURE_VALUE_OS_API_FAIL_SIMULATE_FREQ,
3667 MediaUserSetting::Group::Device);
3668 if ((value >= MIN_OS_API_FAIL_FREQ) &&
3669 (value <= MAX_OS_API_FAIL_FREQ))
3670 {
3671 m_mosOsApiFailSimulateFreq = value;
3672 MOS_OS_NORMALMESSAGE("Init m_MosSimulateRandomOsApiFailFreq as %d \n ", m_mosOsApiFailSimulateFreq);
3673
3674 if (m_mosOsApiFailSimulateMode == OS_API_FAIL_SIMULATE_MODE_RANDOM)
3675 {
3676 srand((unsigned int)time(nullptr));
3677 }
3678 }
3679 else
3680 {
3681 m_mosOsApiFailSimulateFreq = 0;
3682 MOS_OS_NORMALMESSAGE("Invalid OS API Fail Simulate Freq from config: %d \n ", value);
3683 }
3684
3685 // Read Config : memory allocation failure simulate counter
3686 value = 0;
3687 ReadUserSetting(
3688 userSettingPtr,
3689 value,
3690 __MEDIA_USER_FEATURE_VALUE_OS_API_FAIL_SIMULATE_HINT,
3691 MediaUserSetting::Group::Device);
3692 if (value <= m_mosOsApiFailSimulateFreq)
3693 {
3694 m_mosOsApiFailSimulateHint = value;
3695 MOS_OS_NORMALMESSAGE("Init m_MosOsApiFailSimulateHint as %d \n ", m_mosOsApiFailSimulateHint);
3696 }
3697 else
3698 {
3699 m_mosOsApiFailSimulateHint = m_mosOsApiFailSimulateFreq;
3700 MOS_OS_NORMALMESSAGE("Set m_mosOsApiFailSimulateHint as %d since INVALID CONFIG %d \n ", m_mosOsApiFailSimulateHint, value);
3701 }
3702 }
3703
MosDeinitOsApiFailSimulateFlag()3704 void MosInterface::MosDeinitOsApiFailSimulateFlag()
3705 {
3706 //default off for simulate fail
3707 m_mosOsApiFailSimulateType = OS_API_FAIL_TYPE_NONE;
3708 m_mosOsApiFailSimulateMode = OS_API_FAIL_SIMULATE_MODE_DEFAULT;
3709 m_mosOsApiFailSimulateFreq = 0;
3710 m_mosOsApiFailSimulateHint = 0;
3711 m_mosOsApiFailSimulateCounter = 0;
3712 }
3713
MosSimulateOsApiFail(OS_API_FAIL_TYPE type,const char * functionName,const char * filename,int32_t line)3714 bool MosInterface::MosSimulateOsApiFail(
3715 OS_API_FAIL_TYPE type,
3716 const char *functionName,
3717 const char *filename,
3718 int32_t line)
3719 {
3720 bool bSimulateOsApiFail = false;
3721
3722 if (!MosOsApiFailSimulationEnabled(type))
3723 {
3724 return false;
3725 }
3726
3727 if (m_mosOsApiFailSimulateMode == OS_API_FAIL_SIMULATE_MODE_RANDOM)
3728 {
3729 int32_t Rn = rand();
3730 m_mosOsApiFailSimulateCounter++;
3731 if (Rn % m_mosOsApiFailSimulateFreq == 1)
3732 {
3733 bSimulateOsApiFail = true;
3734 MOS_DEBUGMESSAGE(MOS_MESSAGE_LVL_CRITICAL, MOS_COMPONENT_OS, MOS_SUBCOMP_SELF,
3735 "Simulated OS API(Type %d) Fail (Rn=%d, SimulateAllocCounter=%d) for: functionName: %s, filename: %s, line: %d\n",
3736 m_mosOsApiFailSimulateType, Rn, m_mosOsApiFailSimulateCounter, functionName, filename, line);
3737 }
3738 else
3739 {
3740 bSimulateOsApiFail = false;
3741 }
3742 }
3743 else if (m_mosOsApiFailSimulateMode == OS_API_FAIL_SIMULATE_MODE_TRAVERSE)
3744 {
3745 if (m_mosOsApiFailSimulateCounter++ == m_mosOsApiFailSimulateHint)
3746 {
3747 MOS_DEBUGMESSAGE(MOS_MESSAGE_LVL_CRITICAL, MOS_COMPONENT_OS, MOS_SUBCOMP_SELF,
3748 "Simulated OS API(Type %d) Fail (hint=%d) for: functionName: %s, filename: %s, line: %d\n",
3749 m_mosOsApiFailSimulateType, m_mosOsApiFailSimulateHint, functionName, filename, line);
3750 bSimulateOsApiFail = true;
3751 }
3752 else
3753 {
3754 bSimulateOsApiFail = false;
3755 }
3756 }
3757 else
3758 {
3759 //MOS_OS_NORMALMESSAGE("Invalid m_mosOsApiFailSimulateMode: %d \n ", m_mosOsApiFailSimulateMode);
3760 bSimulateOsApiFail = false;
3761 }
3762
3763 return bSimulateOsApiFail;
3764 }
3765 #endif // #if (_DEBUG || _RELEASE_INTERNAL)
3766
IsAsyncDevice(MOS_STREAM_HANDLE streamState)3767 bool MosInterface::IsAsyncDevice(MOS_STREAM_HANDLE streamState)
3768 {
3769 return false;
3770 }
3771
GmmFmtToMosFmt(GMM_RESOURCE_FORMAT format)3772 MOS_FORMAT MosInterface::GmmFmtToMosFmt(
3773 GMM_RESOURCE_FORMAT format)
3774 {
3775 static const std::map<GMM_RESOURCE_FORMAT, MOS_FORMAT> gmm2MosFmtMap = {
3776 {GMM_FORMAT_B8G8R8X8_UNORM_TYPE, Format_X8R8G8B8},
3777 {GMM_FORMAT_R8G8B8A8_UNORM_TYPE, Format_A8B8G8R8},
3778 {GMM_FORMAT_B8G8R8A8_UNORM_TYPE, Format_A8R8G8B8},
3779 {GMM_FORMAT_B5G6R5_UNORM_TYPE, Format_R5G6B5},
3780 {GMM_FORMAT_R8G8B8_UNORM, Format_R8G8B8},
3781 {GMM_FORMAT_R8G8B8_UINT_TYPE, Format_R8G8B8},
3782 {GMM_FORMAT_R32_UINT_TYPE, Format_R32U},
3783 {GMM_FORMAT_R32_FLOAT_TYPE, Format_R32F},
3784 {GMM_FORMAT_MEDIA_Y8_UNORM, Format_Y8},
3785 {GMM_FORMAT_MEDIA_Y1_UNORM, Format_Y8},
3786 {GMM_FORMAT_MEDIA_Y16_UNORM, Format_Y16U},
3787 {GMM_FORMAT_MEDIA_Y16_SNORM, Format_Y16S},
3788 {GMM_FORMAT_YUY2_2x1, Format_YUY2},
3789 {GMM_FORMAT_YUY2, Format_YUY2},
3790 {GMM_FORMAT_P8, Format_P8},
3791 {GMM_FORMAT_R16_UNORM_TYPE, Format_R16UN},
3792 {GMM_FORMAT_A8_UNORM_TYPE, Format_A8},
3793 {GMM_FORMAT_GENERIC_8BIT, Format_L8},
3794 {GMM_FORMAT_L16_UNORM_TYPE, Format_L16},
3795 {GMM_FORMAT_GENERIC_16BIT_TYPE, Format_D16},
3796 {GMM_FORMAT_YVYU, Format_YVYU},
3797 {GMM_FORMAT_UYVY, Format_UYVY},
3798 {GMM_FORMAT_VYUY_2x1, Format_VYUY},
3799 {GMM_FORMAT_VYUY, Format_VYUY},
3800 {GMM_FORMAT_P016_TYPE, Format_P016},
3801 {GMM_FORMAT_P010_TYPE, Format_P010},
3802 {GMM_FORMAT_NV12_TYPE, Format_NV12},
3803 {GMM_FORMAT_NV11_TYPE, Format_NV11},
3804 {GMM_FORMAT_P208_TYPE, Format_P208},
3805 {GMM_FORMAT_IMC1_TYPE, Format_IMC1},
3806 {GMM_FORMAT_IMC2_TYPE, Format_IMC2},
3807 {GMM_FORMAT_IMC3_TYPE, Format_IMC3},
3808 {GMM_FORMAT_IMC4_TYPE, Format_IMC4},
3809 {GMM_FORMAT_I420_TYPE, Format_I420},
3810 {GMM_FORMAT_IYUV_TYPE, Format_IYUV},
3811 {GMM_FORMAT_YV12_TYPE, Format_YV12},
3812 {GMM_FORMAT_YVU9_TYPE, Format_YVU9},
3813 {GMM_FORMAT_R8_UNORM_TYPE, Format_R8UN},
3814 {GMM_FORMAT_R16_UINT_TYPE, Format_R16U},
3815 {GMM_FORMAT_R8G8_SNORM, Format_V8U8},
3816 {GMM_FORMAT_R8_UINT_TYPE, Format_R8U},
3817 {GMM_FORMAT_R32_SINT, Format_R32S},
3818 {GMM_FORMAT_R8G8_UNORM_TYPE, Format_R8G8UN},
3819 {GMM_FORMAT_R16_SINT_TYPE, Format_R16S},
3820 {GMM_FORMAT_R16G16B16A16_UNORM_TYPE, Format_A16B16G16R16},
3821 {GMM_FORMAT_R16G16B16A16_FLOAT_TYPE, Format_A16B16G16R16F},
3822 {GMM_FORMAT_R10G10B10A2_UNORM_TYPE, Format_R10G10B10A2},
3823 {GMM_FORMAT_B10G10R10A2_UNORM_TYPE, Format_B10G10R10A2},
3824 {GMM_FORMAT_MFX_JPEG_YUV422H_TYPE, Format_422H},
3825 {GMM_FORMAT_MFX_JPEG_YUV411_TYPE, Format_411P},
3826 {GMM_FORMAT_MFX_JPEG_YUV422V_TYPE, Format_422V},
3827 {GMM_FORMAT_MFX_JPEG_YUV444_TYPE, Format_444P},
3828 {GMM_FORMAT_BAYER_BGGR16, Format_IRW0},
3829 {GMM_FORMAT_BAYER_RGGB16, Format_IRW1},
3830 {GMM_FORMAT_BAYER_GRBG16, Format_IRW2},
3831 {GMM_FORMAT_BAYER_GBRG16, Format_IRW3},
3832 {GMM_FORMAT_R8G8B8A8_UINT_TYPE, Format_AYUV},
3833 {GMM_FORMAT_AYUV, Format_AYUV},
3834 {GMM_FORMAT_R16G16_UNORM_TYPE, Format_R16G16UN},
3835 {GMM_FORMAT_R16_FLOAT, Format_R16F},
3836 {GMM_FORMAT_Y416_TYPE, Format_Y416},
3837 {GMM_FORMAT_Y410_TYPE, Format_Y410},
3838 {GMM_FORMAT_Y210_TYPE, Format_Y210},
3839 {GMM_FORMAT_Y216_TYPE, Format_Y216},
3840 {GMM_FORMAT_MFX_JPEG_YUV411R_TYPE, Format_411R},
3841 {GMM_FORMAT_RGBP_TYPE, Format_RGBP},
3842 {GMM_FORMAT_BGRP_TYPE, Format_RGBP},
3843 {GMM_FORMAT_R24_UNORM_X8_TYPELESS, Format_D24S8UN},
3844 {GMM_FORMAT_R32_FLOAT_X8X24_TYPELESS, Format_D32S8X24_FLOAT},
3845 {GMM_FORMAT_R16G16_SINT_TYPE, Format_R16G16S},
3846 {GMM_FORMAT_R32G32B32A32_FLOAT, Format_R32G32B32A32F}};
3847
3848 auto iter = gmm2MosFmtMap.find(format);
3849 if (iter != gmm2MosFmtMap.end())
3850 {
3851 return iter->second;
3852 }
3853 return Format_Invalid;
3854 }
3855
MosFmtToGmmFmt(MOS_FORMAT format)3856 GMM_RESOURCE_FORMAT MosInterface::MosFmtToGmmFmt(MOS_FORMAT format)
3857 {
3858 static const std::map<MOS_FORMAT, GMM_RESOURCE_FORMAT> mos2GmmFmtMap = {
3859 {Format_Buffer, GMM_FORMAT_GENERIC_8BIT},
3860 {Format_Buffer_2D, GMM_FORMAT_GENERIC_8BIT},
3861 {Format_L8, GMM_FORMAT_GENERIC_8BIT},
3862 {Format_L16, GMM_FORMAT_L16_UNORM_TYPE},
3863 {Format_STMM, GMM_FORMAT_MEDIA_Y8_UNORM},
3864 {Format_AI44, GMM_FORMAT_GENERIC_8BIT},
3865 {Format_IA44, GMM_FORMAT_GENERIC_8BIT},
3866 {Format_R5G6B5, GMM_FORMAT_B5G6R5_UNORM_TYPE},
3867 {Format_R8G8B8, GMM_FORMAT_R8G8B8_UNORM},
3868 {Format_X8R8G8B8, GMM_FORMAT_B8G8R8X8_UNORM_TYPE},
3869 {Format_A8R8G8B8, GMM_FORMAT_B8G8R8A8_UNORM_TYPE},
3870 {Format_X8B8G8R8, GMM_FORMAT_R8G8B8X8_UNORM_TYPE},
3871 {Format_A8B8G8R8, GMM_FORMAT_R8G8B8A8_UNORM_TYPE},
3872 {Format_R32F, GMM_FORMAT_R32_FLOAT_TYPE},
3873 {Format_V8U8, GMM_FORMAT_GENERIC_16BIT}, // matching size as format
3874 {Format_YUY2, GMM_FORMAT_YUY2},
3875 {Format_UYVY, GMM_FORMAT_UYVY},
3876 {Format_P8, GMM_FORMAT_RENDER_8BIT_TYPE}, // matching size as format
3877 {Format_A8, GMM_FORMAT_A8_UNORM_TYPE},
3878 {Format_AYUV, GMM_FORMAT_AYUV_TYPE},
3879 {Format_NV12, GMM_FORMAT_NV12_TYPE},
3880 {Format_NV21, GMM_FORMAT_NV21_TYPE},
3881 {Format_YV12, GMM_FORMAT_YV12_TYPE},
3882 {Format_R32U, GMM_FORMAT_R32_UINT_TYPE},
3883 {Format_R32S, GMM_FORMAT_R32_SINT_TYPE},
3884 {Format_RAW, GMM_FORMAT_GENERIC_8BIT},
3885 {Format_444P, GMM_FORMAT_MFX_JPEG_YUV444_TYPE},
3886 {Format_422H, GMM_FORMAT_MFX_JPEG_YUV422H_TYPE},
3887 {Format_422V, GMM_FORMAT_MFX_JPEG_YUV422V_TYPE},
3888 {Format_IMC3, GMM_FORMAT_IMC3_TYPE},
3889 {Format_411P, GMM_FORMAT_MFX_JPEG_YUV411_TYPE},
3890 {Format_411R, GMM_FORMAT_MFX_JPEG_YUV411R_TYPE},
3891 {Format_RGBP, GMM_FORMAT_RGBP_TYPE},
3892 {Format_BGRP, GMM_FORMAT_BGRP_TYPE},
3893 {Format_R8U, GMM_FORMAT_R8_UINT_TYPE},
3894 {Format_R8UN, GMM_FORMAT_R8_UNORM},
3895 {Format_R16U, GMM_FORMAT_R16_UINT_TYPE},
3896 {Format_R16F, GMM_FORMAT_R16_FLOAT_TYPE},
3897 {Format_P010, GMM_FORMAT_P010_TYPE},
3898 {Format_P016, GMM_FORMAT_P016_TYPE},
3899 {Format_Y216, GMM_FORMAT_Y216_TYPE},
3900 {Format_Y416, GMM_FORMAT_Y416_TYPE},
3901 {Format_P208, GMM_FORMAT_P208_TYPE},
3902 {Format_A16B16G16R16, GMM_FORMAT_R16G16B16A16_UNORM_TYPE},
3903 {Format_Y210, GMM_FORMAT_Y210_TYPE},
3904 {Format_Y410, GMM_FORMAT_Y410_TYPE},
3905 {Format_R10G10B10A2, GMM_FORMAT_R10G10B10A2_UNORM_TYPE},
3906 {Format_B10G10R10A2, GMM_FORMAT_B10G10R10A2_UNORM_TYPE},
3907 {Format_A16B16G16R16F, GMM_FORMAT_R16G16B16A16_FLOAT},
3908 {Format_R32G32B32A32F, GMM_FORMAT_R32G32B32A32_FLOAT}
3909 };
3910
3911 auto iter = mos2GmmFmtMap.find(format);
3912 if (iter != mos2GmmFmtMap.end())
3913 {
3914 return iter->second;
3915 }
3916 return GMM_FORMAT_INVALID;
3917
3918 }
3919
MosFmtToOsFmt(MOS_FORMAT format)3920 uint32_t MosInterface::MosFmtToOsFmt(MOS_FORMAT format)
3921 {
3922 static const std::map<MOS_FORMAT, MOS_OS_FORMAT> mos2OsFmtMap = {
3923 {Format_A8R8G8B8, (MOS_OS_FORMAT)DDI_FORMAT_A8R8G8B8},
3924 {Format_X8R8G8B8, (MOS_OS_FORMAT)DDI_FORMAT_X8R8G8B8},
3925 {Format_A8B8G8R8, (MOS_OS_FORMAT)DDI_FORMAT_A8B8G8R8},
3926 {Format_R32U, (MOS_OS_FORMAT)DDI_FORMAT_R32F},
3927 {Format_R32F, (MOS_OS_FORMAT)DDI_FORMAT_R32F},
3928 {Format_R5G6B5, (MOS_OS_FORMAT)DDI_FORMAT_R5G6B5},
3929 {Format_YUY2, (MOS_OS_FORMAT)DDI_FORMAT_YUY2},
3930 {Format_P8, (MOS_OS_FORMAT)DDI_FORMAT_P8},
3931 {Format_A8P8, (MOS_OS_FORMAT)DDI_FORMAT_A8P8},
3932 {Format_A8, (MOS_OS_FORMAT)DDI_FORMAT_A8},
3933 {Format_L8, (MOS_OS_FORMAT)DDI_FORMAT_L8},
3934 {Format_L16, (MOS_OS_FORMAT)DDI_FORMAT_L16},
3935 {Format_A4L4, (MOS_OS_FORMAT)DDI_FORMAT_A4L4},
3936 {Format_A8L8, (MOS_OS_FORMAT)DDI_FORMAT_A8L8},
3937 {Format_V8U8, (MOS_OS_FORMAT)DDI_FORMAT_V8U8},
3938 {Format_YVYU, (MOS_OS_FORMAT)FOURCC_YVYU},
3939 {Format_UYVY, (MOS_OS_FORMAT)FOURCC_UYVY},
3940 {Format_VYUY, (MOS_OS_FORMAT)FOURCC_VYUY},
3941 {Format_AYUV, (MOS_OS_FORMAT)FOURCC_AYUV},
3942 {Format_NV12, (MOS_OS_FORMAT)FOURCC_NV12},
3943 {Format_NV21, (MOS_OS_FORMAT)FOURCC_NV21},
3944 {Format_NV11, (MOS_OS_FORMAT)FOURCC_NV11},
3945 {Format_P208, (MOS_OS_FORMAT)FOURCC_P208},
3946 {Format_IMC1, (MOS_OS_FORMAT)FOURCC_IMC1},
3947 {Format_IMC2, (MOS_OS_FORMAT)FOURCC_IMC2},
3948 {Format_IMC3, (MOS_OS_FORMAT)FOURCC_IMC3},
3949 {Format_IMC4, (MOS_OS_FORMAT)FOURCC_IMC4},
3950 {Format_I420, (MOS_OS_FORMAT)FOURCC_I420},
3951 {Format_IYUV, (MOS_OS_FORMAT)FOURCC_IYUV},
3952 {Format_YV12, (MOS_OS_FORMAT)FOURCC_YV12},
3953 {Format_YVU9, (MOS_OS_FORMAT)FOURCC_YVU9},
3954 {Format_AI44, (MOS_OS_FORMAT)FOURCC_AI44},
3955 {Format_IA44, (MOS_OS_FORMAT)FOURCC_IA44},
3956 {Format_400P, (MOS_OS_FORMAT)FOURCC_400P},
3957 {Format_411P, (MOS_OS_FORMAT)FOURCC_411P},
3958 {Format_411R, (MOS_OS_FORMAT)FOURCC_411R},
3959 {Format_422H, (MOS_OS_FORMAT)FOURCC_422H},
3960 {Format_422V, (MOS_OS_FORMAT)FOURCC_422V},
3961 {Format_444P, (MOS_OS_FORMAT)FOURCC_444P},
3962 {Format_RGBP, (MOS_OS_FORMAT)FOURCC_RGBP},
3963 {Format_BGRP, (MOS_OS_FORMAT)FOURCC_BGRP},
3964 {Format_STMM, (MOS_OS_FORMAT)DDI_FORMAT_P8},
3965 {Format_P010, (MOS_OS_FORMAT)FOURCC_P010},
3966 {Format_P016, (MOS_OS_FORMAT)FOURCC_P016},
3967 {Format_Y216, (MOS_OS_FORMAT)FOURCC_Y216},
3968 {Format_Y416, (MOS_OS_FORMAT)FOURCC_Y416},
3969 {Format_A16B16G16R16, (MOS_OS_FORMAT)DDI_FORMAT_A16B16G16R16},
3970 {Format_Y210, (MOS_OS_FORMAT)FOURCC_Y210},
3971 {Format_Y410, (MOS_OS_FORMAT)FOURCC_Y410},
3972 {Format_R32G32B32A32F, (MOS_OS_FORMAT)DDI_FORMAT_R32G32B32A32F}};
3973
3974 auto iter = mos2OsFmtMap.find(format);
3975 if (iter != mos2OsFmtMap.end())
3976 {
3977 return iter->second;
3978 }
3979 return (MOS_OS_FORMAT)DDI_FORMAT_UNKNOWN;
3980 }
3981
OsFmtToMosFmt(uint32_t format)3982 MOS_FORMAT MosInterface::OsFmtToMosFmt(uint32_t format)
3983 {
3984 static const std::map<MOS_OS_FORMAT, MOS_FORMAT> os2MosFmtMap = {
3985 {DDI_FORMAT_A8B8G8R8, Format_A8R8G8B8},
3986 {DDI_FORMAT_X8B8G8R8, Format_X8R8G8B8},
3987 {DDI_FORMAT_R32F, Format_R32F},
3988 {DDI_FORMAT_A8R8G8B8, Format_A8R8G8B8},
3989 {DDI_FORMAT_X8R8G8B8, Format_X8R8G8B8},
3990 {DDI_FORMAT_R5G6B5, Format_R5G6B5},
3991 {DDI_FORMAT_YUY2, Format_YUY2},
3992 {DDI_FORMAT_P8, Format_P8},
3993 {DDI_FORMAT_A8P8, Format_A8P8},
3994 {DDI_FORMAT_A8, Format_A8},
3995 {DDI_FORMAT_L8, Format_L8},
3996 {DDI_FORMAT_L16, Format_L16},
3997 {DDI_FORMAT_A4L4, Format_A4L4},
3998 {DDI_FORMAT_A8L8, Format_A8L8},
3999 {DDI_FORMAT_V8U8, Format_V8U8},
4000 {DDI_FORMAT_A16B16G16R16, Format_A16B16G16R16},
4001 {DDI_FORMAT_R32G32B32A32F, Format_R32G32B32A32F},
4002 {FOURCC_YVYU, Format_YVYU},
4003 {FOURCC_UYVY, Format_UYVY},
4004 {FOURCC_VYUY, Format_VYUY},
4005 {FOURCC_AYUV, Format_AYUV},
4006 {FOURCC_NV12, Format_NV12},
4007 {FOURCC_NV21, Format_NV21},
4008 {FOURCC_NV11, Format_NV11},
4009 {FOURCC_P208, Format_P208},
4010 {FOURCC_IMC1, Format_IMC1},
4011 {FOURCC_IMC2, Format_IMC2},
4012 {FOURCC_IMC3, Format_IMC3},
4013 {FOURCC_IMC4, Format_IMC4},
4014 {FOURCC_I420, Format_I420},
4015 {FOURCC_IYUV, Format_IYUV},
4016 {FOURCC_YV12, Format_YV12},
4017 {FOURCC_YVU9, Format_YVU9},
4018 {FOURCC_AI44, Format_AI44},
4019 {FOURCC_IA44, Format_IA44},
4020 {FOURCC_400P, Format_400P},
4021 {FOURCC_411P, Format_411P},
4022 {FOURCC_411R, Format_411R},
4023 {FOURCC_422H, Format_422H},
4024 {FOURCC_422V, Format_422V},
4025 {FOURCC_444P, Format_444P},
4026 {FOURCC_RGBP, Format_RGBP},
4027 {FOURCC_BGRP, Format_BGRP},
4028 {FOURCC_P010, Format_P010},
4029 {FOURCC_P016, Format_P016},
4030 {FOURCC_Y216, Format_Y216},
4031 {FOURCC_Y416, Format_Y416},
4032 {FOURCC_Y210, Format_Y210},
4033 {FOURCC_Y410, Format_Y410}
4034 };
4035
4036 auto iter = os2MosFmtMap.find(format);
4037 if (iter != os2MosFmtMap.end())
4038 {
4039 return iter->second;
4040 }
4041 return Format_Invalid;
4042 }
4043
IsCompressibelSurfaceSupported(MEDIA_FEATURE_TABLE * skuTable)4044 bool MosInterface::IsCompressibelSurfaceSupported(MEDIA_FEATURE_TABLE *skuTable)
4045 {
4046 if(skuTable)
4047 {
4048 return MEDIA_IS_SKU(skuTable, FtrCompressibleSurfaceDefault);
4049 }
4050 return true;
4051 }
4052
IsMismatchOrderProgrammingSupported()4053 bool MosInterface::IsMismatchOrderProgrammingSupported()
4054 {
4055 return false;
4056 }
4057
WaitForBBCompleteNotifyEvent(MOS_STREAM_HANDLE streamState,GPU_CONTEXT_HANDLE gpuContextHandle,uint32_t uiTimeOut)4058 MOS_STATUS MosInterface::WaitForBBCompleteNotifyEvent(
4059 MOS_STREAM_HANDLE streamState,
4060 GPU_CONTEXT_HANDLE gpuContextHandle,
4061 uint32_t uiTimeOut)
4062 {
4063 return MOS_STATUS_SUCCESS;
4064 }
4065
RegisterBBCompleteNotifyEvent(MOS_STREAM_HANDLE streamState,GPU_CONTEXT_HANDLE gpuContextHandle)4066 MOS_STATUS MosInterface::RegisterBBCompleteNotifyEvent(
4067 MOS_STREAM_HANDLE streamState,
4068 GPU_CONTEXT_HANDLE gpuContextHandle)
4069 {
4070 return MOS_STATUS_SUCCESS;
4071 }
4072
GetRtLogResourceInfo(PMOS_INTERFACE osInterface,PMOS_RESOURCE & osResource,uint32_t & size)4073 void MosInterface::GetRtLogResourceInfo(
4074 PMOS_INTERFACE osInterface,
4075 PMOS_RESOURCE &osResource,
4076 uint32_t &size)
4077 {
4078 osResource = nullptr;
4079 size = 0;
4080 if (osInterface->osStreamState && osInterface->osStreamState->osDeviceContext)
4081 {
4082 MosOcaRTLogMgr *ocaRTLogMgr = MosOcaRTLogMgr::GetInstance();
4083 MOS_OS_CHK_NULL_NO_STATUS_RETURN(ocaRTLogMgr);
4084 GpuContextSpecificNext *gpuContext = dynamic_cast<GpuContextSpecificNext*>(osInterface->osStreamState->osDeviceContext->GetGpuContextMgr()->GetGpuContext(osInterface->osStreamState->currentGpuContextHandle));
4085 if (gpuContext != nullptr)
4086 {
4087 osResource = gpuContext->GetOcaRTLogResource(osInterface->osStreamState->osDeviceContext->GetOcaRTLogResource());
4088 size = ocaRTLogMgr->GetRtlogHeapSize();
4089 }
4090 }
4091 }
4092
IsPooledResource(MOS_STREAM_HANDLE streamState,PMOS_RESOURCE osResource)4093 bool MosInterface::IsPooledResource(MOS_STREAM_HANDLE streamState, PMOS_RESOURCE osResource)
4094 {
4095 return false;
4096 }
4097
MapTileType(GMM_RESOURCE_FLAG flags,GMM_TILE_TYPE type)4098 MOS_TILE_TYPE MosInterface::MapTileType(GMM_RESOURCE_FLAG flags, GMM_TILE_TYPE type)
4099 {
4100 return MOS_TILE_INVALID;
4101 }
4102
SetMultiEngineEnabled(PMOS_INTERFACE pOsInterface,MOS_COMPONENT component,bool enabled)4103 MOS_STATUS MosInterface::SetMultiEngineEnabled(
4104 PMOS_INTERFACE pOsInterface,
4105 MOS_COMPONENT component,
4106 bool enabled)
4107 {
4108 return MOS_STATUS_SUCCESS;
4109 }
4110
GetMultiEngineStatus(PMOS_INTERFACE pOsInterface,PLATFORM * platform,MOS_COMPONENT component,bool & isMultiDevices,bool & isMultiEngine)4111 MOS_STATUS MosInterface::GetMultiEngineStatus(
4112 PMOS_INTERFACE pOsInterface,
4113 PLATFORM *platform,
4114 MOS_COMPONENT component,
4115 bool &isMultiDevices,
4116 bool &isMultiEngine)
4117 {
4118 return MOS_STATUS_SUCCESS;
4119 }
4120
4121 bool MosInterface::m_bTrinity = false;
SetIsTrinityEnabled(bool bTrinity)4122 void MosInterface::SetIsTrinityEnabled(bool bTrinity)
4123 {
4124 return;
4125 }