| /* |
| * Copyright (c) 2009-2020, 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_os_specific.h |
| //! \brief Common interface and structure used in MOS LINUX OS |
| //! |
| |
| #ifndef __MOS_OS_SPECIFIC_H__ |
| #define __MOS_OS_SPECIFIC_H__ |
| |
| #include "media_skuwa_specific.h" |
| #include "GmmLib.h" |
| #include "mos_resource_defs.h" |
| #include "mos_defs.h" |
| #include "mos_os_cp_interface_specific.h" |
| #ifdef ANDROID |
| #include <utils/Log.h> |
| #endif |
| #include "i915_drm.h" |
| #include "mos_bufmgr.h" |
| #if !defined(USE_MAGMA) |
| #include "xf86drm.h" |
| #endif |
| |
| #include <vector> |
| |
| typedef unsigned int MOS_OS_FORMAT; |
| |
| class GraphicsResource; |
| class GraphicsResourceNext; |
| class AuxTableMgr; |
| class MosOcaInterface; |
| class GraphicsResourceNext; |
| |
| //////////////////////////////////////////////////////////////////// |
| |
| typedef void* HINSTANCE; |
| |
| #define MAKEFOURCC(ch0, ch1, ch2, ch3) \ |
| ((uint32_t)(uint8_t)(ch0) | ((uint32_t)(uint8_t)(ch1) << 8) | \ |
| ((uint32_t)(uint8_t)(ch2) << 16) | ((uint32_t)(uint8_t)(ch3) << 24 )) |
| |
| #define GMM_LIBVA_LINUX 3 |
| |
| enum DdiSurfaceFormat |
| { |
| DDI_FORMAT_UNKNOWN = 0, |
| DDI_FORMAT_A8B8G8R8 = 32, |
| DDI_FORMAT_X8B8G8R8 = 33, |
| DDI_FORMAT_A8R8G8B8 = 21, |
| DDI_FORMAT_X8R8G8B8 = 22, |
| DDI_FORMAT_R5G6B5 = 23, |
| DDI_FORMAT_YUY2 = MAKEFOURCC('Y', 'U', 'Y', '2'), |
| DDI_FORMAT_P8 = 41, |
| DDI_FORMAT_A8P8 = 40, |
| DDI_FORMAT_A8 = 28, |
| DDI_FORMAT_L8 = 50, |
| DDI_FORMAT_L16 = 81, |
| DDI_FORMAT_A4L4 = 52, |
| DDI_FORMAT_A8L8 = 51, |
| DDI_FORMAT_R32F = 114, |
| DDI_FORMAT_V8U8 = 60, |
| DDI_FORMAT_UYVY = MAKEFOURCC('U', 'Y', 'V', 'Y'), |
| DDI_FORMAT_NV12 = MAKEFOURCC('N', 'V', '1', '2'), |
| DDI_FORMAT_A16B16G16R16 = 36, |
| DDI_FORMAT_R32G32B32A32F = 115, |
| }; |
| |
| #define INDIRECT_HEAP_SIZE_UNITS (1024) |
| |
| /* copy from intcver.h */ |
| #ifndef BUILD_NUMBER |
| #define BUILD_NUMBER 9034 |
| #endif |
| |
| #define COMMAND_BUFFER_RESERVED_SPACE 0x80 |
| |
| #define RtlEqualMemory(Destination,Source,Length) (!memcmp((Destination),(Source),(Length))) |
| |
| //////////////////////////////////////////////////////////////////// |
| |
| //! |
| //! \brief Definitions specific to Linux |
| //! |
| #define COMMAND_BUFFER_SIZE 32768 |
| |
| #define MAX_CMD_BUF_NUM 30 |
| |
| #define MOS_LOCKFLAG_WRITEONLY OSKM_LOCKFLAG_WRITEONLY |
| #define MOS_LOCKFLAG_READONLY OSKM_LOCKFLAG_READONLY |
| #define MOS_LOCKFLAG_NOOVERWRITE OSKM_LOCKFLAG_NOOVERWRITE |
| #define MOS_LOCKFLAG_NO_SWIZZLE OSKM_LOCKFLAG_NO_SWIZZLE |
| |
| #define MOS_DIR_SEPERATOR '/' |
| |
| #define MOS_INVALID_ALLOC_INDEX -1 |
| #define MOS_MAX_REGS 128 //32 |
| #ifdef ANDROID |
| #define MOS_STATUS_REPORT_DEFAULT 0 |
| #else |
| #define MOS_STATUS_REPORT_DEFAULT 1 |
| #endif |
| |
| #define OSKM_LOCKFLAG_WRITEONLY 0x00000001 |
| #define OSKM_LOCKFLAG_READONLY 0x00000002 |
| #define OSKM_LOCKFLAG_NOOVERWRITE 0x00000004 |
| #define OSKM_LOCKFLAG_NO_SWIZZLE 0x00000008 |
| |
| // should be defined in libdrm, this is a temporary solution to pass QuickBuild |
| #define I915_EXEC_VEBOX (4<<0) |
| #define I915_EXEC_VCS2 (7<<0) |
| |
| // I915_EXEC_BSD_* -- Attempt to provide backwards and forwards |
| // compatibility with versions of include/drm/i915_drm.h that do not |
| // have these definitions or that have them with the same values but |
| // different textual representations. This will help avoid compiler |
| // warnings about macro redefinitions. |
| |
| #if !defined I915_EXEC_BSD_MASK |
| #define I915_EXEC_BSD_MASK (3<<13) |
| #endif |
| #if !defined I915_EXEC_BSD_DEFAULT |
| #define I915_EXEC_BSD_DEFAULT (0<<13) /* default ping-pong mode */ |
| #endif |
| #if !defined I915_EXEC_BSD_RING1 |
| #define I915_EXEC_BSD_RING1 (1<<13) |
| #endif |
| #if !defined I915_EXEC_BSD_RING2 |
| #define I915_EXEC_BSD_RING2 (2<<13) |
| #endif |
| |
| #define I915_PARAM_HAS_BSD2 31 |
| #define I915_EXEC_ENABLE_WATCHDOG_LINUX (1<<18) |
| |
| //! |
| //! \brief Forward declarations |
| //! |
| typedef struct _MOS_SPECIFIC_RESOURCE MOS_RESOURCE, *PMOS_RESOURCE; |
| typedef struct _MOS_INTERFACE *PMOS_INTERFACE; |
| typedef struct _MOS_COMMAND_BUFFER *PMOS_COMMAND_BUFFER; |
| typedef struct _MOS_LOCK_PARAMS *PMOS_LOCK_PARAMS; |
| |
| //! |
| //! \brief enum to video device operations |
| //! |
| typedef enum _MOS_MEDIA_OPERATION |
| { |
| MOS_MEDIA_OPERATION_NONE = 0, |
| MOS_MEDIA_OPERATION_DECODE, |
| MOS_MEDIA_OPERATION_ENCODE, |
| MOS_MEDIA_OPERATION_MAX |
| } MOS_MEDIA_OPERATION, *PMOS_MEDIA_OPERATION; |
| |
| //! |
| //! \brief ENum to GPU nodes |
| //! |
| typedef enum _MOS_GPU_NODE |
| { |
| MOS_GPU_NODE_3D = I915_EXEC_RENDER, |
| MOS_GPU_NODE_COMPUTE = (5<<0), //To change to compute CS later when linux define the name |
| MOS_GPU_NODE_VE = I915_EXEC_VEBOX, |
| MOS_GPU_NODE_VIDEO = I915_EXEC_BSD, |
| MOS_GPU_NODE_VIDEO2 = I915_EXEC_VCS2, |
| MOS_GPU_NODE_BLT = I915_EXEC_BLT, |
| MOS_GPU_NODE_MAX = 7,//GFX_MAX(I915_EXEC_RENDER, I915_EXEC_VEBOX, I915_EXEC_BSD, I915_EXEC_VCS2, I915_EXEC_BLT) + 1 |
| } MOS_GPU_NODE, *PMOS_GPU_NODE; |
| |
| //! |
| //! \brief Inline function to get GPU node |
| //! |
| static inline MOS_GPU_NODE OSKMGetGpuNode(MOS_GPU_CONTEXT uiGpuContext) |
| { |
| switch (uiGpuContext) |
| { |
| case MOS_GPU_CONTEXT_RENDER: |
| case MOS_GPU_CONTEXT_RENDER2: |
| case MOS_GPU_CONTEXT_RENDER3: |
| case MOS_GPU_CONTEXT_RENDER4: |
| case MOS_GPU_CONTEXT_COMPUTE: //change this context mapping to Compute Node instead of 3D node after the node name is defined in linux. |
| return MOS_GPU_NODE_3D; |
| break; |
| case MOS_GPU_CONTEXT_VEBOX: |
| return MOS_GPU_NODE_VE; |
| break; |
| case MOS_GPU_CONTEXT_VIDEO: |
| case MOS_GPU_CONTEXT_VIDEO2: |
| case MOS_GPU_CONTEXT_VIDEO3: |
| case MOS_GPU_CONTEXT_VIDEO4: |
| case MOS_GPU_CONTEXT_VIDEO5: |
| case MOS_GPU_CONTEXT_VIDEO6: |
| case MOS_GPU_CONTEXT_VIDEO7: |
| return MOS_GPU_NODE_VIDEO; |
| break; |
| case MOS_GPU_CONTEXT_VDBOX2_VIDEO: |
| case MOS_GPU_CONTEXT_VDBOX2_VIDEO2: |
| case MOS_GPU_CONTEXT_VDBOX2_VIDEO3: |
| return MOS_GPU_NODE_VIDEO2; |
| break; |
| case MOS_GPU_CONTEXT_BLT: |
| return MOS_GPU_NODE_BLT; |
| break; |
| default: |
| return MOS_GPU_NODE_MAX ; |
| break; |
| } |
| } |
| |
| //! |
| //! \brief enum to Intel bo map operations |
| //! |
| typedef enum _MOS_MMAP_OPERATION |
| { |
| MOS_MMAP_OPERATION_NONE = 0, |
| MOS_MMAP_OPERATION_MMAP, |
| MOS_MMAP_OPERATION_MMAP_GTT, |
| MOS_MMAP_OPERATION_MMAP_WC |
| } MOS_MMAP_OPERATION, *PMOS_MMAP_OPERATION; |
| |
| //! |
| //! \brief Structure to Linux resource |
| //! |
| struct _MOS_SPECIFIC_RESOURCE |
| { |
| int32_t iWidth; |
| int32_t iHeight; |
| int32_t iSize; |
| int32_t iPitch; |
| int32_t iDepth; //!< for 3D surface |
| MOS_FORMAT Format; |
| int32_t iCount; |
| int32_t iAllocationIndex[MOS_GPU_CONTEXT_MAX]; |
| uint32_t dwGfxAddress; |
| uint8_t *pData; |
| const char *bufname; |
| uint32_t isTiled; |
| MOS_TILE_TYPE TileType; |
| uint32_t bMapped; |
| MOS_LINUX_BO *bo; |
| uint32_t name; |
| GMM_RESOURCE_INFO *pGmmResInfo; //!< GMM resource descriptor |
| MOS_MMAP_OPERATION MmapOperation; |
| uint8_t *pSystemShadow; |
| MOS_PLANE_OFFSET YPlaneOffset; //!< Y surface plane offset |
| MOS_PLANE_OFFSET UPlaneOffset; //!< U surface plane offset |
| MOS_PLANE_OFFSET VPlaneOffset; //!< V surface plane offset |
| |
| //!< to sync render target for multi-threading decoding mode |
| struct |
| { |
| int32_t bSemInitialized; |
| PMOS_SEMAPHORE *ppCurrentFrameSemaphore; //!< Semaphore queue for hybrid decoding multi-threading case |
| PMOS_SEMAPHORE *ppReferenceFrameSemaphore; //!< Semaphore queue for hybrid decoding multi-threading case; post when a surface is not used as reference frame |
| }; |
| |
| #if MOS_MEDIASOLO_SUPPORTED |
| //!< these fields are only used while MediaSolo is enabled(bSoloInUse of OS_Interface is true). |
| uint32_t dwOffset; |
| FILE* pFile; |
| char *pcFilePath; |
| int32_t bManualSwizzlingInUse; |
| // used for AubCapture mode |
| int32_t bAubGttUpdate; |
| int32_t bAubMemUpdate; |
| int32_t bInterestedRes; |
| int32_t bPermaLocked; |
| #endif // MOS_MEDIASOLO_SUPPORTED |
| |
| // This is used by MDF when a wrapper/virtual MOS Resource is used to set surface state for a given VA, not necessary from start, in an actual MOS resource |
| uint64_t user_provided_va; |
| // for MODS Wrapper |
| GraphicsResource* pGfxResource; |
| GraphicsResourceNext* pGfxResourceNext; |
| bool bConvertedFromDDIResource; |
| uint32_t dwResourceOffset; |
| bool bExternalSurface; //!< indicate the surface not allocated by media |
| |
| // Tile switch |
| MOS_TILE_MODE_GMM TileModeGMM; |
| bool bGMMTileEnabled; |
| }; |
| |
| //! |
| //! \brief Structure to MOS_SURFACE |
| //! |
| struct MOS_SURFACE |
| { |
| MOS_RESOURCE OsResource; //Surface Resource |
| |
| uint32_t dwArraySlice; //!< [in] |
| uint32_t dwMipSlice; //!< [in] |
| MOS_S3D_CHANNEL S3dChannel; //!< [in] |
| |
| MOS_GFXRES_TYPE Type; //!< [out] Basic resource geometry |
| int32_t bOverlay; |
| int32_t bFlipChain; |
| |
| uint32_t dwWidth; //!< [out] Type == 2D || VOLUME, width in pixels. |
| uint32_t dwHeight; //!< [out] Type == 2D || VOLUME, height in rows. Type == BUFFER, n/a |
| uint32_t dwSize; //!< [out] Type == 2D || VOLUME, the size of surface |
| uint32_t dwDepth; //!< [out] 0: Implies 2D resource. >=1: volume resource |
| uint32_t dwArraySize; //!< [out] 0,1: 1 element. >1: N elements |
| uint32_t dwLockPitch; //!< [out] pitch in bytes used for locking |
| uint32_t dwPitch; //!< [out] < RenderPitch > pitch in bytes used for programming HW |
| uint32_t dwSlicePitch; //!< [out] Type == VOLUME, byte offset to next slice. Type != VOLUME, n/a |
| uint32_t dwQPitch; //!< [out] QPitch - distance in rows between R-Planes used for programming HW |
| MOS_TILE_TYPE TileType; //!< [out] Defines the layout of a physical page. Optimal choice depends on usage model. |
| MOS_FORMAT Format; //!< [out] Pixel format |
| int32_t bArraySpacing; //!< [out] Array spacing |
| int32_t bCompressible; //!< [out] Memory compression |
| |
| uint32_t dwOffset; // Surface Offset (Y/Base) |
| MOS_PLANE_OFFSET YPlaneOffset; // Y surface plane offset |
| MOS_PLANE_OFFSET UPlaneOffset; // U surface plane offset |
| MOS_PLANE_OFFSET VPlaneOffset; // V surface plane |
| |
| union |
| { |
| struct |
| { |
| MOS_RESOURCE_OFFSETS Y; |
| MOS_RESOURCE_OFFSETS U; |
| MOS_RESOURCE_OFFSETS V; |
| } YUV; //!< [out] Valid for YUV & planar RGB formats. Invalid for RGB formats. |
| |
| MOS_RESOURCE_OFFSETS RGB; //!< [out] Valid non planar RGB formats. Invalid for YUV and planar RGB formats. |
| } RenderOffset; //!< [out] Offsets request by input parameters. Used to program HW. |
| |
| union |
| { |
| struct |
| { |
| uint32_t Y; |
| uint32_t U; |
| uint32_t V; |
| } YUV; //!< [out] Valid for YUV & planar RGB formats. Invalid for RGB formats. |
| |
| uint32_t RGB; //!< [out] Valid non planar RGB formats. Invalid for YUV and planar RGB formats. |
| } LockOffset; //!< [out] Offset in bytes used for locking |
| |
| // Surface compression mode, enable flags |
| int32_t bIsCompressed; //!< [out] Memory compression flag |
| MOS_RESOURCE_MMC_MODE CompressionMode; //!< [out] Memory compression mode |
| uint32_t CompressionFormat; //!< [out] Memory compression format |
| // deprecated: not to use MmcState |
| MOS_MEMCOMP_STATE MmcState; // Memory compression state |
| // Tile Switch |
| MOS_TILE_MODE_GMM TileModeGMM; //!< [out] Transparent GMM Tiletype specifying in hwcmd finally |
| bool bGMMTileEnabled; //!< [out] GMM defined tile mode flag |
| uint32_t YoffsetForUplane; //!< [out] Y offset from U plane to Y plane. |
| uint32_t YoffsetForVplane; //!< [out] Y offset from V plane to Y plane. |
| }; |
| typedef MOS_SURFACE *PMOS_SURFACE; |
| |
| //! |
| //! \brief Structure to MOS_BUFFER |
| //! |
| struct MOS_BUFFER |
| { |
| MOS_RESOURCE OsResource; //!< Buffer resource |
| uint32_t size; //!< Buffer size |
| const char* name; //!< Buffer name |
| bool initOnAllocate; //!< Flag to indicate whether initialize when allocate |
| uint8_t initValue; //!< Initialize value when initOnAllocate is set |
| bool bPersistent; //!< Persistent flag |
| }; |
| typedef MOS_BUFFER *PMOS_BUFFER; |
| |
| //! |
| //! \brief Structure to patch location list |
| //! |
| typedef struct _PATCHLOCATIONLIST |
| { |
| uint32_t AllocationIndex; |
| uint32_t AllocationOffset; |
| uint32_t PatchOffset; |
| uint32_t cpCmdProps; |
| int32_t uiRelocFlag; |
| uint32_t uiWriteOperation; |
| MOS_LINUX_BO *cmdBo; |
| } PATCHLOCATIONLIST, *PPATCHLOCATIONLIST; |
| |
| //#define PATCHLOCATIONLIST_SIZE 25 |
| #define CODECHAL_MAX_REGS 256 |
| #define PATCHLOCATIONLIST_SIZE CODECHAL_MAX_REGS |
| |
| //! |
| //! \brief Structure to Allocation List |
| //! |
| typedef struct _ALLOCATION_LIST |
| { |
| HANDLE hAllocation; |
| uint32_t WriteOperation; |
| } ALLOCATION_LIST, *PALLOCATION_LIST; |
| |
| //#define ALLOCATIONLIST_SIZE MOS_MAX_REGS |
| #define ALLOCATIONLIST_SIZE CODECHAL_MAX_REGS //!< use the large value |
| |
| //! |
| //! \brief Structure to command buffer |
| //! |
| typedef struct _COMMAND_BUFFER |
| { |
| // Double linked list |
| struct _COMMAND_BUFFER *pNext; |
| struct _COMMAND_BUFFER *pPrev; |
| |
| int64_t *pSyncTag; |
| int64_t qSyncTag; |
| |
| // Status |
| int32_t bActive; //!< Active / Inactive flag |
| int32_t bRunning; //!< CB is running in Gfx Device |
| LARGE_INTEGER TimeStart; //!< Start timestamp |
| LARGE_INTEGER TimeEnd; //!< End timestamp |
| |
| // Buffer information |
| uint8_t *pCmdBase; //!< Pointer to buffer data |
| uint8_t *pCmdCurrent; //!< Current pointer |
| int32_t iSize; //!< Buffer Size |
| int32_t iCurrent; //!< Current offset |
| int32_t iRemaining; //!< Remaining |
| } COMMAND_BUFFER, *PCOMMAND_BUFFER; |
| |
| typedef struct _MOS_GPU_STATUS_DATA |
| { |
| uint32_t GPUTag; |
| uint32_t ReservedForGPUTag; //!< Reserved for gpu tag uint64_t write back by gpu but we only use the low uint32_t above. |
| uint32_t Reserved[6]; //!< Padding to 32 byte-aligned for future use. |
| } MOS_GPU_STATUS_DATA; |
| |
| //! |
| //! \brief Structure to Gpu context |
| //! |
| typedef struct _CODECHAL_OS_GPU_CONTEXT |
| { |
| volatile int32_t bCBFlushed; //!< if CB not flushed, re-use |
| PMOS_COMMAND_BUFFER pCB; |
| uint32_t uiCommandBufferSize; |
| |
| // Allcoation List |
| ALLOCATION_LIST *pAllocationList; |
| uint32_t uiNumAllocations; |
| uint32_t uiMaxPatchLocationsize; |
| |
| // Patch List |
| PATCHLOCATIONLIST *pPatchLocationList; |
| uint32_t uiCurrentNumPatchLocations; |
| uint32_t uiMaxNumAllocations; |
| |
| // OS command buffer |
| PCOMMAND_BUFFER pStartCB; |
| PCOMMAND_BUFFER pCurrentCB; |
| |
| // Resource registrations |
| uint32_t uiResCount; //!< # of resources registered |
| int32_t iResIndex[CODECHAL_MAX_REGS]; //!< Resource indices |
| PMOS_RESOURCE pResources; //!< Pointer to resources list |
| int32_t *pbWriteMode; //!< Write mode |
| |
| // GPU Status |
| uint32_t uiGPUStatusTag; |
| } MOS_OS_GPU_CONTEXT, *PMOS_OS_GPU_CONTEXT; |
| |
| //! |
| //! \brief Structure to buffer pool |
| //! |
| typedef struct _CMD_BUFFER_BO_POOL |
| { |
| int32_t iFetch; |
| MOS_LINUX_BO *pCmd_bo[MAX_CMD_BUF_NUM]; |
| }CMD_BUFFER_BO_POOL; |
| |
| struct MOS_CONTEXT_OFFSET |
| { |
| MOS_LINUX_CONTEXT *intel_context; |
| MOS_LINUX_BO *target_bo; |
| uint64_t offset64; |
| }; |
| |
| // APO related |
| #define FUTURE_PLATFORM_MOS_APO 1234 |
| bool SetupApoMosSwitch(int32_t fd); |
| |
| enum OS_SPECIFIC_RESOURCE_TYPE |
| { |
| OS_SPECIFIC_RESOURCE_INVALID = 0, |
| OS_SPECIFIC_RESOURCE_SURFACE = 1, |
| OS_SPECIFIC_RESOURCE_BUFFER = 2, |
| OS_SPECIFIC_RESOURCE_MAX |
| }; |
| |
| class OsContextNext; |
| typedef OsContextNext OsDeviceContext; |
| typedef OsDeviceContext *MOS_DEVICE_HANDLE; |
| |
| typedef struct _MOS_OS_CONTEXT MOS_CONTEXT, *PMOS_CONTEXT, MOS_OS_CONTEXT, *PMOS_OS_CONTEXT, MOS_DRIVER_CONTEXT,*PMOS_DRIVER_CONTEXT; |
| //! |
| //! \brief Structure to OS context |
| //! |
| struct _MOS_OS_CONTEXT |
| { |
| // Context must be freed by os emul layer |
| int32_t bFreeContext; |
| |
| uint32_t uIndirectStateSize; |
| |
| MOS_OS_GPU_CONTEXT OsGpuContext[MOS_GPU_CONTEXT_MAX]; |
| |
| // Buffer rendering |
| LARGE_INTEGER Frequency; //!< Frequency |
| LARGE_INTEGER LastCB; //!< End time for last CB |
| |
| CMD_BUFFER_BO_POOL CmdBufferPool; |
| |
| // Emulated platform, sku, wa tables |
| PLATFORM platform; |
| MEDIA_FEATURE_TABLE SkuTable; |
| MEDIA_WA_TABLE WaTable; |
| MEDIA_SYSTEM_INFO gtSystemInfo; |
| |
| // Controlled OS resources (for analysis) |
| MOS_BUFMGR *bufmgr; |
| MOS_LINUX_CONTEXT *intel_context; |
| int32_t submit_fence; |
| uint32_t uEnablePerfTag; //!< 0: Do not pass PerfTag to KMD, perf data collection disabled; |
| //!< 1: Pass PerfTag to MVP driver, perf data collection enabled; |
| //!< 2: Pass PerfTag to DAPC driver, perf data collection enabled; |
| int32_t bDisableKmdWatchdog; //!< 0: Do not disable kmd watchdog, that is to say, pass I915_EXEC_ENABLE_WATCHDOG flag to KMD; |
| //!< 1: Disable kmd watchdog, that is to say, DO NOT pass I915_EXEC_ENABLE_WATCHDOG flag to KMD; |
| PERF_DATA *pPerfData; //!< Add Perf Data for KMD to capture perf tag |
| |
| int32_t bHybridDecoderRunningFlag; //!< Flag to indicate if hybrid decoder is running |
| |
| int iDeviceId; |
| int wRevision; |
| int32_t bIsAtomSOC; |
| int fd; //!< handle for /dev/dri/card0 |
| |
| int32_t bUse64BitRelocs; |
| bool bUseSwSwizzling; |
| bool bTileYFlag; |
| |
| void **ppMediaMemDecompState; //!<Media memory decompression data structure |
| void **ppMediaCopyState; //!<Media memory copy data structure |
| |
| // For modulized GPU context |
| void* m_gpuContextMgr; |
| void* m_cmdBufMgr; |
| MOS_DEVICE_HANDLE m_osDeviceContext = nullptr; |
| |
| //For 2VD box |
| int32_t bKMDHasVCS2; |
| bool bPerCmdBufferBalancing; |
| int32_t semid; |
| int32_t shmid; |
| void *pShm; |
| |
| uint32_t *pTranscryptedKernels; //!< The cached version for current set of transcrypted and authenticated kernels |
| uint32_t uiTranscryptedKernelsSize; //!< Size in bytes of the cached version of transcrypted and authenticated kernels |
| void *pLibdrmHandle; |
| |
| GMM_CLIENT_CONTEXT *pGmmClientContext; //UMD specific ClientContext object in GMM |
| GmmExportEntries GmmFuncs; |
| AuxTableMgr *m_auxTableMgr; |
| |
| // GPU Status Buffer |
| PMOS_RESOURCE pGPUStatusBuffer; |
| |
| std::vector< struct MOS_CONTEXT_OFFSET> contextOffsetList; |
| |
| bool bSimIsActive; //!< To indicate if simulation environment |
| bool m_apoMosEnabled; //!< apo mos or not |
| |
| // Media memory decompression function |
| void (* pfnMemoryDecompress)( |
| PMOS_CONTEXT pOsContext, |
| PMOS_RESOURCE pOsResource); |
| |
| //! |
| //! \brief the function ptr for surface copy function |
| //! |
| void (* pfnMediaMemoryCopy )( |
| PMOS_CONTEXT pOsContext, |
| PMOS_RESOURCE pInputResource, |
| PMOS_RESOURCE pOutputResource, |
| bool bOutputCompressed); |
| |
| //! |
| //! \brief the function ptr for Media Memory 2D copy function |
| //! |
| void (* pfnMediaMemoryCopy2D)( |
| PMOS_CONTEXT pOsContext, |
| PMOS_RESOURCE pInputResource, |
| PMOS_RESOURCE pOutputResource, |
| uint32_t copyWidth, |
| uint32_t copyHeight, |
| uint32_t copyInputOffset, |
| uint32_t copyOutputOffset, |
| uint32_t bpp, |
| bool bOutputCompressed); |
| |
| //! |
| //! \brief the function ptr for Media copy function |
| //! |
| |
| // Os Context interface functions |
| void (* pfnDestroy)( |
| struct _MOS_OS_CONTEXT *pOsContext, |
| int32_t MODSEnabled, |
| int32_t MODSForGpuContext); |
| |
| int32_t (* pfnRefresh)( |
| struct _MOS_OS_CONTEXT *pOsContext); |
| |
| int32_t (* pfnGetCommandBuffer)( |
| struct _MOS_OS_CONTEXT *pOsContext, |
| PMOS_COMMAND_BUFFER pCmdBuffer, |
| int32_t iSize); |
| |
| void (* pfnReturnCommandBuffer)( |
| struct _MOS_OS_CONTEXT *pOsContext, |
| MOS_GPU_CONTEXT GpuContext, |
| PMOS_COMMAND_BUFFER pCmdBuffer); |
| |
| int32_t (* pfnFlushCommandBuffer)( |
| struct _MOS_OS_CONTEXT *pOsContext, |
| MOS_GPU_CONTEXT GpuContext); |
| |
| MOS_STATUS (* pfnInsertCmdBufferToPool)( |
| struct _MOS_OS_CONTEXT *pOsContext, |
| PMOS_COMMAND_BUFFER pCmdBuffer); |
| |
| MOS_STATUS (* pfnWaitAndReleaseCmdBuffer)( |
| struct _MOS_OS_CONTEXT *pOsContext, |
| int32_t index); |
| |
| uint32_t (* GetDmaBufID ) ( |
| struct _MOS_OS_CONTEXT *pOsContext); |
| |
| void (* SetDmaBufID ) ( |
| struct _MOS_OS_CONTEXT *pOsContext, |
| uint32_t dwDmaBufID); |
| |
| void (* SetPerfHybridKernelID ) ( |
| struct _MOS_OS_CONTEXT *pOsContext, |
| uint32_t KernelID); |
| |
| uint32_t (* pfnGetGpuCtxBufferTag)( |
| PMOS_CONTEXT pOsContext, |
| MOS_GPU_CONTEXT GpuContext); |
| |
| void (* pfnIncGpuCtxBufferTag)( |
| PMOS_CONTEXT pOsContext, |
| MOS_GPU_CONTEXT GpuContext); |
| |
| uint32_t (* GetGPUTag)( |
| PMOS_INTERFACE pOsInterface, |
| MOS_GPU_CONTEXT GpuContext); |
| |
| GMM_CLIENT_CONTEXT* (* GetGmmClientContext)( |
| PMOS_CONTEXT pOsContext); |
| |
| MosOcaInterface* (*GetOcaInterface)(); |
| }; |
| |
| //! |
| //! \brief Structure to VDBOX Workload Type |
| //! |
| typedef struct _VDBOX_WORKLOAD |
| { |
| uint32_t uiVDBoxCount[2]; // VDBox workloads |
| uint32_t uiRingIndex; // ping-pong when vdbox1 count equals vdbox2 count |
| }VDBOX_WORKLOAD, *PVDBOX_WORKLOAD; |
| |
| //! |
| //! \brief Structure to Android Resource Type |
| //! |
| |
| //! |
| //! \brief Structure to Android Resource structure |
| //! |
| typedef struct _MOS_OS_ALLOCATION |
| { |
| PMOS_RESOURCE pOsResource; //!< Resource Info |
| int32_t bWriteMode; //!< Read/Write Mode |
| } MOS_OS_ALLOCATION, *PMOS_OS_ALLOCATION; |
| |
| //! |
| //! \brief Structure to Buffer structure |
| //! |
| typedef struct _MOS_SPECIFIC_BUFFER |
| { |
| uint32_t dwHandle; //!< Buffer Handle |
| int32_t iAllocationIndex; //!< Allocation Index |
| } MOS_SPECIFIC_BUFFER_ANDROID, *PMOS_SPECIFIC_BUFFER; |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| //! |
| //! \brief Check if OS resource is nullptr |
| //! \details Check if OS resource is nullptr |
| //! \param PMOS_RESOURCE pOsResource |
| //! [in] Pointer to OS Resource |
| //! \return int32_t |
| //! Return true if nullptr, otherwise false |
| //! |
| int32_t Mos_ResourceIsNull( |
| PMOS_RESOURCE pOsResource); |
| |
| //! |
| //! \brief Get Buffer Type |
| //! \details Returns the type of buffer, 1D, 2D or volume |
| //! \param PMOS_RESOURCE pOsResource |
| //! [in] Pointer to OS Resource |
| //! \return GFX resource Type |
| //! |
| MOS_GFXRES_TYPE GetResType( |
| PMOS_RESOURCE pOsResource); |
| |
| //! |
| //! \brief OS reset resource |
| //! \details Resets the OS resource |
| //! \param PMOS_RESOURCE pOsResource |
| //! [in] Pointer to OS Resource |
| //! \return void |
| //! Return NONE |
| //! |
| void Mos_ResetResource( |
| PMOS_RESOURCE pOsResource); |
| |
| //! |
| //! \brief Convert to MOS tile type |
| //! \details Convert from Linux to MOS tile type |
| //! \param uint32_t type |
| //! [in] tile type |
| //! \return MOS_TILE_TYPE |
| //! Return MOS tile type |
| //! |
| MOS_TILE_TYPE LinuxToMosTileType( |
| uint32_t type); |
| |
| //! |
| //! \brief Linux OS initilization |
| //! \details Linux OS initilization |
| //! \param PMOS_INTERFACE pOsInterface |
| //! [in] Pointer to OS Interface |
| //! \param PMOS_CONTEXT pOsDriverContext |
| //! [in] Pointer to OS Driver context |
| //! \return MOS_STATUS |
| //! Return MOS_STATUS_SUCCESS if successful, otherwise failed |
| //! |
| MOS_STATUS Mos_Specific_InitInterface( |
| PMOS_INTERFACE pOsInterface, |
| PMOS_CONTEXT pOsDriverContext); |
| |
| //! |
| //! \brief Lock resource |
| //! \details Lock allocated resource |
| //! \param PMOS_INTERFACE pOsInterface |
| //! [in] Pointer to OS interface structure |
| //! \param PMOS_RESOURCE pOsResource |
| //! [in] Pointer to input OS resource |
| //! \param PMOS_LOCK_PARAMS pLockFlags |
| //! [in] Lock Flags - MOS_LOCKFLAG_* flags |
| //! \return void * |
| //! |
| void *Mos_Specific_LockResource( |
| PMOS_INTERFACE pOsInterface, |
| PMOS_RESOURCE pOsResource, |
| PMOS_LOCK_PARAMS pLockFlags); |
| |
| //! |
| //! \brief Destroys OS specific allocations |
| //! \details Destroys OS specific allocations including destroying OS context |
| //! \param PMOS_INTERFACE pOsInterface |
| //! [in] Pointer to OS Interface |
| //! \param int32_t bDestroyVscVppDeviceTag |
| //! [in] Destroy VscVppDeviceTagId Flag, no use in Linux |
| //! \return void |
| //! |
| void Mos_Specific_Destroy( |
| PMOS_INTERFACE pOsInterface, |
| int32_t bDestroyVscVppDeviceTag); |
| |
| //! |
| //! \brief Resets OS States |
| //! \details Resets OS States for linux |
| //! \param PMOS_INTERFACE pOsInterface |
| //! [in] Pointer to OS Interface |
| //! \return void |
| //! |
| void Mos_Specific_ResetOsStates( |
| PMOS_INTERFACE pOsInterface); |
| |
| //! |
| //! \brief Resizes the buffer to be used for rendering GPU commands |
| //! \details Resizes the buffer to be used for rendering GPU commands |
| //! \param PMOS_INTERFACE pOsInterface |
| //! [in] OS Interface |
| //! \param uint32_t dwRequestedCommandBufferSize |
| //! [in] Requested command buffer size |
| //! \param uint32_t dwRequestedPatchListSize |
| //! [in] Requested patch list size |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if succeeded, otherwise error code |
| //! |
| MOS_STATUS Mos_Specific_ResizeCommandBufferAndPatchList( |
| PMOS_INTERFACE pOsInterface, |
| uint32_t dwRequestedCommandBufferSize, |
| uint32_t dwRequestedPatchListSize, |
| uint32_t dwFlags); |
| |
| //! |
| //! \brief Unlock resource |
| //! \details Unlock the locked resource |
| //! \param PMOS_INTERFACE pOsInterface |
| //! [in] Pointer to OS interface structure |
| //! \param PMOS_RESOURCE pOsResource |
| //! [in] Pointer to input OS resource |
| //! \return MOS_STATUS |
| //! Return MOS_STATUS_SUCCESS if successful, otherwise failed |
| //! |
| MOS_STATUS Mos_Specific_UnlockResource( |
| PMOS_INTERFACE pOsInterface, |
| PMOS_RESOURCE pOsResource); |
| |
| //! |
| //! \brief Get Resource Information |
| //! \details Linux get resource info |
| //! \param PMOS_INTERFACE pOsInterface |
| //! [in] Pointer to OS interface structure |
| //! \param PMOS_RESOURCE pOsResource |
| //! [in] Pointer to input OS resource |
| //! \param PMOS_SURFACE pResDetails |
| //! [out] Pointer to output resource information details |
| //! \return MOS_STATUS |
| //! Return MOS_STATUS_SUCCESS if successful, otherwise failed |
| //! |
| MOS_STATUS Mos_Specific_GetResourceInfo( |
| PMOS_INTERFACE pOsInterface, |
| PMOS_RESOURCE pOsResource, |
| PMOS_SURFACE pResDetails); |
| |
| //! |
| //! \brief Get resource index |
| //! \details Get resource index of MOS_RESOURCE |
| //! \param PMOS_RESOURCE osResource |
| //! [in] Pointer to OS resource |
| //! \return uint32_t |
| //! Resource index |
| //! |
| uint32_t Mos_Specific_GetResourceIndex( |
| PMOS_RESOURCE osResource); |
| |
| uint32_t Mos_Specific_GetResourcePitch( |
| PMOS_RESOURCE pOsResource); |
| |
| void Mos_Specific_SetResourceWidth( |
| PMOS_RESOURCE pOsResource, |
| uint32_t dwWidth); |
| |
| void Mos_Specific_SetResourceFormat( |
| PMOS_RESOURCE pOsResource, |
| MOS_FORMAT mosFormat); |
| |
| //! |
| //! \brief Get SetMarker enabled flag |
| //! \details Get SetMarker enabled flag from OsInterface |
| //! \param PMOS_INTERFACE pOsInterface |
| //! [in] OS Interface |
| //! \return bool |
| //! SetMarker enabled flag |
| //! |
| bool Mos_Specific_IsSetMarkerEnabled( |
| PMOS_INTERFACE pOsInterface); |
| |
| //! |
| //! \brief Get SetMarker resource address |
| //! \details Get SetMarker resource address from OsInterface |
| //! \param PMOS_INTERFACE pOsInterface |
| //! [in] OS Interface |
| //! \return PMOS_RESOURCE |
| //! SetMarker resource address |
| //! |
| PMOS_RESOURCE Mos_Specific_GetMarkerResource( |
| PMOS_INTERFACE pOsInterface); |
| |
| //! |
| //! \brief Get TimeStamp frequency base |
| //! \details Get TimeStamp frequency base from OsInterface |
| //! \param PMOS_INTERFACE pOsInterface |
| //! [in] OS Interface |
| //! \return uint32_t |
| //! time stamp frequency base |
| //! |
| uint32_t Mos_Specific_GetTsFrequency( |
| PMOS_INTERFACE pOsInterface); |
| |
| //! |
| //! \brief Checks whether the requested resource is releasable |
| //! \param PMOS_INTERFACE pOsInterface |
| //! [in] OS Interface |
| //! \param PMOS_RESOURCE pOsResource |
| //! [in] Pointer to OS Resource |
| //! \return MOS_STATUS |
| //! MOS_STATUS_SUCCESS if requested can be released, otherwise MOS_STATUS_UNKNOWN |
| //! |
| MOS_STATUS Mos_Specific_IsResourceReleasable( |
| PMOS_INTERFACE pOsInterface, |
| PMOS_RESOURCE pOsResource); |
| |
| #if (_DEBUG || _RELEASE_INTERNAL) |
| MOS_LINUX_BO * Mos_GetNopCommandBuffer_Linux( |
| PMOS_INTERFACE pOsInterface); |
| |
| MOS_LINUX_BO * Mos_GetBadCommandBuffer_Linux( |
| PMOS_INTERFACE pOsInterface); |
| #endif |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif // __MOS_OS_SPECIFIC_H__ |
