Google Git
Sign in
fuchsia / third_party / github.com / intel / media-driver / e34411258934cdb646fa1767dbab7d9e27dbe291 / . / media_driver / linux / common / os / mos_interface.cpp
blob: fcc0aec2027b84fb92e427e2784e5a292b86a59a [file] [log] [blame]
/*
* Copyright (c) 2009-2021, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
//!
//! \file mos_interface.cpp
//! \brief MOS interface implementation
//!
#include "mos_interface.h"
#include "mos_context_specific_next.h"
#include "mos_gpucontext_specific_next.h"
#include "mos_os_specific_next.h"
#include "media_libva_common.h"
#include "mos_auxtable_mgr.h"
#include "mos_os_virtualengine_singlepipe_specific_next.h"
#include "mos_os_virtualengine_scalability_specific_next.h"
#include "mos_graphicsresource_specific_next.h"
#include "mos_bufmgr_priv.h"
#if (_DEBUG || _RELEASE_INTERNAL)
#include <stdlib.h> //for simulate random OS API failure
#include <time.h> //for simulate random OS API failure
#endif
MOS_STATUS MosInterface::InitOsUtilities(DDI_DEVICE_CONTEXT ddiDeviceContext)
{
MOS_UNUSED(ddiDeviceContext);
MosUtilities::MosUtilitiesInit(nullptr);
// MOS_OS_FUNCTION_ENTER need mos utilities init
MOS_OS_FUNCTION_ENTER;
#if (_DEBUG || _RELEASE_INTERNAL)
//Init MOS OS API fail simulate flags
MosInitOsApiFailSimulateFlag(ddiDeviceContext);
#endif
//Read user feature key here for Per Utility Tool Enabling
#if _RELEASE_INTERNAL
if (!g_perfutility->bPerfUtilityKey)
{
MOS_USER_FEATURE_VALUE_DATA UserFeatureData;
MosUtilities::MosZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
MosUtilities::MosUserFeatureReadValueID(
NULL,
__MEDIA_USER_FEATURE_VALUE_PERF_UTILITY_TOOL_ENABLE_ID,
&UserFeatureData,
(MOS_CONTEXT_HANDLE) nullptr);
g_perfutility->dwPerfUtilityIsEnabled = UserFeatureData.i32Data;
char sFilePath[MOS_MAX_PERF_FILENAME_LEN + 1] = "";
MOS_USER_FEATURE_VALUE_DATA perfFilePath;
MOS_STATUS eStatus_Perf = MOS_STATUS_SUCCESS;
MosUtilities::MosZeroMemory(&perfFilePath, sizeof(perfFilePath));
perfFilePath.StringData.pStringData = sFilePath;
eStatus_Perf = MosUtilities::MosUserFeatureReadValueID(
nullptr,
__MEDIA_USER_FEATURE_VALUE_PERF_OUTPUT_DIRECTORY_ID,
&perfFilePath,
(MOS_CONTEXT_HANDLE) nullptr);
if (eStatus_Perf == MOS_STATUS_SUCCESS)
{
g_perfutility->setupFilePath(sFilePath);
}
else
{
g_perfutility->setupFilePath();
}
g_perfutility->bPerfUtilityKey = true;
}
#endif
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::CloseOsUtilities(PMOS_CONTEXT mosCtx)
{
MOS_OS_FUNCTION_ENTER;
// Close MOS utlities
MosUtilities::MosUtilitiesClose(nullptr);
#if (_DEBUG || _RELEASE_INTERNAL)
//reset MOS init OS API simulate flags
MosDeinitOsApiFailSimulateFlag();
#endif
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::CreateOsDeviceContext(DDI_DEVICE_CONTEXT ddiDeviceContext, MOS_DEVICE_HANDLE *deviceContext)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(deviceContext);
MOS_OS_CHK_NULL_RETURN(ddiDeviceContext);
*deviceContext = MOS_New(OsContextSpecificNext);
MOS_OS_CHK_NULL_RETURN(*deviceContext);
MOS_OS_CHK_STATUS_RETURN((*deviceContext)->Init((PMOS_CONTEXT)ddiDeviceContext));
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::DestroyOsDeviceContext(MOS_DEVICE_HANDLE deviceContext)
{
MOS_OS_FUNCTION_ENTER;
if (deviceContext)
{
deviceContext->CleanUp();
MOS_Delete(deviceContext);
deviceContext = nullptr;
}
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::CreateOsStreamState(
MOS_STREAM_HANDLE *streamState,
MOS_DEVICE_HANDLE deviceContext,
MOS_INTERFACE_HANDLE osInterface,
MOS_COMPONENT component,
EXTRA_PARAMS extraParams)
{
MOS_USER_FEATURE_VALUE_DATA userFeatureData = {};
MOS_STATUS eStatusUserFeature = MOS_STATUS_SUCCESS;
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(deviceContext);
*streamState = MOS_New(MosStreamState);
MOS_OS_CHK_NULL_RETURN(*streamState);
(*streamState)->osDeviceContext = deviceContext;
(*streamState)->component = component;
(*streamState)->currentGpuContextHandle = 0;
(*streamState)->simIsActive = false;
(*streamState)->mediaReset = false;
(*streamState)->usesPatchList = true;
(*streamState)->usesGfxAddress = !(*streamState)->usesPatchList;
MosUtilities::MosZeroMemory(&userFeatureData, sizeof(userFeatureData));
#if (_DEBUG || _RELEASE_INTERNAL)
MosUtilities::MosUserFeatureReadValueID(
nullptr,
__MEDIA_USER_FEATURE_VALUE_SIM_ENABLE_ID,
&userFeatureData,
(MOS_CONTEXT_HANDLE) nullptr);
(*streamState)->simIsActive = (int32_t)userFeatureData.i32Data;
// Null HW Driver
// 0: Disabled
MosUtilities::MosZeroMemory(&userFeatureData, sizeof(userFeatureData));
MosUtilities::MosUserFeatureReadValueID(
nullptr,
__MEDIA_USER_FEATURE_VALUE_NULL_HW_ACCELERATION_ENABLE_ID,
&userFeatureData,
(MOS_CONTEXT_HANDLE) nullptr);
(*streamState)->nullHwAccelerationEnable.Value = userFeatureData.u32Data;
#endif
// SupportVirtualEngine flag is set by Hals
(*streamState)->supportVirtualEngine = false;
(*streamState)->useHwSemaForResSyncInVe = false;
(*streamState)->virtualEngineInterface = nullptr;
(*streamState)->veEnable = false;
(*streamState)->phasedSubmission = true;
auto skuTable = GetSkuTable(*streamState);
MOS_OS_CHK_NULL_RETURN(skuTable);
if (MEDIA_IS_SKU(skuTable, FtrGucSubmission))
{
(*streamState)->bGucSubmission = true;
}
#if (_DEBUG || _RELEASE_INTERNAL)
// read the "Force VDBOX" user feature key
// 0: not force
MosUtilities::MosZeroMemory(&userFeatureData, sizeof(userFeatureData));
MosUtilities::MosUserFeatureReadValueID(
nullptr,
__MEDIA_USER_FEATURE_VALUE_FORCE_VDBOX_ID,
&userFeatureData,
(MOS_CONTEXT_HANDLE) nullptr);
(*streamState)->eForceVdbox = userFeatureData.u32Data;
//Read Scalable/Legacy Decode mode on Gen11+
//1:by default for scalable decode mode
//0:for legacy decode mode
MosUtilities::MosZeroMemory(&userFeatureData, sizeof(userFeatureData));
eStatusUserFeature = MosUtilities::MosUserFeatureReadValueID(
nullptr,
__MEDIA_USER_FEATURE_VALUE_ENABLE_HCP_SCALABILITY_DECODE_ID,
&userFeatureData,
(MOS_CONTEXT_HANDLE) nullptr);
(*streamState)->hcpDecScalabilityMode = userFeatureData.u32Data ? MOS_SCALABILITY_ENABLE_MODE_DEFAULT : MOS_SCALABILITY_ENABLE_MODE_FALSE;
if((*streamState)->hcpDecScalabilityMode
&& (eStatusUserFeature == MOS_STATUS_SUCCESS))
{
//user's value to enable scalability
(*streamState)->hcpDecScalabilityMode = MOS_SCALABILITY_ENABLE_MODE_USER_FORCE;
}
(*streamState)->frameSplit = false;
MosUtilities::MosZeroMemory(&userFeatureData, sizeof(userFeatureData));
MosUtilities::MosUserFeatureReadValueID(
NULL,
__MEDIA_USER_FEATURE_VALUE_ENABLE_LINUX_FRAME_SPLIT_ID,
&userFeatureData,
(MOS_CONTEXT_HANDLE) nullptr);
(*streamState)->frameSplit = (uint32_t)userFeatureData.i32Data;
MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
MOS_UserFeature_ReadValue_ID(
NULL,
__MEDIA_USER_FEATURE_VALUE_ENABLE_GUC_SUBMISSION_ID,
&userFeatureData,
nullptr);
(*streamState)->bGucSubmission = (*streamState)->bGucSubmission && ((uint32_t)userFeatureData.i32Data);
//KMD Virtual Engine DebugOverride
// 0: not Override
MosUtilities::MosZeroMemory(&userFeatureData, sizeof(userFeatureData));
MosUtilities::MosUserFeatureReadValueID(
nullptr,
__MEDIA_USER_FEATURE_VALUE_ENABLE_VE_DEBUG_OVERRIDE_ID,
&userFeatureData,
(MOS_CONTEXT_HANDLE) nullptr);
(*streamState)->enableDbgOvrdInVirtualEngine = userFeatureData.u32Data ? true : false;
#endif
if (component == COMPONENT_VPCommon ||
component == COMPONENT_VPreP ||
component == COMPONENT_LibVA)
{
// UMD Vebox Virtual Engine Scalability Mode
// 0: disable. can set to 1 only when KMD VE is enabled.
MosUtilities::MosZeroMemory(&userFeatureData, sizeof(userFeatureData));
eStatusUserFeature = MosUtilities::MosUserFeatureReadValueID(
nullptr,
__MEDIA_USER_FEATURE_VALUE_ENABLE_VEBOX_SCALABILITY_MODE_ID,
&userFeatureData,
(MOS_CONTEXT_HANDLE) nullptr);
(*streamState)->veboxScalabilityMode = userFeatureData.u32Data ? MOS_SCALABILITY_ENABLE_MODE_DEFAULT : MOS_SCALABILITY_ENABLE_MODE_FALSE;
#if (_DEBUG || _RELEASE_INTERNAL)
if((*streamState)->veboxScalabilityMode
&& (eStatusUserFeature == MOS_STATUS_SUCCESS))
{
//user's value to enable scalability
(*streamState)->veboxScalabilityMode = MOS_SCALABILITY_ENABLE_MODE_USER_FORCE;
(*streamState)->enableDbgOvrdInVirtualEngine = true;
if ((*streamState)->eForceVebox == MOS_FORCE_VEBOX_NONE)
{
(*streamState)->eForceVebox = MOS_FORCE_VEBOX_1_2;
}
}
else if ((!(*streamState)->veboxScalabilityMode)
&& (eStatusUserFeature == MOS_STATUS_SUCCESS))
{
(*streamState)->enableDbgOvrdInVirtualEngine = true;
(*streamState)->eForceVebox = MOS_FORCE_VEBOX_NONE;
}
// read the "Force VEBOX" user feature key
// 0: not force
MosUtilities::MosZeroMemory(&userFeatureData, sizeof(userFeatureData));
MosUtilities::MosUserFeatureReadValueID(
nullptr,
__MEDIA_USER_FEATURE_VALUE_FORCE_VEBOX_ID,
&userFeatureData,
(MOS_CONTEXT_HANDLE) nullptr);
(*streamState)->eForceVebox = (MOS_FORCE_VEBOX)userFeatureData.u32Data;
#endif
}
MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData = __NULL_USER_FEATURE_VALUE_WRITE_DATA__;
// Report if pre-si environment is in use
userFeatureWriteData.Value.i32Data = (*streamState)->simIsActive;
userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_SIM_IN_USE_ID;
MosUtilities::MosUserFeatureWriteValuesID(
nullptr,
&userFeatureWriteData,
1,
(MOS_CONTEXT_HANDLE)nullptr);
#if MOS_COMMAND_BUFFER_DUMP_SUPPORTED
DumpCommandBufferInit(*streamState);
#endif // MOS_COMMAND_BUFFER_DUMP_SUPPORTED
MOS_OS_CHK_STATUS_RETURN(MosInterface::InitStreamParameters(*streamState, extraParams));
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::DestroyOsStreamState(
MOS_STREAM_HANDLE streamState)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_Delete(streamState);
streamState = nullptr;
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::InitStreamParameters(
MOS_STREAM_HANDLE streamState,
EXTRA_PARAMS extraParams)
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
PMOS_CONTEXT context = nullptr;
uint32_t resetCount = 0;
int32_t ret = 0;
MOS_BUFMGR *bufMgr = nullptr;
int32_t fd = -1;
OsContextSpecificNext *osDeviceContext = nullptr;
MOS_USER_FEATURE_VALUE_DATA userFeatureData = {};
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(streamState->osDeviceContext);
MOS_OS_CHK_NULL_RETURN(extraParams);
osDeviceContext = (OsContextSpecificNext *)streamState->osDeviceContext;
fd = osDeviceContext->GetFd();
if (0 >= fd)
{
MOS_OS_ASSERTMESSAGE("Invalid fd");
return MOS_STATUS_INVALID_HANDLE;
}
bufMgr = osDeviceContext->GetBufMgr();
MOS_OS_CHK_NULL_RETURN(bufMgr);
context = (PMOS_OS_CONTEXT)MOS_AllocAndZeroMemory(sizeof(MOS_OS_CONTEXT));
MOS_OS_CHK_NULL_RETURN(context);
context->m_apoMosEnabled = true;
context->m_osDeviceContext = streamState->osDeviceContext;
context->bSimIsActive = streamState->simIsActive;
if (GMM_SUCCESS != OpenGmm(&context->GmmFuncs))
{
MOS_FreeMemAndSetNull(context);
MOS_OS_ASSERTMESSAGE("Unable to open gmm");
return MOS_STATUS_INVALID_PARAMETER;
}
streamState->perStreamParameters = (OS_PER_STREAM_PARAMETERS)context;
context->pGmmClientContext = context->GmmFuncs.pfnCreateClientContext((GMM_CLIENT)GMM_LIBVA_LINUX);
context->bufmgr = bufMgr;
context->m_gpuContextMgr = osDeviceContext->GetGpuContextMgr();
context->m_cmdBufMgr = osDeviceContext->GetCmdBufferMgr();
context->fd = fd;
context->pPerfData = ((PMOS_CONTEXT)extraParams)->pPerfData;
context->m_auxTableMgr = osDeviceContext->GetAuxTableMgr();
mos_bufmgr_gem_enable_reuse(bufMgr);
context->SkuTable = *osDeviceContext->GetSkuTable();
context->WaTable = *osDeviceContext->GetWaTable();
context->gtSystemInfo = *osDeviceContext->GetGtSysInfo();
context->platform = *osDeviceContext->GetPlatformInfo();
context->bUse64BitRelocs = true;
context->bUseSwSwizzling = context->bSimIsActive || MEDIA_IS_SKU(&context->SkuTable, FtrUseSwSwizzling);
context->bTileYFlag = MEDIA_IS_SKU(&context->SkuTable, FtrTileY);
if (MEDIA_IS_SKU(&context->SkuTable, FtrContextBasedScheduling))
{
MOS_TraceEventExt(EVENT_GPU_CONTEXT_CREATE, EVENT_TYPE_START,
&eStatus, sizeof(eStatus), nullptr, 0);
context->intel_context = mos_gem_context_create_ext(context->bufmgr, 0);
MOS_OS_CHK_NULL_RETURN(context->intel_context);
context->intel_context->vm = mos_gem_vm_create(context->bufmgr);
MOS_OS_CHK_NULL_RETURN(context->intel_context->vm);
MOS_TraceEventExt(EVENT_GPU_CONTEXT_CREATE, EVENT_TYPE_END,
&context->intel_context, sizeof(void *),
&eStatus, sizeof(eStatus));
}
else //use legacy context create ioctl for pre-gen11 platforms
{
MOS_OS_ASSERTMESSAGE("Do not support the legacy context creation.\n");
MOS_FreeMemAndSetNull(context->pPerfData);
MOS_FreeMemAndSetNull(context);
streamState->perStreamParameters = nullptr;
return MOS_STATUS_UNIMPLEMENTED;
}
context->intel_context->pOsContext = context;
ret = mos_get_reset_stats(context->intel_context, &resetCount, nullptr, nullptr);
if (ret)
{
MOS_OS_NORMALMESSAGE("mos_get_reset_stats return error(%d)\n", ret);
resetCount = 0;
}
streamState->ctxPriority = 0;
streamState->gpuResetCount = resetCount;
streamState->gpuActiveBatch = 0;
streamState->gpuPendingBatch = 0;
context->bIsAtomSOC = false;
context->bFreeContext = true;
#if !defined(ANDROID) && !defined(__Fuchsia__)
{
drm_i915_getparam_t gp;
int32_t ret = -1;
int32_t value = 0;
//KMD support VCS2?
gp.value = &value;
gp.param = I915_PARAM_HAS_BSD2;
ret = drmIoctl(context->fd, DRM_IOCTL_I915_GETPARAM, &gp);
if (ret == 0 && value != 0)
{
context->bKMDHasVCS2 = true;
}
else
{
context->bKMDHasVCS2 = false;
}
}
#else
//TODO(fxbug.dev/78281) - remove
fprintf(stderr, "%s:%d MosInterface::InitStreamParameters not implemented\n", __FILE__, __LINE__);
#endif
// read "Linux PerformanceTag Enable" user feature key
MosUtilities::MosUserFeatureReadValueID(
nullptr,
__MEDIA_USER_FEATURE_VALUE_LINUX_PERFORMANCETAG_ENABLE_ID,
&userFeatureData,
(MOS_CONTEXT_HANDLE)nullptr);
context->uEnablePerfTag = userFeatureData.u32Data;
return MOS_STATUS_SUCCESS;
}
uint32_t MosInterface::GetInterfaceVersion(MOS_DEVICE_HANDLE deviceContext)
{
MOS_OS_FUNCTION_ENTER;
// No interface version to get in Linux
return 0;
}
PLATFORM *MosInterface::GetPlatform(MOS_STREAM_HANDLE streamState)
{
MOS_OS_FUNCTION_ENTER;
if (streamState && streamState->osDeviceContext)
{
return streamState->osDeviceContext->GetPlatformInfo();
}
return nullptr;
}
MEDIA_FEATURE_TABLE *MosInterface::GetSkuTable(MOS_STREAM_HANDLE streamState)
{
MOS_OS_FUNCTION_ENTER;
if (streamState && streamState->osDeviceContext)
{
return streamState->osDeviceContext->GetSkuTable();
}
return nullptr;
}
MEDIA_WA_TABLE *MosInterface::GetWaTable(MOS_STREAM_HANDLE streamState)
{
MOS_OS_FUNCTION_ENTER;
if (streamState && streamState->osDeviceContext)
{
return streamState->osDeviceContext->GetWaTable();
}
return nullptr;
}
MEDIA_SYSTEM_INFO *MosInterface::GetGtSystemInfo(MOS_STREAM_HANDLE streamState)
{
MOS_OS_FUNCTION_ENTER;
if (streamState && streamState->osDeviceContext)
{
return streamState->osDeviceContext->GetGtSysInfo();
}
return nullptr;
}
MOS_STATUS MosInterface::GetMediaEngineInfo(MOS_STREAM_HANDLE streamState, MEDIA_ENGINE_INFO &info)
{
MOS_OS_FUNCTION_ENTER;
auto systemInfo = MosInterface::GetGtSystemInfo(streamState);
MOS_OS_CHK_NULL_RETURN(systemInfo);
MosUtilities::MosZeroMemory(&info, sizeof(info));
info.VDBoxInfo = systemInfo->VDBoxInfo;
info.VEBoxInfo = systemInfo->VEBoxInfo;
return MOS_STATUS_SUCCESS;
}
ADAPTER_INFO *MosInterface::GetAdapterInfo(MOS_STREAM_HANDLE streamState)
{
MOS_OS_FUNCTION_ENTER;
// No adapter Info in Linux
return nullptr;
}
MOS_STATUS MosInterface::CreateGpuContext(
MOS_STREAM_HANDLE streamState,
GpuContextCreateOption &createOption,
GPU_CONTEXT_HANDLE &gpuContextHandle)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(streamState->osDeviceContext);
auto osDeviceContext = streamState->osDeviceContext;
auto gpuContextMgr = osDeviceContext->GetGpuContextMgr();
MOS_OS_CHK_NULL_RETURN(gpuContextMgr);
auto cmdBufMgr = osDeviceContext->GetCmdBufferMgr();
MOS_OS_CHK_NULL_RETURN(cmdBufMgr);
auto osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
MOS_OS_CHK_NULL_RETURN(osParameters);
if (createOption.gpuNode == MOS_GPU_NODE_3D && createOption.SSEUValue != 0)
{
struct drm_i915_gem_context_param_sseu sseu;
MosUtilities::MosZeroMemory(&sseu, sizeof(sseu));
sseu.engine.engine_class = I915_ENGINE_CLASS_RENDER;
sseu.engine.engine_instance = 0;
if (mos_get_context_param_sseu(osParameters->intel_context, &sseu))
{
MOS_OS_ASSERTMESSAGE("Failed to get sseu configuration.");
return MOS_STATUS_UNKNOWN;
};
if (mos_hweight8(sseu.subslice_mask) > createOption.packed.SubSliceCount)
{
sseu.subslice_mask = mos_switch_off_n_bits(sseu.subslice_mask,
mos_hweight8(sseu.subslice_mask) - createOption.packed.SubSliceCount);
}
if (mos_set_context_param_sseu(osParameters->intel_context, sseu))
{
MOS_OS_ASSERTMESSAGE("Failed to set sseu configuration.");
return MOS_STATUS_UNKNOWN;
};
}
MOS_GPU_NODE gpuNode = MOS_GPU_NODE_3D;
gpuNode = static_cast<MOS_GPU_NODE>(createOption.gpuNode);
auto gpuContext = gpuContextMgr->CreateGpuContext(gpuNode, cmdBufMgr);
MOS_OS_CHK_NULL_RETURN(gpuContext);
auto gpuContextSpecific = static_cast<GpuContextSpecificNext *>(gpuContext);
MOS_OS_CHK_NULL_RETURN(gpuContextSpecific);
MOS_OS_CHK_STATUS_RETURN(gpuContextSpecific->Init(gpuContextMgr->GetOsContext(), streamState, &createOption));
gpuContextHandle = gpuContextSpecific->GetGpuContextHandle();
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::DestroyGpuContext(
MOS_STREAM_HANDLE streamState,
GPU_CONTEXT_HANDLE gpuContext)
{
MOS_OS_FUNCTION_ENTER;
MOS_STATUS eStatus;
eStatus = MOS_STATUS_SUCCESS;
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(streamState->osDeviceContext);
MOS_OS_ASSERT(gpuContext != MOS_GPU_CONTEXT_INVALID_HANDLE);
auto gpuContextMgr = streamState->osDeviceContext->GetGpuContextMgr();
MOS_OS_CHK_NULL_RETURN(gpuContextMgr);
auto gpuContextInstance = gpuContextMgr->GetGpuContext(gpuContext);
MOS_OS_CHK_NULL_RETURN(gpuContextInstance);
gpuContextMgr->DestroyGpuContext(gpuContextInstance);
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::SetGpuContext(
MOS_STREAM_HANDLE streamState,
GPU_CONTEXT_HANDLE gpuContext)
{
MOS_OS_FUNCTION_ENTER;
auto gpuContextMgr = streamState->osDeviceContext->GetGpuContextMgr();
MOS_OS_CHK_NULL_RETURN(gpuContextMgr);
auto gpuContextPtr = gpuContextMgr->GetGpuContext(gpuContext);
MOS_OS_CHK_NULL_RETURN(gpuContextPtr);
streamState->currentGpuContextHandle = gpuContext;
return MOS_STATUS_SUCCESS;
}
void *MosInterface::GetGpuContextbyHandle(
MOS_STREAM_HANDLE streamState,
GPU_CONTEXT_HANDLE gpuContextHandle)
{
if (!streamState || !streamState->osDeviceContext)
{
MOS_OS_ASSERTMESSAGE("Invalid nullptr");
return nullptr;
}
auto gpuContextMgr = streamState->osDeviceContext->GetGpuContextMgr();
if (!gpuContextMgr)
{
MOS_OS_ASSERTMESSAGE("Invalid nullptr");
return nullptr;
}
GpuContextNext *gpuContext = gpuContextMgr->GetGpuContext(gpuContextHandle);
if (!gpuContext)
{
MOS_OS_ASSERTMESSAGE("Invalid nullptr");
}
return (void *)gpuContext;
}
MOS_STATUS MosInterface::AddCommand(
COMMAND_BUFFER_HANDLE cmdBuffer,
const void *cmd,
uint32_t cmdSize)
{
MOS_OS_FUNCTION_ENTER;
uint32_t cmdSizeDwAligned = 0;
MOS_OS_CHK_NULL_RETURN(cmdBuffer);
MOS_OS_CHK_NULL_RETURN(cmd);
if (cmdSize == 0)
{
MOS_OS_ASSERTMESSAGE("Incorrect command size to add to command buffer.");
return MOS_STATUS_INVALID_PARAMETER;
}
cmdSizeDwAligned = MOS_ALIGN_CEIL(cmdSize, sizeof(uint32_t));
cmdBuffer->iOffset += cmdSizeDwAligned;
cmdBuffer->iRemaining -= cmdSizeDwAligned;
if (cmdBuffer->iRemaining < 0)
{
cmdBuffer->iOffset -= cmdSizeDwAligned;
cmdBuffer->iRemaining += cmdSizeDwAligned;
MOS_OS_ASSERTMESSAGE("Unable to add command: remaining space = %d, command size = %d.",
cmdBuffer->iRemaining,
cmdSizeDwAligned);
return MOS_STATUS_UNKNOWN;
}
MOS_OS_VERBOSEMESSAGE("The command was successfully added: remaining space = %d, buffer size = %d.",
cmdBuffer->iRemaining,
cmdBuffer->iOffset + cmdBuffer->iRemaining);
MosUtilities::MosSecureMemcpy(cmdBuffer->pCmdPtr, cmdSize, cmd, cmdSize);
cmdBuffer->pCmdPtr += (cmdSizeDwAligned / sizeof(uint32_t));
return MOS_STATUS_SUCCESS;
}
#if MOS_COMMAND_BUFFER_DUMP_SUPPORTED
MOS_STATUS MosInterface::DumpCommandBuffer(
MOS_STREAM_HANDLE streamState,
COMMAND_BUFFER_HANDLE cmdBuffer)
{
MOS_OS_FUNCTION_ENTER;
static uint32_t dwCommandBufferNumber = 0;
MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
char * pOutputBuffer = nullptr;
// Each hex value should have 9 chars.
uint32_t SIZE_OF_ONE_WORD = 9;
uint32_t dwBytesWritten = 0;
uint32_t dwNumberOfDwords = 0;
uint32_t dwSizeToAllocate = 0;
char sFileName[MOS_MAX_HLT_FILENAME_LEN] = {0};
// Maximum length of engine name is 6
char sEngName[6];
size_t nSizeFileNamePrefix = 0;
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(cmdBuffer);
// Set the name of the engine that is going to be used.
auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
MOS_OS_CHK_NULL_RETURN(gpuContext);
MOS_GPU_NODE gpuNode = gpuContext->GetContextNode();
switch (gpuNode)
{
case MOS_GPU_NODE_VIDEO:
case MOS_GPU_NODE_VIDEO2:
MosUtilities::MosSecureStrcpy(sEngName, sizeof(sEngName), MOS_COMMAND_BUFFER_VIDEO_ENGINE);
break;
case MOS_GPU_NODE_COMPUTE:
MosUtilities::MosSecureStrcpy(sEngName, sizeof(sEngName), MOS_COMMAND_BUFFER_RENDER_ENGINE);
break;
case MOS_GPU_NODE_VE:
MosUtilities::MosSecureStrcpy(sEngName, sizeof(sEngName), MOS_COMMAND_BUFFER_VEBOX_ENGINE);
break;
case MOS_GPU_NODE_3D:
MosUtilities::MosSecureStrcpy(sEngName, sizeof(sEngName), MOS_COMMAND_BUFFER_RENDER_ENGINE);
break;
default:
MOS_OS_ASSERTMESSAGE("Unsupported GPU context.");
return eStatus;
}
dwNumberOfDwords = cmdBuffer->iOffset / sizeof(uint32_t);
dwSizeToAllocate =
dwNumberOfDwords * (SIZE_OF_ONE_WORD + 1) // Add 1 byte for the space following each Dword.
+ 3 * SIZE_OF_ONE_WORD; // For engine and platform names.
// Alloc output buffer.
pOutputBuffer = (char *)MOS_AllocAndZeroMemory(dwSizeToAllocate);
MOS_OS_CHK_NULL_RETURN(pOutputBuffer);
dwBytesWritten = MosUtilities::MosSecureStringPrint(
pOutputBuffer,
SIZE_OF_ONE_WORD * 3,
SIZE_OF_ONE_WORD * 3,
"Eng=%s ",
sEngName);
if (streamState->dumpCommandBufferToFile)
{
MosUtilities::MosSecureMemcpy(sFileName, MOS_MAX_HLT_FILENAME_LEN, streamState->sDirName, MOS_MAX_HLT_FILENAME_LEN);
nSizeFileNamePrefix = strnlen(sFileName, sizeof(sFileName));
MosUtilities::MosSecureStringPrint(
sFileName + nSizeFileNamePrefix,
sizeof(sFileName) - nSizeFileNamePrefix,
sizeof(sFileName) - nSizeFileNamePrefix,
"%c%s%c%s_%d.txt",
MOS_DIR_SEPERATOR,
MOS_COMMAND_BUFFER_OUT_DIR,
MOS_DIR_SEPERATOR,
MOS_COMMAND_BUFFER_OUT_FILE,
dwCommandBufferNumber);
// Write the output buffer to file.
MOS_OS_CHK_STATUS_RETURN(MosUtilities::MosWriteFileFromPtr((const char *)sFileName, pOutputBuffer, dwBytesWritten));
}
if (streamState->dumpCommandBufferAsMessages)
{
MOS_OS_NORMALMESSAGE(pOutputBuffer);
}
MosUtilities::MosZeroMemory(pOutputBuffer, dwBytesWritten);
dwBytesWritten = 0;
// Fill in the output buffer with the command buffer dwords.
for (uint32_t dwIndex = 0; dwIndex < dwNumberOfDwords; dwIndex++)
{
dwBytesWritten += MosUtilities::MosSecureStringPrint(
pOutputBuffer + dwBytesWritten,
SIZE_OF_ONE_WORD + 1,
SIZE_OF_ONE_WORD + 1,
"%.8x ",
cmdBuffer->pCmdBase[dwIndex]);
if (dwBytesWritten % (SIZE_OF_ONE_WORD + 1) == 0)
{
if (streamState->dumpCommandBufferToFile)
{
MOS_OS_CHK_STATUS_RETURN(MosUtilities::MosAppendFileFromPtr((const char *)sFileName, pOutputBuffer, dwBytesWritten));
}
if (streamState->dumpCommandBufferAsMessages)
{
MOS_OS_NORMALMESSAGE(pOutputBuffer);
}
MosUtilities::MosZeroMemory(pOutputBuffer, dwBytesWritten);
dwBytesWritten = 0;
}
}
if (streamState->dumpCommandBufferToFile)
{
MOS_OS_CHK_STATUS_RETURN(MosUtilities::MosAppendFileFromPtr((const char *)sFileName, pOutputBuffer, dwBytesWritten));
}
if (streamState->dumpCommandBufferAsMessages)
{
MOS_OS_NORMALMESSAGE(pOutputBuffer);
}
dwCommandBufferNumber++;
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
#endif // MOS_COMMAND_BUFFER_DUMP_SUPPORTED
MOS_STATUS MosInterface::GetCommandBuffer(
MOS_STREAM_HANDLE streamState,
COMMAND_BUFFER_HANDLE &cmdBuffer,
uint32_t pipeIdx)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(streamState);
auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
MOS_OS_CHK_NULL_RETURN(gpuContext);
return (gpuContext->GetCommandBuffer(cmdBuffer, pipeIdx));
}
MOS_STATUS MosInterface::ReturnCommandBuffer(
MOS_STREAM_HANDLE streamState,
COMMAND_BUFFER_HANDLE cmdBuffer,
uint32_t pipeIdx)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(streamState);
auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
MOS_OS_CHK_NULL_RETURN(gpuContext);
(gpuContext->ReturnCommandBuffer(cmdBuffer, pipeIdx));
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::SubmitCommandBuffer(
MOS_STREAM_HANDLE streamState,
COMMAND_BUFFER_HANDLE cmdBuffer,
bool nullRendering)
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MOS_OS_CHK_NULL_RETURN(streamState);
auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
MOS_OS_CHK_NULL_RETURN(gpuContext);
gpuContext->UpdatePriority(streamState->ctxPriority);
return (gpuContext->SubmitCommandBuffer(streamState, cmdBuffer, nullRendering));
}
MOS_STATUS MosInterface::ResetCommandBuffer(
MOS_STREAM_HANDLE streamState,
COMMAND_BUFFER_HANDLE cmdBuffer)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(streamState);
auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
MOS_OS_CHK_NULL_RETURN(gpuContext);
// Reset the explicitly provided cmd buffer, or reset GPU context states
if (cmdBuffer)
{
MOS_OS_CHK_STATUS_RETURN(gpuContext->ResetCommandBuffer());
}
else
{
gpuContext->ResetGpuContextStatus();
}
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::VerifyCommandBufferSize(
MOS_STREAM_HANDLE streamState,
COMMAND_BUFFER_HANDLE cmdBuffer,
uint32_t requestedSize,
uint32_t pipeIdx)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(streamState);
auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
MOS_OS_CHK_NULL_RETURN(gpuContext);
return (gpuContext->VerifyCommandBufferSize(requestedSize));
}
MOS_STATUS MosInterface::ResizeCommandBufferAndPatchList(
MOS_STREAM_HANDLE streamState,
COMMAND_BUFFER_HANDLE cmdBuffer,
uint32_t requestedSize,
uint32_t requestedPatchListSize,
uint32_t pipeIdx)
{
MOS_OS_FUNCTION_ENTER;
auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
MOS_OS_CHK_NULL_RETURN(gpuContext);
return (gpuContext->ResizeCommandBufferAndPatchList(requestedSize, requestedPatchListSize, pipeIdx));
}
MOS_STATUS MosInterface::SetPatchEntry(
MOS_STREAM_HANDLE streamState,
PMOS_PATCH_ENTRY_PARAMS params)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(params);
MOS_OS_CHK_NULL_RETURN(streamState);
auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
MOS_OS_CHK_NULL_RETURN(gpuContext);
MOS_OS_CHK_STATUS_RETURN(gpuContext->SetPatchEntry(streamState, params));
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::GetIndirectState(
MOS_STREAM_HANDLE streamState,
uint8_t **indirectState,
uint32_t &offset,
uint32_t &size)
{
MOS_OS_FUNCTION_ENTER;
auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
MOS_OS_CHK_NULL_RETURN(gpuContext);
MOS_OS_CHK_STATUS_RETURN(gpuContext->GetIndirectState(offset, size));
if (indirectState)
{
MOS_OS_CHK_STATUS_RETURN(gpuContext->GetIndirectStatePointer(indirectState));
}
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::SetupIndirectState(
MOS_STREAM_HANDLE streamState,
uint32_t size)
{
MOS_OS_FUNCTION_ENTER;
auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
MOS_OS_CHK_NULL_RETURN(gpuContext);
MOS_OS_CHK_STATUS_RETURN(gpuContext->SetIndirectStateSize(size));
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::SetupAttributeVeBuffer(
MOS_STREAM_HANDLE streamState,
COMMAND_BUFFER_HANDLE cmdBuffer)
{
MOS_OS_FUNCTION_ENTER;
// no VE attribute buffer to setup
return MOS_STATUS_SUCCESS;
}
MOS_CMD_BUF_ATTRI_VE *MosInterface::GetAttributeVeBuffer(
COMMAND_BUFFER_HANDLE cmdBuffer)
{
MOS_OS_FUNCTION_ENTER;
// no VE attribute buffer to get
return nullptr;
}
static GMM_RESOURCE_USAGE_TYPE GmmResourceUsage[MOS_HW_RESOURCE_DEF_MAX] =
{
//
// CODEC USAGES
//
GMM_RESOURCE_USAGE_BEGIN_CODEC,
GMM_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC,
GMM_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC_PARTIALENCSURFACE,
GMM_RESOURCE_USAGE_POST_DEBLOCKING_CODEC,
GMM_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_ENCODE,
GMM_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_DECODE,
GMM_RESOURCE_USAGE_STREAMOUT_DATA_CODEC,
GMM_RESOURCE_USAGE_INTRA_ROWSTORE_SCRATCH_BUFFER_CODEC,
GMM_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC,
GMM_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC,
GMM_RESOURCE_USAGE_MACROBLOCK_STATUS_BUFFER_CODEC,
GMM_RESOURCE_USAGE_MFX_INDIRECT_BITSTREAM_OBJECT_DECODE,
GMM_RESOURCE_USAGE_MFX_INDIRECT_MV_OBJECT_CODEC,
GMM_RESOURCE_USAGE_MFD_INDIRECT_IT_COEF_OBJECT_DECODE,
GMM_RESOURCE_USAGE_MFC_INDIRECT_PAKBASE_OBJECT_CODEC,
GMM_RESOURCE_USAGE_BSDMPC_ROWSTORE_SCRATCH_BUFFER_CODEC,
GMM_RESOURCE_USAGE_MPR_ROWSTORE_SCRATCH_BUFFER_CODEC,
GMM_RESOURCE_USAGE_BITPLANE_READ_CODEC,
GMM_RESOURCE_USAGE_DIRECTMV_BUFFER_CODEC,
GMM_RESOURCE_USAGE_SURFACE_CURR_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_REF_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE_FF,
GMM_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE_DST,
GMM_RESOURCE_USAGE_SURFACE_ME_DISTORTION_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_BRC_ME_DISTORTION_ENCODE,
GMM_RESOURCE_USAGE_PAK_OBJECT_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_FLATNESS_CHECK_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_MBENC_CURBE_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_MAD_ENCODE,
GMM_RESOURCE_USAGE_VP8_BLOCK_MODE_COST_ENCODE,
GMM_RESOURCE_USAGE_VP8_MB_MODE_COST_ENCODE,
GMM_RESOURCE_USAGE_VP8_MBENC_OUTPUT_ENCODE,
GMM_RESOURCE_USAGE_VP8_HISTOGRAM_ENCODE,
GMM_RESOURCE_USAGE_VP8_L3_LLC_ENCODE,
GMM_RESOURCE_USAGE_MFX_STANDALONE_DEBLOCKING_CODEC,
GMM_RESOURCE_USAGE_HCP_MD_CODEC,
GMM_RESOURCE_USAGE_HCP_SAO_CODEC,
GMM_RESOURCE_USAGE_HCP_MV_CODEC,
GMM_RESOURCE_USAGE_HCP_STATUS_ERROR_CODEC,
GMM_RESOURCE_USAGE_HCP_LCU_ILDB_STREAMOUT_CODEC,
GMM_RESOURCE_USAGE_VP9_PROBABILITY_BUFFER_CODEC,
GMM_RESOURCE_USAGE_VP9_SEGMENT_ID_BUFFER_CODEC,
GMM_RESOURCE_USAGE_VP9_HVD_ROWSTORE_BUFFER_CODEC,
GMM_RESOURCE_USAGE_MBDISABLE_SKIPMAP_CODEC,
GMM_RESOURCE_USAGE_VDENC_ROW_STORE_BUFFER_CODEC,
GMM_RESOURCE_USAGE_VDENC_STREAMIN_CODEC,
GMM_RESOURCE_USAGE_SURFACE_MB_QP_CODEC,
GMM_RESOURCE_USAGE_MACROBLOCK_ILDB_STREAM_OUT_BUFFER_CODEC,
GMM_RESOURCE_USAGE_SSE_SRC_PIXEL_ROW_STORE_BUFFER_CODEC,
GMM_RESOURCE_USAGE_SLICE_STATE_STREAM_OUT_BUFFER_CODEC,
GMM_RESOURCE_USAGE_CABAC_SYNTAX_STREAM_OUT_BUFFER_CODEC,
GMM_RESOURCE_USAGE_PRED_COL_STORE_BUFFER_CODEC,
GMM_RESOURCE_USAGE_SURFACE_PAK_IMAGESTATE_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_MBENC_BRC_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_MB_BRC_CONST_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_BRC_MB_QP_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_BRC_ROI_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_SLICE_MAP_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_WP_DOWNSAMPLED_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_VDENC_IMAGESTATE_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_UNCACHED,
GMM_RESOURCE_USAGE_SURFACE_ELLC_ONLY,
GMM_RESOURCE_USAGE_SURFACE_ELLC_LLC_ONLY,
GMM_RESOURCE_USAGE_SURFACE_ELLC_LLC_L3,
GMM_RESOURCE_USAGE_SURFACE_BRC_HISTORY_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_SOFTWARE_SCOREBOARD_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_ME_MV_DATA_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_MV_DISTORTION_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_4XME_DISTORTION_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_INTRA_DISTORTION_ENCODE,
GMM_RESOURCE_USAGE_MB_STATS_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_PAK_STATS_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_PIC_STATE_READ_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_PIC_STATE_WRITE_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_COMBINED_ENC_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_BRC_CONSTANT_DATA_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_INTERMEDIATE_CU_RECORD_SURFACE_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_SCRATCH_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_LCU_LEVEL_DATA_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_ENC_HISTORY_INPUT_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_ENC_HISTORY_OUTPUT_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_DEBUG_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_ENC_CONSTANT_TABLE_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_ENC_CU_RECORD_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_ENC_MV_TEMPORAL_BUFFER_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_ENC_CU_PACKET_FOR_PAK_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_ENC_BCOMBINED1_ENCODE,
GMM_RESOURCE_USAGE_SURFACE_ENC_BCOMBINED2_ENCODE,
GMM_RESOURCE_USAGE_FRAME_STATS_STREAMOUT_DATA_CODEC,
GMM_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_TILE_LINE_BUFFER_CODEC,
GMM_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_TILE_COLUMN_BUFFER_CODEC,
GMM_RESOURCE_USAGE_HCP_MD_TILE_LINE_CODEC,
GMM_RESOURCE_USAGE_HCP_MD_TILE_COLUMN_CODEC,
GMM_RESOURCE_USAGE_HCP_SAO_TILE_LINE_CODEC,
GMM_RESOURCE_USAGE_HCP_SAO_TILE_COLUMN_CODEC,
GMM_RESOURCE_USAGE_VP9_PROBABILITY_COUNTER_BUFFER_CODEC,
GMM_RESOURCE_USAGE_HUC_VIRTUAL_ADDR_REGION_BUFFER_CODEC,
GMM_RESOURCE_USAGE_SIZE_STREAMOUT_CODEC,
GMM_RESOURCE_USAGE_COMPRESSED_HEADER_BUFFER_CODEC,
GMM_RESOURCE_USAGE_PROBABILITY_DELTA_BUFFER_CODEC,
GMM_RESOURCE_USAGE_TILE_RECORD_BUFFER_CODEC,
GMM_RESOURCE_USAGE_TILE_SIZE_STAS_BUFFER_CODEC,
GMM_RESOURCE_USAGE_END_CODEC,
//
// CM USAGES
//
CM_RESOURCE_USAGE_SurfaceState,
CM_RESOURCE_USAGE_StateHeap,
CM_RESOURCE_USAGE_NO_L3_SurfaceState,
CM_RESOURCE_USAGE_NO_LLC_ELLC_SurfaceState,
CM_RESOURCE_USAGE_NO_LLC_SurfaceState,
CM_RESOURCE_USAGE_NO_ELLC_SurfaceState,
CM_RESOURCE_USAGE_NO_LLC_L3_SurfaceState,
CM_RESOURCE_USAGE_NO_ELLC_L3_SurfaceState,
CM_RESOURCE_USAGE_NO_CACHE_SurfaceState,
CM_RESOURCE_USAGE_L1_Enabled_SurfaceState,
//
// MP USAGES
//
MP_RESOURCE_USAGE_BEGIN,
MP_RESOURCE_USAGE_DEFAULT,
MP_RESOURCE_USAGE_DEFAULT_FF,
MP_RESOURCE_USAGE_DEFAULT_RCS,
MP_RESOURCE_USAGE_SurfaceState,
MP_RESOURCE_USAGE_SurfaceState_FF,
MP_RESOURCE_USAGE_SurfaceState_RCS,
MP_RESOURCE_USAGE_AGE3_SurfaceState,
MP_RESOURCE_USAGE_EDRAM_SurfaceState,
MP_RESOURCE_USAGE_EDRAM_AGE3_SurfaceState,
MP_RESOURCE_USAGE_No_L3_SurfaceState,
MP_RESOURCE_USAGE_No_LLC_L3_SurfaceState,
MP_RESOURCE_USAGE_No_LLC_L3_AGE_SurfaceState,
MP_RESOURCE_USAGE_No_LLC_eLLC_L3_AGE_SurfaceState,
MP_RESOURCE_USAGE_PartialEnc_No_LLC_L3_AGE_SurfaceState,
MP_RESOURCE_USAGE_END,
// MHW - SFC
MHW_RESOURCE_USAGE_Sfc_CurrentOutputSurface, //!< SFC output surface
MHW_RESOURCE_USAGE_Sfc_CurrentOutputSurface_PartialEncSurface, //!< SFC output surface for partial secure surfaces
MHW_RESOURCE_USAGE_Sfc_AvsLineBufferSurface, //!< SFC AVS Line buffer Surface
MHW_RESOURCE_USAGE_Sfc_IefLineBufferSurface, //!< SFC IEF Line buffer Surface
// PAT Media Usages
GMM_RESOURCE_USAGE_MEDIA_BATCH_BUFFERS,
// DECODE
GMM_RESOURCE_USAGE_DECODE_INPUT_BITSTREAM,
GMM_RESOURCE_USAGE_DECODE_INPUT_REFERENCE,
GMM_RESOURCE_USAGE_DECODE_INTERNAL_READ,
GMM_RESOURCE_USAGE_DECODE_INTERNAL_WRITE,
GMM_RESOURCE_USAGE_DECODE_INTERNAL_READ_WRITE_CACHE,
GMM_RESOURCE_USAGE_DECODE_INTERNAL_READ_WRITE_NOCACHE,
GMM_RESOURCE_USAGE_DECODE_OUTPUT_PICTURE,
GMM_RESOURCE_USAGE_DECODE_OUTPUT_STATISTICS_WRITE,
GMM_RESOURCE_USAGE_DECODE_OUTPUT_STATISTICS_READ_WRITE,
// ENCODE
GMM_RESOURCE_USAGE_ENCODE_INPUT_RAW,
GMM_RESOURCE_USAGE_ENCODE_INPUT_RECON,
GMM_RESOURCE_USAGE_ENCODE_INTERNAL_READ,
GMM_RESOURCE_USAGE_ENCODE_INTERNAL_WRITE,
GMM_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE,
GMM_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_NOCACHE,
GMM_RESOURCE_USAGE_ENCODE_EXTERNAL_READ,
GMM_RESOURCE_USAGE_ENCODE_OUTPUT_PICTURE,
GMM_RESOURCE_USAGE_ENCODE_OUTPUT_BITSTREAM,
GMM_RESOURCE_USAGE_ENCODE_OUTPUT_STATISTICS_WRITE,
GMM_RESOURCE_USAGE_ENCODE_OUTPUT_STATISTICS_READ_WRITE,
// VP
GMM_RESOURCE_USAGE_VP_INPUT_PICTURE_FF,
GMM_RESOURCE_USAGE_VP_INPUT_REFERENCE_FF,
GMM_RESOURCE_USAGE_VP_INTERNAL_READ_FF,
GMM_RESOURCE_USAGE_VP_INTERNAL_WRITE_FF,
GMM_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_FF,
GMM_RESOURCE_USAGE_VP_OUTPUT_PICTURE_FF,
GMM_RESOURCE_USAGE_VP_INPUT_PICTURE_RENDER,
GMM_RESOURCE_USAGE_VP_INPUT_REFERENCE_RENDER,
GMM_RESOURCE_USAGE_VP_INTERNAL_READ_RENDER,
GMM_RESOURCE_USAGE_VP_INTERNAL_WRITE_RENDER,
GMM_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_RENDER,
GMM_RESOURCE_USAGE_VP_OUTPUT_PICTURE_RENDER,
// CP
GMM_RESOURCE_USAGE_CP_EXTERNAL_READ,
GMM_RESOURCE_USAGE_CP_INTERNAL_WRITE,
};
GMM_RESOURCE_USAGE_TYPE MosInterface::GetGmmResourceUsageType(
MOS_HW_RESOURCE_DEF resUsage)
{
if (resUsage >= (sizeof(GmmResourceUsage) / sizeof(GmmResourceUsage[0])))
return GMM_RESOURCE_USAGE_UNKNOWN;
return GmmResourceUsage[resUsage];
}
MEMORY_OBJECT_CONTROL_STATE MosInterface::GetCachePolicyMemoryObject(
MOS_STREAM_HANDLE streamState,
MOS_HW_RESOURCE_DEF mosUsage)
{
MOS_OS_FUNCTION_ENTER;
//auto gmmClientContext = MosInterface::GetGmmClientContext(streamState);
// Force convert to stream handle for wrapper
auto gmmClientContext = (GMM_CLIENT_CONTEXT *)streamState;
MOS_OS_ASSERT(gmmClientContext);
GMM_RESOURCE_USAGE_TYPE usage = GmmResourceUsage[mosUsage];
if (gmmClientContext->GetCachePolicyElement(usage).Initialized)
{
return gmmClientContext->CachePolicyGetMemoryObject(nullptr, usage);
}
else
{
return gmmClientContext->GetCachePolicyUsage()[GMM_RESOURCE_USAGE_UNKNOWN].MemoryObjectOverride;
}
return {0};
}
uint8_t MosInterface::GetCachePolicyL1Config(
MOS_STREAM_HANDLE streamState,
MOS_HW_RESOURCE_DEF mosUsage)
{
MOS_OS_FUNCTION_ENTER;
return 0;
}
MOS_STATUS MosInterface::GetReservedFromResouce(MOS_RESOURCE_HANDLE resource, uint32_t &val)
{
return MOS_STATUS_UNIMPLEMENTED;
}
MOS_STATUS MosInterface::GetReservedFromStream(MOS_STREAM_HANDLE stream, uint32_t &val)
{
return MOS_STATUS_UNIMPLEMENTED;
}
MOS_STATUS MosInterface::GetReservedFromDevice(MOS_DEVICE_HANDLE device, uint32_t &val)
{
MOS_OS_CHK_NULL_RETURN(device);
OsContextSpecificNext *osDevice = dynamic_cast<OsContextSpecificNext*>(device);
MOS_OS_CHK_NULL_RETURN(osDevice);
if (osDevice->GetBufMgr()->get_reserved)
{
val = *(osDevice->GetBufMgr()->get_reserved);
return MOS_STATUS_SUCCESS;
}
else
{
return MOS_STATUS_UNIMPLEMENTED;
}
}
MOS_STATUS MosInterface::GetperStreamParameters(MOS_STREAM_HANDLE stream, void **perStreamParameters)
{
MOS_OS_CHK_NULL_RETURN(stream);
*perStreamParameters = (void*)stream->perStreamParameters;
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::ConvertResourceFromDdi(
OsSpecificRes osResource,
MOS_RESOURCE_HANDLE &resource,
uint32_t firstArraySlice,
uint32_t mipSlice)
{
MOS_OS_FUNCTION_ENTER;
if (firstArraySlice == OS_SPECIFIC_RESOURCE_INVALID || firstArraySlice >= OS_SPECIFIC_RESOURCE_MAX)
{
MOS_OS_ASSERTMESSAGE("Cannot Convert Resource From Ddi, invalid ddi resource type!");
return MOS_STATUS_INVALID_PARAMETER;
}
MOS_OS_CHK_NULL_RETURN(osResource);
MOS_OS_CHK_NULL_RETURN(resource);
if (firstArraySlice == OS_SPECIFIC_RESOURCE_SURFACE)
{
DDI_MEDIA_SURFACE *mediaSurface = (DDI_MEDIA_SURFACE *)osResource;
switch (mediaSurface->format)
{
case Media_Format_NV12:
resource->Format = Format_NV12;
break;
case Media_Format_NV21:
resource->Format = Format_NV21;
break;
case Media_Format_YUY2:
resource->Format = Format_YUY2;
break;
case Media_Format_X8R8G8B8:
resource->Format = Format_X8R8G8B8;
break;
case Media_Format_X8B8G8R8:
resource->Format = Format_X8B8G8R8;
break;
case Media_Format_A8B8G8R8:
case Media_Format_R8G8B8A8:
resource->Format = Format_A8B8G8R8;
break;
case Media_Format_A8R8G8B8:
resource->Format = Format_A8R8G8B8;
break;
case Media_Format_R5G6B5:
resource->Format = Format_R5G6B5;
break;
case Media_Format_R8G8B8:
resource->Format = Format_R8G8B8;
break;
case Media_Format_RGBP:
resource->Format = Format_RGBP;
break;
case Media_Format_BGRP:
resource->Format = Format_BGRP;
break;
case Media_Format_444P:
resource->Format = Format_444P;
break;
case Media_Format_411P:
resource->Format = Format_411P;
break;
case Media_Format_IMC3:
resource->Format = Format_IMC3;
break;
case Media_Format_400P:
resource->Format = Format_400P;
break;
case Media_Format_422H:
resource->Format = Format_422H;
break;
case Media_Format_422V:
resource->Format = Format_422V;
break;
case Media_Format_Buffer:
resource->Format = Format_Any;
case Media_Format_P010:
resource->Format = Format_P010;
break;
case Media_Format_P012:
case Media_Format_P016:
resource->Format = Format_P016;
break;
case Media_Format_Y210:
resource->Format = Format_Y210;
break;
#if VA_CHECK_VERSION(1, 9, 0)
case Media_Format_Y212:
#endif
case Media_Format_Y216:
resource->Format = Format_Y216;
break;
case Media_Format_AYUV:
resource->Format = Format_AYUV;
break;
case Media_Format_Y410:
resource->Format = Format_Y410;
break;
#if VA_CHECK_VERSION(1, 9, 0)
case Media_Format_Y412:
#endif
case Media_Format_Y416:
resource->Format = Format_Y416;
break;
case Media_Format_Y8:
resource->Format = Format_Y8;
break;
case Media_Format_Y16S:
resource->Format = Format_Y16S;
break;
case Media_Format_Y16U:
resource->Format = Format_Y16U;
break;
case Media_Format_R10G10B10A2:
case Media_Format_R10G10B10X2:
resource->Format = Format_R10G10B10A2;
break;
case Media_Format_B10G10R10A2:
case Media_Format_B10G10R10X2:
resource->Format = Format_B10G10R10A2;
break;
case Media_Format_UYVY:
resource->Format = Format_UYVY;
break;
case Media_Format_VYUY:
resource->Format = Format_VYUY;
break;
case Media_Format_YVYU:
resource->Format = Format_YVYU;
break;
case Media_Format_A16R16G16B16:
resource->Format = Format_A16R16G16B16;
break;
case Media_Format_A16B16G16R16:
resource->Format = Format_A16B16G16R16;
break;
default:
MOS_OS_ASSERTMESSAGE("MOS: unsupported media format for surface.");
break;
}
resource->iWidth = mediaSurface->iWidth;
resource->iHeight = mediaSurface->iHeight;
resource->iPitch = mediaSurface->iPitch;
resource->iCount = mediaSurface->iRefCount;
resource->isTiled = mediaSurface->isTiled;
resource->TileType = LinuxToMosTileType(mediaSurface->TileType);
resource->bo = mediaSurface->bo;
resource->name = mediaSurface->name;
resource->ppCurrentFrameSemaphore = &mediaSurface->pCurrentFrameSemaphore;
resource->ppReferenceFrameSemaphore = &mediaSurface->pReferenceFrameSemaphore;
resource->bSemInitialized = false;
resource->bMapped = false;
if (mediaSurface->bMapped == true)
{
resource->pData = mediaSurface->pData;
}
else
{
resource->pData = nullptr;
}
resource->pGmmResInfo = mediaSurface->pGmmResourceInfo;
resource->dwGfxAddress = 0;
}
else if (firstArraySlice == OS_SPECIFIC_RESOURCE_BUFFER)
{
DDI_MEDIA_BUFFER *mediaBuffer = (DDI_MEDIA_BUFFER *)osResource;
switch (mediaBuffer->format)
{
case Media_Format_Buffer:
resource->Format = Format_Buffer;
resource->iWidth = mediaBuffer->iSize;
resource->iHeight = 1;
resource->iPitch = mediaBuffer->iSize;
break;
case Media_Format_Perf_Buffer:
resource->Format = Format_Buffer;
resource->iWidth = mediaBuffer->iSize;
resource->iHeight = 1;
resource->iPitch = mediaBuffer->iSize;
break;
case Media_Format_2DBuffer:
resource->Format = Format_Buffer_2D;
resource->iWidth = mediaBuffer->uiWidth;
resource->iHeight = mediaBuffer->uiHeight;
resource->iPitch = mediaBuffer->uiPitch;
break;
case Media_Format_CPU:
return MOS_STATUS_SUCCESS;
default:
resource->iWidth = mediaBuffer->iSize;
resource->iHeight = 1;
resource->iPitch = mediaBuffer->iSize;
MOS_OS_ASSERTMESSAGE("MOS: unsupported media format for surface.");
break;
}
resource->iCount = mediaBuffer->iRefCount;
resource->isTiled = 0;
resource->TileType = LinuxToMosTileType(mediaBuffer->TileType);
resource->bo = mediaBuffer->bo;
resource->name = mediaBuffer->name;
resource->bMapped = false;
if (mediaBuffer->bMapped == true)
{
resource->pData = mediaBuffer->pData;
}
else
{
resource->pData = nullptr;
}
resource->dwGfxAddress = 0;
resource->pGmmResInfo = mediaBuffer->pGmmResourceInfo;
}
resource->bConvertedFromDDIResource = true;
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::CreateOsSpecificResourceInfo(OsSpecificRes resource, bool isInternal)
{
MOS_OS_FUNCTION_ENTER;
// No OsSpecificResourceInfo in Linux
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::DestroySpecificResourceInfo(OsSpecificRes resource)
{
MOS_OS_FUNCTION_ENTER;
// No OsSpecificResourceInfo in Linux
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::AllocateResource(
MOS_STREAM_HANDLE streamState,
PMOS_ALLOC_GFXRES_PARAMS params,
MOS_RESOURCE_HANDLE &resource
#if MOS_MESSAGES_ENABLED
,
const char *functionName,
const char *filename,
int32_t line
#endif
)
{
MOS_STATUS estatus = MOS_STATUS_SUCCESS;
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(resource);
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(streamState->osDeviceContext);
#if (_DEBUG || _RELEASE_INTERNAL)
if (MosSimulateOsApiFail(OS_FAIL_ALLOC_GFX_RES, __FUNCTION__, __FILE__, __LINE__))
{
return MOS_STATUS_NO_SPACE;
}
#endif
resource->bConvertedFromDDIResource = false;
if (!params->bBypassMODImpl)
{
resource->pGfxResourceNext = GraphicsResourceNext::CreateGraphicResource(GraphicsResourceNext::osSpecificResource);
MOS_OS_CHK_NULL_RETURN(resource->pGfxResourceNext);
GraphicsResourceNext::CreateParams createParams(params);
auto eStatus = resource->pGfxResourceNext->Allocate(streamState->osDeviceContext, createParams);
MOS_OS_CHK_STATUS_MESSAGE_RETURN(eStatus, "Allocate graphic resource failed");
eStatus = resource->pGfxResourceNext->ConvertToMosResource(resource);
MOS_OS_CHK_STATUS_MESSAGE_RETURN(eStatus, "Convert graphic resource failed");
}
else
{
estatus = GraphicsResourceSpecificNext::AllocateExternalResource(streamState, params, resource);
MOS_OS_CHK_STATUS_MESSAGE_RETURN(estatus, "Allocate external graphic resource failed");
}
MOS_OS_CHK_NULL_RETURN(resource->pGmmResInfo);
MosUtilities::MosAtomicIncrement(&MosUtilities::m_mosMemAllocCounterGfx);
MOS_MEMNINJA_GFX_ALLOC_MESSAGE(
resource->pGmmResInfo,
params->pBufName,
streamState->component,
(uint32_t)resource->pGmmResInfo->GetSizeSurface(),
params->dwArraySize,
functionName,
filename,
line);
return MOS_STATUS_SUCCESS;
}
//The input bit definition in MOS_GFXRES_FREE_FLAGS
uint32_t MosInterface::ConvertHalFreeFlagsToOsFreeFlags(
uint32_t halFreeFlag)
{
return halFreeFlag;
}
MOS_STATUS MosInterface::FreeResource(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE resource,
uint32_t flag
#if MOS_MESSAGES_ENABLED
,
const char *functionName,
const char *filename,
int32_t line
#endif // MOS_MESSAGES_ENABLED
)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(resource);
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(streamState->osDeviceContext);
bool osContextValid = streamState->osDeviceContext->GetOsContextValid();
bool byPassMod = !((!resource->bConvertedFromDDIResource) && (osContextValid == true) && (resource->pGfxResourceNext));
if (!byPassMod)
{
if (resource && resource->pGfxResourceNext)
{
resource->pGfxResourceNext->Free(streamState->osDeviceContext);
}
else
{
MOS_OS_VERBOSEMESSAGE("Received an empty Graphics Resource, skip free");
}
MOS_Delete(resource->pGfxResourceNext);
resource->pGfxResourceNext = nullptr;
MosUtilities::MosAtomicDecrement(&MosUtilities::m_mosMemAllocCounterGfx);
MOS_MEMNINJA_GFX_FREE_MESSAGE(resource->pGmmResInfo, functionName, filename, line);
MosUtilities::MosZeroMemory(resource, sizeof(*resource));
return MOS_STATUS_SUCCESS;
}
MOS_STATUS status = GraphicsResourceSpecificNext::FreeExternalResource(streamState, resource, flag);
if (resource->pGmmResInfo != nullptr &&
streamState->perStreamParameters != nullptr)
{
PMOS_CONTEXT perStreamParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
if (perStreamParameters && perStreamParameters->pGmmClientContext)
{
MosUtilities::m_mosMemAllocCounterGfx--;
MOS_MEMNINJA_GFX_FREE_MESSAGE(resource->pGmmResInfo, functionName, filename, line);
perStreamParameters->pGmmClientContext->DestroyResInfoObject(resource->pGmmResInfo);
resource->pGmmResInfo = nullptr;
}
}
return status;
}
MOS_STATUS MosInterface::GetResourceInfo(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE resource,
MosResourceInfo &details) //MOS_SURFACE
{
MOS_OS_FUNCTION_ENTER;
GMM_RESOURCE_INFO * gmmResourceInfo = nullptr;
GMM_DISPLAY_FRAME gmmChannel = GMM_DISPLAY_FRAME_MAX;
GMM_REQ_OFFSET_INFO reqInfo[3] = {};
GMM_RESOURCE_FLAG gmmFlags = {};
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(resource);
// Get Gmm resource info
gmmResourceInfo = (GMM_RESOURCE_INFO*)resource->pGmmResInfo;
MOS_OS_CHK_NULL_RETURN(gmmResourceInfo);
gmmFlags = gmmResourceInfo->GetResFlags();
// Get resource information
details.dwWidth = GFX_ULONG_CAST(gmmResourceInfo->GetBaseWidth());
details.dwHeight = gmmResourceInfo->GetBaseHeight();
details.dwPitch = GFX_ULONG_CAST(gmmResourceInfo->GetRenderPitch());
details.dwSize = GFX_ULONG_CAST(gmmResourceInfo->GetSizeSurface());
details.dwDepth = MOS_MAX(1, gmmResourceInfo->GetBaseDepth());
details.dwLockPitch = GFX_ULONG_CAST(gmmResourceInfo->GetRenderPitch());
details.dwQPitch = gmmResourceInfo->GetQPitch();
details.bCompressible = gmmFlags.Gpu.MMC ?
(gmmResourceInfo->GetMmcHint(0) == GMM_MMC_HINT_ON) : false;
details.bIsCompressed = gmmResourceInfo->IsMediaMemoryCompressed(0);
details.CompressionMode = (MOS_RESOURCE_MMC_MODE)gmmResourceInfo->GetMmcMode(0);
if (0 == details.dwPitch)
{
MOS_OS_ASSERTMESSAGE("Pitch from GmmResource is 0, unexpected.");
return MOS_STATUS_INVALID_PARAMETER;
}
// check resource's tile type
details.TileModeGMM = (MOS_TILE_MODE_GMM)gmmResourceInfo->GetTileModeSurfaceState();
details.bGMMTileEnabled = true;
switch (gmmResourceInfo->GetTileType())
{
case GMM_TILED_Y:
if (gmmFlags.Info.TiledYf)
{
details.TileType = MOS_TILE_YF;
}
else if (gmmFlags.Info.TiledYs)
{
details.TileType = MOS_TILE_YS;
}
else
{
details.TileType = MOS_TILE_Y;
}
break;
case GMM_TILED_X:
details.TileType = MOS_TILE_X;
break;
case GMM_NOT_TILED:
details.TileType = MOS_TILE_LINEAR;
break;
default:
details.TileType = MOS_TILE_Y;
break;
}
details.Format = resource->Format;
// Get planes
MosUtilities::MosZeroMemory(reqInfo, sizeof(reqInfo));
gmmChannel = GMM_DISPLAY_BASE;
// Get the base offset of the surface (plane Y)
reqInfo[2].ReqRender = true;
reqInfo[2].Plane = GMM_PLANE_Y;
reqInfo[2].Frame = gmmChannel;
reqInfo[2].CubeFace = __GMM_NO_CUBE_MAP;
reqInfo[2].ArrayIndex = 0;
gmmResourceInfo->GetOffset(reqInfo[2]);
details.RenderOffset.YUV.Y.BaseOffset = reqInfo[2].Render.Offset;
details.RenderOffset.YUV.Y.XOffset = reqInfo[2].Render.XOffset;
details.RenderOffset.YUV.Y.YOffset = reqInfo[2].Render.YOffset;
details.LockOffset.YUV.Y = reqInfo[2].Lock.Offset;
// Get U/UV plane information (plane offset, X/Y offset)
reqInfo[0].ReqRender = true;
reqInfo[0].Plane = GMM_PLANE_U;
reqInfo[0].Frame = gmmChannel;
reqInfo[0].CubeFace = __GMM_NO_CUBE_MAP;
reqInfo[0].ArrayIndex = 0;
gmmResourceInfo->GetOffset(reqInfo[0]);
details.RenderOffset.YUV.U.BaseOffset = reqInfo[0].Render.Offset;
details.RenderOffset.YUV.U.XOffset = reqInfo[0].Render.XOffset;
details.RenderOffset.YUV.U.YOffset = reqInfo[0].Render.YOffset;
details.LockOffset.YUV.U = reqInfo[0].Lock.Offset;
// Get V plane information (plane offset, X/Y offset)
reqInfo[1].ReqRender = true;
reqInfo[1].Plane = GMM_PLANE_V;
reqInfo[1].Frame = gmmChannel;
reqInfo[1].CubeFace = __GMM_NO_CUBE_MAP;
reqInfo[1].ArrayIndex = 0;
gmmResourceInfo->GetOffset(reqInfo[1]);
details.RenderOffset.YUV.V.BaseOffset = reqInfo[1].Render.Offset;
details.RenderOffset.YUV.V.XOffset = reqInfo[1].Render.XOffset;
details.RenderOffset.YUV.V.YOffset = reqInfo[1].Render.YOffset;
details.LockOffset.YUV.V = reqInfo[1].Lock.Offset;
// Get Y plane information (plane offset, X / Y offset)
details.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
details.YPlaneOffset.iSurfaceOffset = details.RenderOffset.YUV.Y.BaseOffset;
details.YPlaneOffset.iXOffset = details.RenderOffset.YUV.Y.XOffset;
details.YPlaneOffset.iYOffset = details.RenderOffset.YUV.Y.YOffset;
details.YPlaneOffset.iLockSurfaceOffset = details.LockOffset.YUV.Y;
// Get U/UV plane information (plane offset, X/Y offset)
details.UPlaneOffset.iSurfaceOffset = details.RenderOffset.YUV.U.BaseOffset;
details.UPlaneOffset.iXOffset = details.RenderOffset.YUV.U.XOffset;
details.UPlaneOffset.iYOffset = details.RenderOffset.YUV.U.YOffset;
details.UPlaneOffset.iLockSurfaceOffset = details.LockOffset.YUV.U;
// Get V plane information (plane offset, X/Y offset)
details.VPlaneOffset.iSurfaceOffset = details.RenderOffset.YUV.V.BaseOffset;
details.VPlaneOffset.iXOffset = details.RenderOffset.YUV.V.XOffset;
details.VPlaneOffset.iYOffset = details.RenderOffset.YUV.V.YOffset;
details.VPlaneOffset.iLockSurfaceOffset = details.LockOffset.YUV.V;
details.YoffsetForUplane = (details.UPlaneOffset.iSurfaceOffset - details.dwOffset) / details.dwPitch +
details.UPlaneOffset.iYOffset;
details.YoffsetForVplane = (details.VPlaneOffset.iSurfaceOffset - details.dwOffset) / details.dwPitch +
details.VPlaneOffset.iYOffset;
return eStatus;
}
void *MosInterface::LockMosResource(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE resource,
PMOS_LOCK_PARAMS flags)
{
MOS_OS_FUNCTION_ENTER;
void *pData = nullptr;
if (nullptr == streamState)
{
MOS_OS_ASSERTMESSAGE("input parameter streamState is NULL.");
return nullptr;
}
if (nullptr == resource)
{
MOS_OS_ASSERTMESSAGE("input parameter resource is NULL.");
return nullptr;
}
if ((!resource->bConvertedFromDDIResource) && (resource->pGfxResourceNext))
{
if (nullptr == streamState->osDeviceContext)
{
MOS_OS_ASSERTMESSAGE("invalid osDeviceContext, skip lock");
return nullptr;
}
if (resource->pGfxResourceNext)
{
GraphicsResourceNext::LockParams params(flags);
pData = resource->pGfxResourceNext->Lock(streamState->osDeviceContext, params);
}
else
{
MOS_OS_ASSERTMESSAGE("Received an empty Graphics Resource, skip lock");
return nullptr;
}
return pData;
}
pData = GraphicsResourceSpecificNext::LockExternalResource(streamState, resource, flags);
return pData;
}
MOS_STATUS MosInterface::UnlockMosResource(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE resource)
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(resource);
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(streamState->osDeviceContext);
if ((!resource->bConvertedFromDDIResource) && (resource->pGfxResourceNext))
{
if (resource->pGfxResourceNext)
{
eStatus = resource->pGfxResourceNext->Unlock(streamState->osDeviceContext);
}
else
{
MOS_OS_VERBOSEMESSAGE("Received an empty Graphics Resource, skip unlock");
}
return eStatus;
}
eStatus = GraphicsResourceSpecificNext::UnlockExternalResource(streamState, resource);
return eStatus;
}
MOS_STATUS MosInterface::UpdateResourceUsageType(
PMOS_RESOURCE pOsResource,
MOS_HW_RESOURCE_DEF resUsageType)
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
//---------------------------------
MOS_OS_CHK_NULL_RETURN(pOsResource);
MOS_OS_CHK_NULL_RETURN(pOsResource->pGmmResInfo);
//---------------------------------
pOsResource->pGmmResInfo->OverrideCachePolicyUsage(GetGmmResourceUsageType(resUsageType));
return eStatus;
}
MOS_STATUS MosInterface::RegisterResource(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE resource,
bool write)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(resource);
MOS_OS_CHK_NULL_RETURN(streamState->osDeviceContext);
#if (_DEBUG || _RELEASE_INTERNAL)
if (MosSimulateOsApiFail(OS_FAIL_REGISTER_GFX_RES, __FUNCTION__, __FILE__, __LINE__))
{
return MOS_STATUS_NO_SPACE;
}
#endif
auto gpuContext = MosInterface::GetGpuContext(streamState, streamState->currentGpuContextHandle);
MOS_OS_CHK_NULL_RETURN(gpuContext);
return (gpuContext->RegisterResource(resource, write));
}
uint64_t MosInterface::GetResourceGfxAddress(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE resource)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(resource);
if (!mos_gem_bo_is_softpin(resource->bo))
{
mos_bo_set_softpin(resource->bo);
}
return resource->bo->offset64;
}
uint32_t MosInterface::GetResourceAllocationIndex(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE resource)
{
MOS_OS_FUNCTION_ENTER;
return 0;
}
MOS_STATUS MosInterface::SkipResourceSync(
MOS_RESOURCE_HANDLE resource)
{
MOS_OS_FUNCTION_ENTER;
// No resource sync to skip
return MOS_STATUS_SUCCESS;
}
MOS_STATUS SyncOnResource(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE resource,
bool writeOperation,
GPU_CONTEXT_HANDLE requsetorGpuContext)
{
MOS_OS_FUNCTION_ENTER;
// No need to do sync on resource
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::ResourceSyncCallback(
OsSpecificRes resource,
MOS_DEVICE_HANDLE deviceContext,
uint32_t index,
SYNC_HAZARD hazardType,
GPU_CONTEXT_HANDLE busyCtx,
GPU_CONTEXT_HANDLE requestorCtx,
OS_HANDLE osHandle)
{
MOS_OS_FUNCTION_ENTER;
// No need to do resource sync
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::LockSyncCallback(
OsSpecificRes resource,
MOS_DEVICE_HANDLE deviceContext,
uint32_t index,
SYNC_HAZARD hazardType,
GPU_CONTEXT_HANDLE busyCtx,
bool doNotWait)
{
MOS_OS_FUNCTION_ENTER;
// No need to do Lock sync
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::TrimResidency(
MOS_DEVICE_HANDLE device,
bool periodicTrim,
bool restartPeriodicTrim,
uint64_t &numBytesToTrim,
bool trimToMinimum,
bool trimOnlyMediaResources)
{
MOS_OS_FUNCTION_ENTER;
// No residency to trim
return MOS_STATUS_SUCCESS;
}
MOS_STATUS UpdateResidency(
MOS_DEVICE_HANDLE device,
OsSpecificRes resInfo,
uint32_t index)
{
MOS_OS_FUNCTION_ENTER;
// No residency to update
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::SetMemoryCompressionMode(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE resource,
MOS_MEMCOMP_STATE resMmcMode)
{
MOS_OS_FUNCTION_ENTER;
PGMM_RESOURCE_INFO pGmmResourceInfo = nullptr;
GMM_RESOURCE_MMC_INFO GmmResMmcMode = GMM_MMC_DISABLED;
MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
MOS_OS_CHK_NULL_RETURN(resource);
// Get Gmm resource info
pGmmResourceInfo = (GMM_RESOURCE_INFO *)resource->pGmmResInfo;
MOS_OS_CHK_NULL_RETURN(pGmmResourceInfo);
switch (resMmcMode)
{
case MOS_MEMCOMP_HORIZONTAL:
GmmResMmcMode = GMM_MMC_HORIZONTAL;
break;
case MOS_MEMCOMP_VERTICAL:
GmmResMmcMode = GMM_MMC_VERTICAL;
break;
case MOS_MEMCOMP_DISABLED:
default:
GmmResMmcMode = GMM_MMC_DISABLED;
break;
}
pGmmResourceInfo->SetMmcMode(GmmResMmcMode, 0);
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
MOS_STATUS MosInterface::GetMemoryCompressionMode(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE resource,
MOS_MEMCOMP_STATE &resMmcMode)
{
MOS_OS_FUNCTION_ENTER;
PGMM_RESOURCE_INFO gmmResourceInfo = nullptr;
GMM_RESOURCE_FLAG flags;
MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
MOS_OS_CHK_NULL_RETURN(resource);
MosUtilities::MosZeroMemory(&flags, sizeof(GMM_RESOURCE_FLAG));
// Get Gmm resource info
gmmResourceInfo = (GMM_RESOURCE_INFO *)resource->pGmmResInfo;
MOS_OS_CHK_NULL_RETURN(gmmResourceInfo);
flags = resource->pGmmResInfo->GetResFlags();
if (!flags.Gpu.MMC || !flags.Gpu.CCS)
{
resMmcMode = MOS_MEMCOMP_DISABLED;
return MOS_STATUS_SUCCESS;
}
if (flags.Info.MediaCompressed || flags.Info.RenderCompressed)
{
resMmcMode = flags.Info.RenderCompressed ? MOS_MEMCOMP_RC : MOS_MEMCOMP_MC;
}
else
{
switch (gmmResourceInfo->GetMmcMode(0))
{
case GMM_MMC_HORIZONTAL:
resMmcMode = MOS_MEMCOMP_HORIZONTAL;
break;
case GMM_MMC_VERTICAL:
resMmcMode = MOS_MEMCOMP_VERTICAL;
break;
case GMM_MMC_DISABLED:
default:
resMmcMode = MOS_MEMCOMP_DISABLED;
break;
}
}
uint32_t MmcFormat = 0;
GMM_RESOURCE_FORMAT gmmResFmt;
gmmResFmt = gmmResourceInfo->GetResourceFormat();
auto skuTable = GetSkuTable(streamState);
MOS_OS_CHK_NULL_RETURN(MosInterface::GetGmmClientContext(streamState));
MOS_OS_CHK_NULL_RETURN(skuTable);
if (resMmcMode == MOS_MEMCOMP_MC &&
(!MEDIA_IS_SKU(skuTable, FtrFlatPhysCCS)))
{
MmcFormat = static_cast<uint32_t>(MosInterface::GetGmmClientContext(streamState)->GetMediaSurfaceStateCompressionFormat(gmmResFmt));
resMmcMode = (MmcFormat != 0) ? resMmcMode : MOS_MEMCOMP_DISABLED;
}
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
MOS_STATUS MosInterface::SetMemoryCompressionHint(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE resource,
bool hintOn)
{
MOS_OS_FUNCTION_ENTER;
PGMM_RESOURCE_INFO pGmmResourceInfo = nullptr;
uint32_t uiArrayIndex = 0;
MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
MOS_OS_CHK_NULL_RETURN(resource);
// Get Gmm resource info
pGmmResourceInfo = (GMM_RESOURCE_INFO *)resource->pGmmResInfo;
MOS_OS_CHK_NULL_RETURN(pGmmResourceInfo);
pGmmResourceInfo->SetMmcHint(hintOn ? GMM_MMC_HINT_ON : GMM_MMC_HINT_OFF, uiArrayIndex);
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
MOS_STATUS MosInterface::GetMemoryCompressionFormat(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE resource,
uint32_t * resMmcFormat)
{
MOS_OS_FUNCTION_ENTER;
MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
PGMM_RESOURCE_INFO pGmmResourceInfo;
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(resource);
MOS_OS_CHK_NULL_RETURN(resMmcFormat);
pGmmResourceInfo = (GMM_RESOURCE_INFO *)resource->pGmmResInfo;
MOS_OS_CHK_NULL_RETURN(pGmmResourceInfo);
MOS_OS_CHK_NULL_RETURN(MosInterface::GetGmmClientContext(streamState));
// Get compression format from GMM RESOURCE FORMAT
GMM_RESOURCE_FORMAT gmmResFmt;
gmmResFmt = pGmmResourceInfo->GetResourceFormat();
MOS_MEMCOMP_STATE MmcMode = MOS_MEMCOMP_DISABLED;
uint32_t MmcFormat = 0;
MosInterface::GetMemoryCompressionMode(streamState, resource, MmcMode);
switch (MmcMode)
{
case MOS_MEMCOMP_MC:
MmcFormat = static_cast<uint32_t>(MosInterface::GetGmmClientContext(streamState)->GetMediaSurfaceStateCompressionFormat(gmmResFmt));
break;
case MOS_MEMCOMP_RC:
MmcFormat = static_cast<uint32_t>(MosInterface::GetGmmClientContext(streamState)->GetSurfaceStateCompressionFormat(gmmResFmt));
break;
default:
MmcFormat = 0;
}
if (MmcFormat > 0x1F)
{
MOS_OS_ASSERTMESSAGE("Get a incorrect Compression format(%d) from GMM", MmcFormat);
}
else
{
*resMmcFormat = MmcFormat;
MOS_OS_VERBOSEMESSAGE("GMM compression mode %d, compression format %d", MmcMode, MmcFormat);
}
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
MOS_STATUS MosInterface::DoubleBufferCopyResource(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE inputResource,
MOS_RESOURCE_HANDLE outputResource,
bool outputCompressed)
{
MOS_OS_FUNCTION_ENTER;
MOS_STATUS status = MOS_STATUS_SUCCESS;
MOS_OS_CHK_NULL_RETURN(inputResource);
MOS_OS_CHK_NULL_RETURN(outputResource);
MOS_OS_CHK_NULL_RETURN(streamState);
if (inputResource && inputResource->bo && inputResource->pGmmResInfo &&
outputResource && outputResource->bo && outputResource->pGmmResInfo)
{
OsContextNext *osCtx = streamState->osDeviceContext;
MOS_OS_CHK_NULL_RETURN(osCtx);
MosDecompression *mosDecompression = osCtx->GetMosDecompression();
MOS_OS_CHK_NULL_RETURN(mosDecompression);
// Double Buffer Copy can support any tile status surface with/without compression
mosDecompression->MediaMemoryCopy(inputResource, outputResource, outputCompressed);
}
return status;
}
MOS_STATUS MosInterface::MediaCopyResource2D(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE inputResource,
MOS_RESOURCE_HANDLE outputResource,
uint32_t copyWidth,
uint32_t copyHeight,
uint32_t copyInputOffset,
uint32_t copyOutputOffset,
uint32_t bpp,
bool outputCompressed)
{
MOS_OS_FUNCTION_ENTER;
MOS_STATUS status = MOS_STATUS_SUCCESS;
MOS_OS_CHK_NULL_RETURN(inputResource);
MOS_OS_CHK_NULL_RETURN(outputResource);
MOS_OS_CHK_NULL_RETURN(streamState);
if (inputResource && inputResource->bo && inputResource->pGmmResInfo &&
outputResource && outputResource->bo && outputResource->pGmmResInfo)
{
OsContextNext *osCtx = streamState->osDeviceContext;
MOS_OS_CHK_NULL_RETURN(osCtx);
MosDecompression *mosDecompression = osCtx->GetMosDecompression();
MOS_OS_CHK_NULL_RETURN(mosDecompression);
// Double Buffer Copy can support any tile status surface with/without compression
mosDecompression->MediaMemoryCopy2D(inputResource, outputResource,
copyWidth, copyHeight, copyInputOffset, copyOutputOffset, bpp, outputCompressed);
}
return status;
}
MOS_STATUS MosInterface::DecompResource(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE resource)
{
MOS_OS_FUNCTION_ENTER;
MOS_STATUS status = MOS_STATUS_SUCCESS;
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(resource);
MOS_OS_CHK_NULL_RETURN(resource->bo);
MOS_OS_CHK_NULL_RETURN(resource->pGmmResInfo);
MOS_LINUX_BO *bo = resource->bo;
if (resource->pGmmResInfo->IsMediaMemoryCompressed(0))
{
OsContextNext *osCtx = streamState->osDeviceContext;
MOS_OS_CHK_NULL_RETURN(osCtx);
MosDecompression *mosDecompression = osCtx->GetMosDecompression();
MOS_OS_CHK_NULL_RETURN(mosDecompression);
mosDecompression->MemoryDecompress(resource);
}
return MOS_STATUS_SUCCESS;
}
uint32_t MosInterface::GetGpuStatusTag(
MOS_STREAM_HANDLE streamState,
GPU_CONTEXT_HANDLE gpuContext)
{
MOS_OS_FUNCTION_ENTER;
if (streamState)
{
auto gpuContextIns = MosInterface::GetGpuContext(streamState, gpuContext);
if (gpuContextIns == nullptr)
{
MOS_OS_ASSERTMESSAGE("Get GPU Status Tag failed.");
return 0;
}
return gpuContextIns->GetGpuStatusTag();
}
MOS_OS_ASSERTMESSAGE("Get GPU Status Tag failed.");
return 0;
}
MOS_STATUS MosInterface::IncrementGpuStatusTag(
MOS_STREAM_HANDLE streamState,
GPU_CONTEXT_HANDLE gpuContext)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(streamState);
auto gpuContextIns = MosInterface::GetGpuContext(streamState, gpuContext);
MOS_OS_CHK_NULL_RETURN(gpuContextIns);
gpuContextIns->IncrementGpuStatusTag();
return MOS_STATUS_SUCCESS;
}
uint64_t MosInterface::GetGpuStatusSyncTag(
MOS_STREAM_HANDLE streamState,
GPU_CONTEXT_HANDLE gpuContext)
{
MOS_OS_FUNCTION_ENTER;
// No Gpu Status Sync Tag in Linux
return 0;
}
MOS_STATUS MosInterface::GetGpuStatusBufferResource(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE &resource,
GPU_CONTEXT_HANDLE gpuContext)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(streamState);
auto gpuContextIns = MosInterface::GetGpuContext(streamState, gpuContext);
MOS_OS_CHK_NULL_RETURN(gpuContextIns);
resource = gpuContextIns->GetStatusBufferResource();
return MOS_STATUS_SUCCESS;
}
GMM_CLIENT_CONTEXT *MosInterface::GetGmmClientContext(
MOS_STREAM_HANDLE streamState)
{
MOS_OS_FUNCTION_ENTER;
if (streamState && streamState->osDeviceContext)
{
return streamState->osDeviceContext->GetGmmClientContext();
}
return nullptr;
}
void MosInterface::GetGpuPriority(MOS_STREAM_HANDLE streamState, int32_t* pPriority)
{
MOS_OS_FUNCTION_ENTER;
if (streamState == nullptr)
{
MOS_OS_ASSERTMESSAGE("Failed to set the gpu priority");
return;
}
PMOS_OS_CONTEXT pOsContext = (PMOS_OS_CONTEXT)streamState->perStreamParameters;
if (pOsContext == nullptr)
{
MOS_OS_ASSERTMESSAGE("Failed to set the gpu priority");
return;
}
uint64_t priority = 0;
mos_get_context_param(pOsContext->intel_context, 0, I915_CONTEXT_PARAM_PRIORITY, &priority);
*pPriority = (int32_t)priority;
}
void MosInterface::SetGpuPriority(MOS_STREAM_HANDLE streamState, int32_t priority)
{
MOS_OS_FUNCTION_ENTER;
if (streamState == nullptr)
{
MOS_OS_ASSERTMESSAGE("Failed to set the gpu priority");
return;
}
if (streamState->ctxPriority == priority)
return;
PMOS_OS_CONTEXT pOsContext = (PMOS_OS_CONTEXT)streamState->perStreamParameters;
if (pOsContext == nullptr)
{
MOS_OS_ASSERTMESSAGE("Failed to set the gpu priority");
return;
}
int32_t ret = mos_set_context_param(pOsContext->intel_context, 0, I915_CONTEXT_PARAM_PRIORITY,(uint64_t)priority);
if (ret != 0)
{
MOS_OS_ASSERTMESSAGE("failed to set the gpu priority, error is %d", ret);
}
streamState->ctxPriority = priority;
}
uint64_t MosInterface::GetAuxTableBaseAddr(
MOS_STREAM_HANDLE streamState)
{
MOS_OS_FUNCTION_ENTER;
return 0;
}
MosCpInterface *MosInterface::GetCpInterface(MOS_STREAM_HANDLE streamState)
{
MOS_OS_FUNCTION_ENTER;
return streamState ? streamState->osCpInterface : nullptr;
}
MosOcaInterface *MosInterface::GetOcaInterface(MOS_STREAM_HANDLE streamState)
{
MOS_OS_FUNCTION_ENTER;
return nullptr;
}
MOS_VE_HANDLE MosInterface::GetVirtualEngineState(
MOS_STREAM_HANDLE streamState)
{
MOS_OS_FUNCTION_ENTER;
return streamState ? streamState->virtualEngineInterface : nullptr;
}
MOS_STATUS MosInterface::SetVirtualEngineState(
MOS_STREAM_HANDLE streamState,
MOS_VE_HANDLE veState)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(veState);
streamState->virtualEngineInterface = veState;
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::CreateVirtualEngineState(
MOS_STREAM_HANDLE streamState,
PMOS_VIRTUALENGINE_INIT_PARAMS veInitParms,
MOS_VE_HANDLE& veState)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(streamState);
if (veInitParms->bScalabilitySupported)
{
streamState->virtualEngineInterface = MOS_New(MosOsVeScalabilitySpecific);
}
else
{
streamState->virtualEngineInterface = MOS_New(MosOsVeSinglePipeSpecific);
}
MOS_OS_CHK_NULL_RETURN(streamState->virtualEngineInterface);
MOS_OS_CHK_STATUS_RETURN(streamState->virtualEngineInterface->Initialize(streamState, veInitParms));
veState = streamState->virtualEngineInterface;
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::DestroyVirtualEngineState(
MOS_STREAM_HANDLE streamState)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(streamState);
if (streamState->virtualEngineInterface)
{
streamState->virtualEngineInterface->Destroy();
MOS_Delete(streamState->virtualEngineInterface);
}
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::SetVeHintParams(
MOS_STREAM_HANDLE streamState,
PMOS_VIRTUALENGINE_SET_PARAMS veParams)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(streamState->virtualEngineInterface);
return streamState->virtualEngineInterface->SetHintParams(veParams);
}
MOS_STATUS MosInterface::GetVeHintParams(
MOS_STREAM_HANDLE streamState,
bool scalableMode,
PMOS_VIRTUALENGINE_HINT_PARAMS* hintParams)
{
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(streamState->virtualEngineInterface);
MOS_OS_CHK_NULL_RETURN(hintParams);
return streamState->virtualEngineInterface->GetHintParams(scalableMode, hintParams);
}
MOS_STATUS MosInterface::SetVeSubmissionType(
MOS_STREAM_HANDLE streamState,
COMMAND_BUFFER_HANDLE cmdBuf,
MOS_SUBMISSION_TYPE type)
{
MOS_OS_CHK_NULL_RETURN(cmdBuf);
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(streamState->virtualEngineInterface);
return streamState->virtualEngineInterface->SetSubmissionType(cmdBuf, type);
}
#if _DEBUG || _RELEASE_INTERNAL
uint8_t MosInterface::GetVeEngineCount(
MOS_STREAM_HANDLE streamState)
{
return streamState && streamState->virtualEngineInterface ?
streamState->virtualEngineInterface->GetEngineCount() : 0;
}
uint8_t MosInterface::GetEngineLogicId(
MOS_STREAM_HANDLE streamState,
uint32_t instanceIdx)
{
return streamState && streamState->virtualEngineInterface ?
streamState->virtualEngineInterface->GetEngineLogicId(instanceIdx) : 0;
}
#endif // _DEBUG || _RELEASE_INTERNAL
MOS_STATUS MosInterface::ComposeCommandBufferHeader(
MOS_STREAM_HANDLE streamState,
COMMAND_BUFFER_HANDLE cmdBuffer)
{
MOS_OS_FUNCTION_ENTER;
// No Command buffer header to compose
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosInterface::MosLoadLibrary(
MOS_STREAM_HANDLE streamState,
PCCHAR pFileName,
PHMODULE ppvModule)
{
MOS_OS_FUNCTION_ENTER;
MOS_UNUSED(streamState);
MOS_OS_ASSERT(pFileName);
return MosUtilities::MosLoadLibrary(pFileName, ppvModule);
}
MOS_STATUS MosInterface::MosFreeLibrary(HMODULE hLibModule)
{
MOS_OS_ASSERT(hLibModule);
uint32_t ret = MosUtilities::MosFreeLibrary(hLibModule);
return (ret == true) ? MOS_STATUS_SUCCESS : MOS_STATUS_UNKNOWN;
}
GpuContextSpecificNext *MosInterface::GetGpuContext(MOS_STREAM_HANDLE streamState, GPU_CONTEXT_HANDLE handle)
{
MOS_OS_FUNCTION_ENTER;
if (streamState && streamState->osDeviceContext)
{
auto osDeviceContext = streamState->osDeviceContext;
auto gpuContextMgr = osDeviceContext->GetGpuContextMgr();
if (gpuContextMgr)
{
GpuContextNext *gpuCtx = gpuContextMgr->GetGpuContext(handle);
return static_cast<GpuContextSpecificNext *>(gpuCtx);
}
}
MOS_OS_ASSERTMESSAGE("GetGpuContext failed!");
return nullptr;
}
void MosInterface::SetPerfTag(MOS_STREAM_HANDLE streamState, uint32_t perfTag)
{
MOS_OS_FUNCTION_ENTER;
uint32_t componentTag;
MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState);
MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState->perStreamParameters);
auto osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
PERF_DATA *perfData = osParameters->pPerfData;
MOS_OS_CHK_NULL_NO_STATUS_RETURN(perfData);
switch (streamState->component)
{
case COMPONENT_VPreP:
case COMPONENT_VPCommon:
componentTag = PERFTAG_VPREP;
break;
case COMPONENT_LibVA:
componentTag = PERFTAG_LIBVA;
break;
case COMPONENT_CM:
componentTag = PERFTAG_CM;
break;
case COMPONENT_Decode:
componentTag = PERFTAG_DECODE;
break;
case COMPONENT_Encode:
componentTag = PERFTAG_ENCODE;
break;
default:
componentTag = 0xF000 & perfData->dmaBufID;
break;
}
perfData->dmaBufID = componentTag | (perfTag & 0x0fff);
return;
}
int32_t MosInterface::IsPerfTagSet(MOS_STREAM_HANDLE streamState)
{
uint32_t componentTag = 0;
int32_t ret = false;
MOS_OS_FUNCTION_ENTER;
if (streamState == nullptr ||
streamState->perStreamParameters == nullptr)
{
MOS_OS_ASSERTMESSAGE("streamState or perStreamParameters invalid nullptr");
return false;
}
auto osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
PERF_DATA *perfData = osParameters->pPerfData;
if (perfData == nullptr)
{
MOS_OS_ASSERTMESSAGE("perfData invalid nullptr");
return false;
}
componentTag = 0xF000 & perfData->dmaBufID;
switch (componentTag)
{
case PERFTAG_ENCODE:
case PERFTAG_DECODE:
ret = true;
break;
default:
ret = false;
break;
}
return ret;
}
void MosInterface::IncPerfFrameID(MOS_STREAM_HANDLE streamState)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState);
MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState->perStreamParameters);
auto osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
MOS_OS_CHK_NULL_NO_STATUS_RETURN(osParameters->pPerfData);
osParameters->pPerfData->frameID++;
return;
}
uint32_t MosInterface::GetPerfTag(MOS_STREAM_HANDLE streamState)
{
uint32_t perfTag;
MOS_OS_FUNCTION_ENTER;
if (streamState == nullptr ||
streamState->perStreamParameters == nullptr)
{
MOS_OS_ASSERTMESSAGE("streamState or perStreamParameters invalid nullptr");
return 0;
}
auto osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
perfTag = *(uint32_t *)(osParameters->pPerfData);
return perfTag;
}
void MosInterface::SetPerfHybridKernelID(
MOS_STREAM_HANDLE streamState,
uint32_t kernelID)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState);
MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState->perStreamParameters);
auto osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
PERF_DATA *perfData = osParameters->pPerfData;
MOS_OS_CHK_NULL_NO_STATUS_RETURN(perfData);
perfData->dmaBufID = (perfData->dmaBufID & 0xF0FF) | ((kernelID << 8) & 0x0F00);
return;
}
void MosInterface::ResetPerfBufferID(
MOS_STREAM_HANDLE streamState)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState);
MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState->perStreamParameters);
auto osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
MOS_OS_CHK_NULL_NO_STATUS_RETURN(osParameters->pPerfData);
osParameters->pPerfData->bufferID = 0;
return;
}
void MosInterface::IncPerfBufferID(
MOS_STREAM_HANDLE streamState)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState);
MOS_OS_CHK_NULL_NO_STATUS_RETURN(streamState->perStreamParameters);
auto osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
MOS_OS_CHK_NULL_NO_STATUS_RETURN(osParameters->pPerfData);
osParameters->pPerfData->bufferID++;
return;
}
int32_t MosInterface::IsGPUHung(
MOS_STREAM_HANDLE streamState)
{
uint32_t resetCount = 0;
uint32_t activeBatch = 0;
uint32_t pendingBatch = 0;
int32_t result = false;
int32_t ret = 0;
PMOS_CONTEXT osParameters = nullptr;
MOS_OS_FUNCTION_ENTER;
if (!streamState || !streamState->perStreamParameters)
{
MOS_OS_ASSERTMESSAGE("invalid streamstate");
return false;
}
osParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
ret = mos_get_reset_stats(osParameters->intel_context, &resetCount, &activeBatch, &pendingBatch);
if (ret)
{
MOS_OS_NORMALMESSAGE("mos_get_reset_stats return error(%d)\n", ret);
return false;
}
if (resetCount != streamState->gpuResetCount ||
activeBatch != streamState->gpuActiveBatch ||
pendingBatch != streamState->gpuPendingBatch)
{
streamState->gpuResetCount = resetCount;
streamState->gpuActiveBatch = activeBatch;
streamState->gpuPendingBatch = pendingBatch;
result = true;
}
else
{
result = false;
}
return result;
}
#if MOS_COMMAND_BUFFER_DUMP_SUPPORTED
MOS_STATUS MosInterface::DumpCommandBufferInit(
MOS_STREAM_HANDLE streamState)
{
char sFileName[MOS_MAX_HLT_FILENAME_LEN] = {0};
MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
MOS_USER_FEATURE_VALUE_DATA UserFeatureData = {0};
char *psFileNameAfterPrefix = nullptr;
size_t nSizeFileNamePrefix = 0;
MOS_OS_CHK_NULL_RETURN(streamState);
// Check if command buffer dump was enabled in user feature.
MOS_UserFeature_ReadValue_ID(
nullptr,
__MEDIA_USER_FEATURE_VALUE_DUMP_COMMAND_BUFFER_ENABLE_ID,
&UserFeatureData,
nullptr);
streamState->dumpCommandBuffer = (UserFeatureData.i32Data != 0);
streamState->dumpCommandBufferToFile = ((UserFeatureData.i32Data & 1) != 0);
streamState->dumpCommandBufferAsMessages = ((UserFeatureData.i32Data & 2) != 0);
if (streamState->dumpCommandBufferToFile)
{
// Create output directory.
eStatus = MosUtilDebug::MosLogFileNamePrefix(streamState->sDirName, nullptr);
if (eStatus != MOS_STATUS_SUCCESS)
{
MOS_OS_NORMALMESSAGE("Failed to create log file prefix. Status = %d", eStatus);
return eStatus;
}
memcpy(sFileName, streamState->sDirName, MOS_MAX_HLT_FILENAME_LEN);
nSizeFileNamePrefix = strnlen(sFileName, sizeof(sFileName));
MOS_SecureStringPrint(
sFileName + nSizeFileNamePrefix,
sizeof(sFileName) - nSizeFileNamePrefix,
sizeof(sFileName) - nSizeFileNamePrefix,
"%c%s",
MOS_DIR_SEPERATOR,
MOS_COMMAND_BUFFER_OUT_DIR);
eStatus = MosUtilities::MosCreateDirectory(sFileName);
if (eStatus != MOS_STATUS_SUCCESS)
{
MOS_OS_NORMALMESSAGE("Failed to create output directory. Status = %d", eStatus);
return eStatus;
}
}
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
#endif // MOS_COMMAND_BUFFER_DUMP_SUPPORTED
#if (_DEBUG || _RELEASE_INTERNAL)
uint32_t MosInterface::m_mosOsApiFailSimulateType = 0;
uint32_t MosInterface::m_mosOsApiFailSimulateMode = 0;
uint32_t MosInterface::m_mosOsApiFailSimulateFreq = 0;
uint32_t MosInterface::m_mosOsApiFailSimulateHint = 0;
uint32_t MosInterface::m_mosOsApiFailSimulateCounter = 0;
void MosInterface::MosInitOsApiFailSimulateFlag(MOS_CONTEXT_HANDLE mosCtx)
{
MOS_USER_FEATURE_VALUE_DATA userFeatureValueData;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
//default off for simulate random fail
m_mosOsApiFailSimulateType = OS_API_FAIL_TYPE_NONE;
m_mosOsApiFailSimulateMode = OS_API_FAIL_SIMULATE_MODE_DEFAULT;
m_mosOsApiFailSimulateFreq = 0;
m_mosOsApiFailSimulateHint = 0;
m_mosOsApiFailSimulateCounter = 0;
// Read Config : memory allocation failure simulate mode
MosUtilities::MosZeroMemory(&userFeatureValueData, sizeof(userFeatureValueData));
MosUtilities::MosUserFeatureReadValueID(
nullptr,
__MEDIA_USER_FEATURE_VALUE_OS_API_FAIL_SIMULATE_TYPE_ID,
&userFeatureValueData,
mosCtx);
if (userFeatureValueData.u32Data & OS_API_FAIL_TYPE_MAX)
{
m_mosOsApiFailSimulateType = userFeatureValueData.u32Data;
MOS_OS_NORMALMESSAGE("Init MosSimulateOsApiFailSimulateType as %d \n ", m_mosOsApiFailSimulateType);
}
else
{
m_mosOsApiFailSimulateType = OS_API_FAIL_TYPE_NONE;
MOS_OS_NORMALMESSAGE("Invalid OS API Fail Simulate Type from config: %d \n ", userFeatureValueData.u32Data);
}
// Read Config : memory allocation failure simulate mode
MosUtilities::MosZeroMemory(&userFeatureValueData, sizeof(userFeatureValueData));
MosUtilities::MosUserFeatureReadValueID(
nullptr,
__MEDIA_USER_FEATURE_VALUE_OS_API_FAIL_SIMULATE_MODE_ID,
&userFeatureValueData,
mosCtx);
if ((userFeatureValueData.u32Data == OS_API_FAIL_SIMULATE_MODE_DEFAULT) ||
(userFeatureValueData.u32Data == OS_API_FAIL_SIMULATE_MODE_RANDOM) ||
(userFeatureValueData.u32Data == OS_API_FAIL_SIMULATE_MODE_TRAVERSE))
{
m_mosOsApiFailSimulateMode = userFeatureValueData.u32Data;
MOS_OS_NORMALMESSAGE("Init MosSimulateOsApiFailSimulateMode as %d \n ", m_mosOsApiFailSimulateMode);
}
else
{
m_mosOsApiFailSimulateMode = OS_API_FAIL_SIMULATE_MODE_DEFAULT;
MOS_OS_NORMALMESSAGE("Invalid OS API Fail Simulate Mode from config: %d \n ", userFeatureValueData.u32Data);
}
// Read Config : memory allocation failure simulate frequence
MosUtilities::MosZeroMemory(&userFeatureValueData, sizeof(userFeatureValueData));
MosUtilities::MosUserFeatureReadValueID(
nullptr,
__MEDIA_USER_FEATURE_VALUE_OS_API_FAIL_SIMULATE_FREQ_ID,
&userFeatureValueData,
mosCtx);
if ((userFeatureValueData.u32Data >= MIN_OS_API_FAIL_FREQ) &&
(userFeatureValueData.u32Data <= MAX_OS_API_FAIL_FREQ))
{
m_mosOsApiFailSimulateFreq = userFeatureValueData.u32Data;
MOS_OS_NORMALMESSAGE("Init m_MosSimulateRandomOsApiFailFreq as %d \n ", m_mosOsApiFailSimulateFreq);
if (m_mosOsApiFailSimulateMode == OS_API_FAIL_SIMULATE_MODE_RANDOM)
{
srand((unsigned int)time(nullptr));
}
}
else
{
m_mosOsApiFailSimulateFreq = 0;
MOS_OS_NORMALMESSAGE("Invalid OS API Fail Simulate Freq from config: %d \n ", userFeatureValueData.u32Data);
}
// Read Config : memory allocation failure simulate counter
MosUtilities::MosZeroMemory(&userFeatureValueData, sizeof(userFeatureValueData));
MosUtilities::MosUserFeatureReadValueID(
nullptr,
__MEDIA_USER_FEATURE_VALUE_OS_API_FAIL_SIMULATE_HINT_ID,
&userFeatureValueData,
mosCtx);
if (userFeatureValueData.u32Data <= m_mosOsApiFailSimulateFreq)
{
m_mosOsApiFailSimulateHint = userFeatureValueData.u32Data;
MOS_OS_NORMALMESSAGE("Init m_MosOsApiFailSimulateHint as %d \n ", m_mosOsApiFailSimulateHint);
}
else
{
m_mosOsApiFailSimulateHint = m_mosOsApiFailSimulateFreq;
MOS_OS_NORMALMESSAGE("Set m_mosOsApiFailSimulateHint as %d since INVALID CONFIG %d \n ", m_mosOsApiFailSimulateHint, userFeatureValueData.u32Data);
}
}
void MosInterface::MosDeinitOsApiFailSimulateFlag()
{
//default off for simulate fail
m_mosOsApiFailSimulateType = OS_API_FAIL_TYPE_NONE;
m_mosOsApiFailSimulateMode = OS_API_FAIL_SIMULATE_MODE_DEFAULT;
m_mosOsApiFailSimulateFreq = 0;
m_mosOsApiFailSimulateHint = 0;
m_mosOsApiFailSimulateCounter = 0;
}
bool MosInterface::MosSimulateOsApiFail(
OS_API_FAIL_TYPE type,
const char *functionName,
const char *filename,
int32_t line)
{
bool bSimulateOsApiFail = false;
if (!MosOsApiFailSimulationEnabled(type))
{
return false;
}
if (m_mosOsApiFailSimulateMode == OS_API_FAIL_SIMULATE_MODE_RANDOM)
{
int32_t Rn = rand();
m_mosOsApiFailSimulateCounter++;
if (Rn % m_mosOsApiFailSimulateFreq == 1)
{
bSimulateOsApiFail = true;
MOS_DEBUGMESSAGE(MOS_MESSAGE_LVL_CRITICAL, MOS_COMPONENT_OS, MOS_SUBCOMP_SELF,
"Simulated OS API(Type %d) Fail (Rn=%d, SimulateAllocCounter=%d) for: functionName: %s, filename: %s, line: %d\n",
m_mosOsApiFailSimulateType, Rn, m_mosOsApiFailSimulateCounter, functionName, filename, line);
}
else
{
bSimulateOsApiFail = false;
}
}
else if (m_mosOsApiFailSimulateMode == OS_API_FAIL_SIMULATE_MODE_TRAVERSE)
{
if (m_mosOsApiFailSimulateCounter++ == m_mosOsApiFailSimulateHint)
{
MOS_DEBUGMESSAGE(MOS_MESSAGE_LVL_CRITICAL, MOS_COMPONENT_OS, MOS_SUBCOMP_SELF,
"Simulated OS API(Type %d) Fail (hint=%d) for: functionName: %s, filename: %s, line: %d\n",
m_mosOsApiFailSimulateType, m_mosOsApiFailSimulateHint, functionName, filename, line);
bSimulateOsApiFail = true;
}
else
{
bSimulateOsApiFail = false;
}
}
else
{
//MOS_OS_NORMALMESSAGE("Invalid m_mosOsApiFailSimulateMode: %d \n ", m_mosOsApiFailSimulateMode);
bSimulateOsApiFail = false;
}
return bSimulateOsApiFail;
}
#endif // #if (_DEBUG || _RELEASE_INTERNAL)