Google Git
Sign in
coral / imx-gpu-viv-ko / refs/heads/master / . / hal / kernel / inc / gc_hal_base.h
blob: 80b44a2d3aa8dbf01658dbc31cf29f84293dfaf9 [file] [log] [blame]
/****************************************************************************
*
* The MIT License (MIT)
*
* Copyright (c) 2014 - 2020 Vivante 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.
*
*****************************************************************************
*
* The GPL License (GPL)
*
* Copyright (C) 2014 - 2020 Vivante Corporation
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*****************************************************************************
*
* Note: This software is released under dual MIT and GPL licenses. A
* recipient may use this file under the terms of either the MIT license or
* GPL License. If you wish to use only one license not the other, you can
* indicate your decision by deleting one of the above license notices in your
* version of this file.
*
*****************************************************************************/
#ifndef __gc_hal_base_h_
#define __gc_hal_base_h_
#include "gc_hal_enum.h"
#include "shared/gc_hal_types.h"
#include "gc_hal_debug_zones.h"
#include "shared/gc_hal_base.h"
#ifdef __cplusplus
extern "C" {
#endif
/******************************************************************************\
****************************** Object Declarations *****************************
\******************************************************************************/
typedef struct _gckOS * gckOS;
typedef struct _gcoHAL * gcoHAL;
typedef struct _gcoOS * gcoOS;
typedef struct _gco2D * gco2D;
typedef struct gcsATOM * gcsATOM_PTR;
typedef struct _gco3D * gco3D;
typedef struct _gcoCL * gcoCL;
typedef struct _gcoVX * gcoVX;
typedef struct _gcsFAST_FLUSH * gcsFAST_FLUSH_PTR;
typedef struct _gcoSURF * gcoSURF;
typedef struct _gcsSURF_NODE * gcsSURF_NODE_PTR;
typedef struct _gcsSURF_FORMAT_INFO * gcsSURF_FORMAT_INFO_PTR;
typedef struct _gcsPOINT * gcsPOINT_PTR;
typedef struct _gcsSIZE * gcsSIZE_PTR;
typedef struct _gcsRECT * gcsRECT_PTR;
typedef struct _gcsBOUNDARY * gcsBOUNDARY_PTR;
typedef struct _gcoHARDWARE * gcoHARDWARE;
typedef union _gcuVIDMEM_NODE * gcuVIDMEM_NODE_PTR;
typedef struct _gcsVIDMEM_NODE * gckVIDMEM_NODE;
typedef struct _gcsVIDMEM_BLOCK * gckVIDMEM_BLOCK;
typedef void * gcoVG;
typedef struct _gcoFENCE * gcoFENCE;
typedef struct _gcsSYNC_CONTEXT * gcsSYNC_CONTEXT_PTR;
typedef struct _gcsUSER_MEMORY_DESC * gcsUSER_MEMORY_DESC_PTR;
/* Immuatable features from database */
typedef struct _gcsNN_FIXED_FEATURE
{
gctUINT vipCoreCount;
gctUINT nnCoreCount; /* total nn core count */
gctUINT nnCoreCountInt8; /* total nn core count supporting int8 */
gctUINT nnCoreCountInt16; /* total nn core count supporting int16 */
gctUINT nnCoreCountFloat16; /* total nn core count supporting float16 */
gctUINT nnCoreCountBFloat16; /* total nn core count supporting Bfloat16 */
gctUINT nnMadPerCore;
gctUINT nnInputBufferDepth;
gctUINT nnAccumBufferDepth;
gctUINT nnFCNonPrunAccel;
gctUINT nnInImageOffsetBits;
gctUINT tpCoreCount; /* full-function core count */
gctUINT tpPwlLUTCount;
gctUINT tpPwlLUTSize;
gctUINT vip7Version;
gctUINT vipBrickMode;
gctUINT tpReorderInImageSize;
gctUINT tpliteCoreCount; /* fc-only core count */
gctUINT nnFP16XYDPX;
gctUINT nnFP16XYDPY;
gctUINT nnFP16ZDP;
gctUINT zrlBits;
gctUINT uscCacheControllers;
gctUINT uscBanks;
gctUINT nnLanesPerOutCycle;
gctUINT maxOTNumber;
gctUINT physicalVipSramWidthInByte;
gctUINT equivalentVipsramWidthInByte;
gctUINT shaderCoreCount;
gctUINT latencyHidingAtFullAxiBw;
gctUINT axiBusWidth;
gctUINT nnMaxKXSize;
gctUINT nnMaxKYSize;
gctUINT nnMaxKZSize;
} gcsNN_FIXED_FEATURE;
/* Features can be customized from outside */
typedef struct _gcsNN_CUSTOMIZED_FEATURE
{
gctUINT vipSRAMSize;
gctUINT axiSRAMSize;
gctFLOAT ddrReadBWLimit;
gctFLOAT ddrWriteBWLimit;
gctFLOAT ddrTotalBWLimit;
gctFLOAT axiSramReadBWLimit;
gctFLOAT axiSramWriteBWLimit;
gctFLOAT axiSramTotalBWLimit;
gctFLOAT axiBusReadBWLimit;
gctFLOAT axiBusWriteBWLimit;
gctFLOAT axiBusTotalBWLimit;
gctUINT vipSWTiling;
gctFLOAT ddrLatency;
gctUINT freqInMHZ;
gctUINT axiClockFreqInMHZ;
gctUINT maxSocOTNumber;/*max SOC outstanding transfer number*/
gctUINT nnWriteWithoutUSC;
gctUINT depthWiseSupport;
gctUINT vipVectorPrune;
gctUINT ddrKernelBurstSize;
} gcsNN_CUSTOMIZED_FEATURE;
/* Features are unified (hardcoded) for hardwares */
typedef struct _gcsNN_UNIFIED_FEATURE
{
gctUINT nnUSCCacheSize;
gctUINT nnCmdSizeInBytes;
gctUINT tpCmdSizeInBytes;
gctUINT vipCoefDecodePerf;
gctUINT vipCachedReadFromSram;
gctUINT vipImagePartialCache;
gctUINT lanesPerConv;
gctUINT maxTileSize;
gctUINT fullCacheKernelHeadFix : 1;
gctUINT conv1x1HalfPerformance : 1;
gctUINT per3DTileBubbleFix : 1;
gctUINT cacheLineModeDisabled : 1;
gctUINT tpReOrderFix : 1;
gctUINT zdp3NoCompressFix : 1;
gctUINT asyncCopyPerfFix : 1;
gctUINT accurateTileBW : 1;
gctUINT zxdp3KernelReadConflictFix : 1;
gctUINT axiSramSlowedDownByAddr:1;
gctUINT slowNNReqArbitrationFix:1;
gctUINT singlePortAccBuffer : 1;
gctUINT convOutFifoDepthFix : 1;
gctUINT smallBatchEnable : 1;
gctUINT axiSramOnlySWTiling : 1;
gctUINT imageNotPackedInSram : 1;
gctUINT coefDeltaCordOverFlowZRL8BitFix : 1;
gctUINT lowEfficiencyOfIDWriteImgBufFix : 1;
gctUINT xyOffsetLimitationFix : 1;
gctUINT kernelPerCoreLTOneThirdCoefFix : 1;
gctUINT diffConditionForCachelineModePreFix : 1;
} gcsNN_UNIFIED_FEATURE;
/* Features are derived from above ones */
typedef struct _gcsNN_DERIVIED_FEATURE
{
gctUINT nnDPAmount;
gctUINT nnXYDPX;
gctUINT nnXYDPY;
gctUINT nnZDP;
gctFLOAT totalLatency;
gctFLOAT internalLatency;
gctFLOAT ddrReadBWInBytePerCycle;
gctFLOAT ddrWriteBWInBytePerCycle;
} gcsNN_DERIVED_FEATURE;
/******************************************************************************\
********************* Share obj lock/unlock macros. ****************************
\******************************************************************************/
#define gcmLOCK_SHARE_OBJ(Obj) \
{ \
if(Obj->sharedLock != gcvNULL)\
{\
(gcoOS_AcquireMutex(\
gcvNULL, Obj->sharedLock, gcvINFINITE));\
}\
}
#define gcmUNLOCK_SHARE_OBJ(Obj)\
{\
if(Obj->sharedLock != gcvNULL)\
{\
(gcoOS_ReleaseMutex(gcvNULL, Obj->sharedLock));\
}\
}
typedef struct _gcsSystemInfo
{
/* memory latency number for SH data fetch, in SH cycle*/
gctUINT32 memoryLatencySH;
}
gcsSystemInfo;
#define gcPLS_INITIALIZER \
{ \
gcvNULL, /* gcoOS object. */ \
gcvNULL, /* gcoHAL object. */ \
0, /* internalSize */ \
0, /* internalPhysName */ \
gcvNULL, /* internalLogical */ \
0, /* externalSize */ \
0, /* externalPhysName */ \
gcvNULL, /* externalLogical */ \
0, /* contiguousSize */ \
0, /* contiguousPhysName */ \
gcvNULL, /* contiguousLogical */ \
gcvNULL, /* eglDisplayInfo */ \
gcvNULL, /* eglSurfaceInfo */ \
gcvSURF_A8R8G8B8,/* eglConfigFormat */ \
gcvNULL, /* reference */ \
0, /* processID */ \
0, /* threadID */ \
gcvFALSE, /* exiting */ \
gcvFALSE, /* Special flag for NP2 texture. */ \
gcvFALSE, /* device open. */ \
gcvNULL, /* destructor */ \
gcvNULL, /* accessLock */ \
gcvNULL, /* GL FE compiler lock*/ \
gcvNULL, /* CL FE compiler lock*/ \
gcvNULL, /* VX context lock */ \
gcvPATCH_NOTINIT,/* global patchID */ \
gcvNULL, /* global fenceID*/ \
gcvNULL, /* mainThreadHandle */ \
gcvFALSE, /* memory profile flag */ \
gcvNULL, /* profileLock; */ \
0, /* allocCount; */ \
0, /* allocSize; */ \
0, /* maxAllocSize; */ \
0, /* freeCount; */ \
0, /* freeSize; */ \
0, /* currentSize; */ \
0, /* video_allocCount; */ \
0, /* video_allocSize; */ \
0, /* video_maxAllocSize; */ \
0, /* video_freeCount; */ \
0, /* video_freeSize; */ \
0, /* video_currentSize; */ \
}
/******************************************************************************\
******************************* Thread local storage *************************
\******************************************************************************/
typedef struct _gcsDRIVER_TLS * gcsDRIVER_TLS_PTR;
typedef struct _gcsDRIVER_TLS
{
void (* destructor)(gcsDRIVER_TLS_PTR Tls);
}
gcsDRIVER_TLS;
typedef struct _gcsTLS * gcsTLS_PTR;
typedef struct _gcsTLS
{
gceHARDWARE_TYPE currentType;
gceHARDWARE_TYPE targetType;
/* To which core device control is called,
* it is index in a hardware type.
*/
gctUINT32 currentCoreIndex;
/* Current 3D hardwre of this thread */
gcoHARDWARE currentHardware;
/* Default 3D hardware of this thread */
gcoHARDWARE defaultHardware;
/* Only for separated 3D and 2D */
gcoHARDWARE hardware2D;
#if gcdENABLE_3D
gco3D engine3D;
#endif
gcoVX engineVX;
gctBOOL copied;
/* libGAL.so handle */
gctHANDLE handle;
/* If true, do not releas 2d engine and hardware in hal layer */
gctBOOL release2DUpper;
/* Driver tls. */
gcsDRIVER_TLS_PTR driverTLS[gcvTLS_KEY_COUNT];
}
gcsTLS;
typedef struct _gcsSURF_VIEW
{
gcoSURF surf;
gctUINT firstSlice;
gctUINT numSlices;
}gcsSURF_VIEW;
/* gcsHAL_Limits*/
typedef struct _gcsHAL_LIMITS
{
/* chip info */
gceCHIPMODEL chipModel;
gctUINT32 chipRevision;
gctUINT32 featureCount;
gctUINT32 *chipFeatures;
/* target caps */
gctUINT32 maxWidth;
gctUINT32 maxHeight;
gctUINT32 multiTargetCount;
gctUINT32 maxSamples;
}gcsHAL_LIMITS;
typedef struct _gcsHAL_CHIPIDENTITY
{
gceCHIPMODEL chipModel;
gctUINT32 chipRevision;
gctUINT32 productID;
gctUINT32 customerID;
gctUINT32 ecoID;
gceCHIP_FLAG chipFlags;
gctUINT64 platformFlagBits;
}
gcsHAL_CHIPIDENTITY;
/******************************************************************************\
********************************* gcoHAL Object *********************************
\******************************************************************************/
/* Construct a new gcoHAL object. */
gceSTATUS
gcoHAL_ConstructEx(
IN gctPOINTER Context,
IN gcoOS Os,
OUT gcoHAL * Hal
);
/* Destroy an gcoHAL object. */
gceSTATUS
gcoHAL_DestroyEx(
IN gcoHAL Hal
);
/* Empty function for compatibility. */
gceSTATUS
gcoHAL_Construct(
IN gctPOINTER Context,
IN gcoOS Os,
OUT gcoHAL * Hal
);
/* Empty function for compatibility. */
gceSTATUS
gcoHAL_Destroy(
IN gcoHAL Hal
);
/* Get HAL options */
gceSTATUS
gcoHAL_GetOption(
IN gcoHAL Hal,
IN gceOPTION Option
);
gceSTATUS
gcoHAL_FrameInfoOps(
IN gcoHAL Hal,
IN gceFRAMEINFO FrameInfo,
IN gceFRAMEINFO_OP Op,
IN OUT gctUINT * Val
);
/* Set HAL options */
gceSTATUS
gcoHAL_SetOption(
IN gcoHAL Hal,
IN gceOPTION Option,
IN gctBOOL Value
);
gceSTATUS
gcoHAL_GetHardware(
IN gcoHAL Hal,
OUT gcoHARDWARE* Hw
);
#if gcdENABLE_3D
gceSTATUS
gcoHAL_GetSpecialHintData(
IN gcoHAL Hal,
OUT gctINT * Hint
);
/*
** Deprecated(Don't use it), keep it here for external library(libgcu.so)
*/
gceSTATUS
gcoHAL_Get3DEngine(
IN gcoHAL Hal,
OUT gco3D * Engine
);
#endif /* gcdENABLE_3D */
gceSTATUS
gcoHAL_GetProductName(
IN gcoHAL Hal,
OUT gctSTRING *ProductName,
OUT gctUINT *PID
);
gceSTATUS
gcoHAL_SetFscaleValue(
IN gcoHAL Hal,
IN gctUINT CoreIndex,
IN gctUINT FscaleValue,
IN gctUINT ShaderFscaleValue
);
gceSTATUS
gcoHAL_GetFscaleValue(
OUT gctUINT * FscaleValue,
OUT gctUINT * MinFscaleValue,
OUT gctUINT * MaxFscaleValue
);
gceSTATUS
gcoHAL_SetBltNP2Texture(
gctBOOL enable
);
gceSTATUS
gcoHAL_ExportVideoMemory(
IN gctUINT32 Handle,
IN gctUINT32 Flags,
OUT gctINT32 * FD
);
gceSTATUS
gcoHAL_NameVideoMemory(
IN gctUINT32 Handle,
OUT gctUINT32 * Name
);
gceSTATUS
gcoHAL_ImportVideoMemory(
IN gctUINT32 Name,
OUT gctUINT32 * Handle
);
gceSTATUS
gcoHAL_GetVideoMemoryFd(
IN gctUINT32 Handle,
OUT gctINT * Fd
);
/* Verify whether the specified feature is available in hardware. */
gceSTATUS
gcoHAL_IsFeatureAvailable(
IN gcoHAL Hal,
IN gceFEATURE Feature
);
gceSTATUS
gcoHAL_IsFeatureAvailable1(
IN gcoHAL Hal,
IN gceFEATURE Feature
);
/* Query the identity of the hardware. */
gceSTATUS
gcoHAL_QueryChipIdentity(
IN gcoHAL Hal,
OUT gceCHIPMODEL* ChipModel,
OUT gctUINT32* ChipRevision,
OUT gctUINT32* ChipFeatures,
OUT gctUINT32* ChipMinorFeatures
);
gceSTATUS gcoHAL_QueryChipIdentityEx(
IN gcoHAL Hal,
IN gctUINT32 SizeOfParam,
OUT gcsHAL_CHIPIDENTITY *ChipIdentity
);
gceSTATUS
gcoHAL_QuerySuperTileMode(
OUT gctUINT32_PTR SuperTileMode
);
gceSTATUS
gcoHAL_QueryChipAxiBusWidth(
OUT gctBOOL * AXI128Bits
);
gceSTATUS
gcoHAL_QueryMultiGPUAffinityConfig(
IN gceHARDWARE_TYPE Type,
OUT gceMULTI_GPU_MODE *Mode,
OUT gctUINT32_PTR CoreIndex
);
gceSTATUS
gcoHAL_QuerySRAM(
IN gcoHAL Hal,
IN gcePOOL Type,
OUT gctUINT32 *Size,
OUT gctUINT32 *GPUVirtAddr,
OUT gctPHYS_ADDR_T *GPUPhysAddr,
OUT gctUINT32 *GPUPhysName,
OUT gctPHYS_ADDR_T *CPUPhysAddr
);
#ifdef LINUX
gctINT32
gcoOS_EndRecordAllocation(void);
void
gcoOS_RecordAllocation(void);
void
gcoOS_AddRecordAllocation(gctSIZE_T Size);
#endif
/* Query the amount of video memory. */
gceSTATUS
gcoHAL_QueryVideoMemory(
IN gcoHAL Hal,
OUT gctUINT32 * InternalPhysName,
OUT gctSIZE_T * InternalSize,
OUT gctUINT32 * ExternalPhysName,
OUT gctSIZE_T * ExternalSize,
OUT gctUINT32 * ContiguousPhysName,
OUT gctSIZE_T * ContiguousSize
);
/* Map video memory. */
gceSTATUS
gcoHAL_MapMemory(
IN gcoHAL Hal,
IN gctUINT32 PhysName,
IN gctSIZE_T NumberOfBytes,
OUT gctPOINTER * Logical
);
/* Unmap video memory. */
gceSTATUS
gcoHAL_UnmapMemory(
IN gcoHAL Hal,
IN gctUINT32 PhysName,
IN gctSIZE_T NumberOfBytes,
IN gctPOINTER Logical
);
/* Schedule an unmap of a buffer mapped through its physical address. */
gceSTATUS
gcoHAL_ScheduleUnmapMemory(
IN gcoHAL Hal,
IN gctUINT32 PhysName,
IN gctSIZE_T NumberOfBytes,
IN gctPOINTER Logical
);
/* Allocate video memory. */
gceSTATUS
gcoOS_AllocateVideoMemory(
IN gcoOS Os,
IN gctBOOL InUserSpace,
IN gctBOOL InCacheable,
IN OUT gctSIZE_T * Bytes,
OUT gctUINT32 * Physical,
OUT gctPOINTER * Logical,
OUT gctPOINTER * Handle
);
/* Free video memory. */
gceSTATUS
gcoOS_FreeVideoMemory(
IN gcoOS Os,
IN gctPOINTER Handle
);
/* Lock video memory. */
gceSTATUS
gcoOS_LockVideoMemory(
IN gcoOS Os,
IN gctPOINTER Handle,
IN gctBOOL InUserSpace,
IN gctBOOL InCacheable,
OUT gctUINT32 * Address,
OUT gctPOINTER * Logical
);
/* Commit the current command buffer. */
gceSTATUS
gcoHAL_Commit(
IN gcoHAL Hal,
IN gctBOOL Stall
);
#if gcdENABLE_3D
/* Sencd fence command. */
gceSTATUS
gcoHAL_SendFence(
IN gcoHAL Hal
);
#endif /* gcdENABLE_3D */
/* Query the tile capabilities. */
gceSTATUS
gcoHAL_QueryTiled(
IN gcoHAL Hal,
OUT gctINT32 * TileWidth2D,
OUT gctINT32 * TileHeight2D,
OUT gctINT32 * TileWidth3D,
OUT gctINT32 * TileHeight3D
);
gceSTATUS
gcoHAL_Compact(
IN gcoHAL Hal
);
#if VIVANTE_PROFILER_SYSTEM_MEMORY
gceSTATUS
gcoHAL_ProfileStart(
IN gcoHAL Hal
);
gceSTATUS
gcoHAL_ProfileEnd(
IN gcoHAL Hal,
IN gctCONST_STRING Title
);
#endif
/* Power Management */
gceSTATUS
gcoHAL_SetPowerManagementState(
IN gcoHAL Hal,
IN gceCHIPPOWERSTATE State
);
gceSTATUS
gcoHAL_QueryPowerManagementState(
IN gcoHAL Hal,
OUT gceCHIPPOWERSTATE *State
);
/* Set the filter type for filter blit. */
gceSTATUS
gcoHAL_SetFilterType(
IN gcoHAL Hal,
IN gceFILTER_TYPE FilterType
);
/* Call the kernel HAL layer. */
gceSTATUS
gcoHAL_Call(
IN gcoHAL Hal,
IN OUT gcsHAL_INTERFACE_PTR Interface
);
/* Schedule an event. */
gceSTATUS
gcoHAL_ScheduleEvent(
IN gcoHAL Hal,
IN OUT gcsHAL_INTERFACE_PTR Interface
);
/* Request a start/stop timestamp. */
gceSTATUS
gcoHAL_SetTimer(
IN gcoHAL Hal,
IN gctUINT32 Index,
IN gctBOOL Start
);
/* Get Time delta from a Timer in microseconds. */
gceSTATUS
gcoHAL_GetTimerTime(
IN gcoHAL Hal,
IN gctUINT32 Timer,
OUT gctINT32_PTR TimeDelta
);
/* set timeout value. */
gceSTATUS
gcoHAL_SetTimeOut(
IN gcoHAL Hal,
IN gctUINT32 timeOut
);
gceSTATUS
gcoHAL_SetHardwareType(
IN gcoHAL Hal,
IN gceHARDWARE_TYPE HardwardType
);
gceSTATUS
gcoHAL_GetHardwareType(
IN gcoHAL Hal,
OUT gceHARDWARE_TYPE * HardwardType
);
gceSTATUS
gcoHAL_QueryChipCount(
IN gcoHAL Hal,
OUT gctINT32 * Count
);
gceSTATUS
gcoHAL_Query3DCoreCount(
IN gcoHAL Hal,
OUT gctUINT32 *Count
);
gceSTATUS
gcoHAL_QueryCluster(
IN gcoHAL Hal,
OUT gctINT32 *ClusterMinID,
OUT gctINT32 *ClusterMaxID,
OUT gctUINT32 *ClusterCount,
OUT gctUINT32 *ClusterIDWidth
);
gceSTATUS
gcoHAL_QueryCoreCount(
IN gcoHAL Hal,
IN gceHARDWARE_TYPE Type,
OUT gctUINT *Count,
OUT gctUINT_PTR ChipIDs
);
gceSTATUS
gcoHAL_QuerySeparated2D(
IN gcoHAL Hal
);
gceSTATUS
gcoHAL_QueryHybrid2D(
IN gcoHAL Hal
);
gceSTATUS
gcoHAL_Is3DAvailable(
IN gcoHAL Hal
);
/* Get pointer to gcoVG object. */
gceSTATUS
gcoHAL_GetVGEngine(
IN gcoHAL Hal,
OUT gcoVG * Engine
);
gceSTATUS
gcoHAL_QueryChipLimits(
IN gcoHAL Hal,
IN gctINT32 Chip,
OUT gcsHAL_LIMITS *Limits);
gceSTATUS
gcoHAL_QueryChipFeature(
IN gcoHAL Hal,
IN gctINT32 Chip,
IN gceFEATURE Feature);
gceSTATUS
gcoHAL_SetCoreIndex(
IN gcoHAL Hal,
IN gctUINT32 Core
);
gceSTATUS
gcoHAL_GetCurrentCoreIndex(
IN gcoHAL Hal,
OUT gctUINT32 *Core
);
gceSTATUS
gcoHAL_ConvertCoreIndexGlobal(
IN gcoHAL Hal,
IN gceHARDWARE_TYPE Type,
IN gctUINT32 CoreCount,
IN gctUINT32 *LocalCoreIndexs,
OUT gctUINT32 *GlobalCoreIndexs
);
gceSTATUS
gcoHAL_ConvertCoreIndexLocal(
IN gcoHAL Hal,
IN gceHARDWARE_TYPE Type,
IN gctUINT32 CoreCount,
IN gctUINT32 *GlobalCoreIndexs,
OUT gctUINT32 *LocalCoreIndexs
);
gceSTATUS
gcoHAL_SelectChannel(
IN gcoHAL Hal,
IN gctBOOL Priority,
IN gctUINT32 ChannelId
);
gceSTATUS
gcoHAL_MCFESemaphore(
IN gctUINT32 SemaHandle,
IN gctBOOL SendSema
);
gceSTATUS
gcoHAL_AllocateMCFESemaphore(
OUT gctUINT32 * SemaHandle
);
gceSTATUS
gcoHAL_FreeMCFESemaphore(
IN gctUINT32 SemaHandle
);
/*----------------------------------------------------------------------------*/
/*----- Shared Buffer --------------------------------------------------------*/
/* Create shared buffer. */
gceSTATUS
gcoHAL_CreateShBuffer(
IN gctUINT32 Size,
OUT gctSHBUF * ShBuf
);
/* Destroy shared buffer. */
gceSTATUS
gcoHAL_DestroyShBuffer(
IN gctSHBUF ShBuf
);
/* Map shared buffer to current process. */
gceSTATUS
gcoHAL_MapShBuffer(
IN gctSHBUF ShBuf
);
/* Write user data to shared buffer. */
gceSTATUS
gcoHAL_WriteShBuffer(
IN gctSHBUF ShBuf,
IN gctCONST_POINTER Data,
IN gctUINT32 ByteCount
);
/* Read user data from shared buffer. */
gceSTATUS
gcoHAL_ReadShBuffer(
IN gctSHBUF ShBuf,
IN gctPOINTER Data,
IN gctUINT32 BytesCount,
OUT gctUINT32 * BytesRead
);
/* Config power management to be enabled or disabled. */
gceSTATUS
gcoHAL_ConfigPowerManagement(
IN gctBOOL Enable
);
gceSTATUS
gcoHAL_AllocateVideoMemory(
IN gctUINT Alignment,
IN gceVIDMEM_TYPE Type,
IN gctUINT32 Flag,
IN gcePOOL Pool,
IN OUT gctSIZE_T * Bytes,
OUT gctUINT32_PTR Node
);
gceSTATUS
gcoHAL_LockVideoMemory(
IN gctUINT32 Node,
IN gctBOOL Cacheable,
IN gceENGINE engine,
OUT gctUINT32 * Address,
OUT gctPOINTER * Logical
);
gceSTATUS
gcoHAL_UnlockVideoMemory(
IN gctUINT32 Node,
IN gceVIDMEM_TYPE Type,
IN gceENGINE engine
);
gceSTATUS
gcoHAL_UnlockVideoMemoryEX(
IN gctUINT32 Node,
IN gceVIDMEM_TYPE Type,
IN gceENGINE Engine,
IN gctBOOL Sync
);
gceSTATUS
gcoHAL_ReleaseVideoMemory(
IN gctUINT32 Node
);
#if gcdENABLE_3D
/* Query the target capabilities. */
gceSTATUS
gcoHAL_QueryTargetCaps(
IN gcoHAL Hal,
OUT gctUINT * MaxWidth,
OUT gctUINT * MaxHeight,
OUT gctUINT * MultiTargetCount,
OUT gctUINT * MaxSamples
);
#endif
gceSTATUS
gcoHAL_WrapUserMemory(
IN gcsUSER_MEMORY_DESC_PTR UserMemoryDesc,
IN gceVIDMEM_TYPE Type,
OUT gctUINT32_PTR Node
);
gceSTATUS
gcoHAL_QueryResetTimeStamp(
OUT gctUINT64_PTR ResetTimeStamp,
OUT gctUINT64_PTR ContextID
);
gceSTATUS
gcoHAL_WaitFence(
IN gctUINT32 Handle,
IN gctUINT32 TimeOut
);
gceSTATUS
gcoHAL_ScheduleSignal(
IN gctSIGNAL Signal,
IN gctSIGNAL AuxSignal,
IN gctINT ProcessID,
IN gceKERNEL_WHERE FromWhere
);
gceSTATUS
gcoHAL_GetGraphicBufferFd(
IN gctUINT32 Node[3],
IN gctSHBUF ShBuf,
IN gctSIGNAL Signal,
OUT gctINT32 * Fd
);
gceSTATUS
gcoHAL_AlignToTile(
IN OUT gctUINT32 * Width,
IN OUT gctUINT32 * Height,
IN gceSURF_TYPE Type,
IN gceSURF_FORMAT Format
);
/******************************************************************************\
********************************** gcoOS Object *********************************
\******************************************************************************/
/* Lock PLS access */
gceSTATUS
gcoOS_LockPLS(
void
);
/* Unlock PLS access */
gceSTATUS
gcoOS_UnLockPLS(
void
);
/* Get PLS value for given key */
gctPOINTER
gcoOS_GetPLSValue(
IN gcePLS_VALUE key
);
/* Set PLS value of a given key */
void
gcoOS_SetPLSValue(
IN gcePLS_VALUE key,
OUT gctPOINTER value
);
/* Lock GL FE compiler access */
gceSTATUS
gcoOS_LockGLFECompiler(
void
);
/* Unlock GL FE compiler access */
gceSTATUS
gcoOS_UnLockGLFECompiler(
void
);
/* Lock CL FE compiler access */
gceSTATUS
gcoOS_LockCLFECompiler(
void
);
/* Unlock CL FE compiler access */
gceSTATUS
gcoOS_UnLockCLFECompiler(
void
);
gceSTATUS
gcoOS_GetTLS(
OUT gcsTLS_PTR * TLS
);
/* Copy the TLS from a source thread. */
gceSTATUS
gcoOS_CopyTLS(
IN gcsTLS_PTR Source
);
/* Query the thread local storage. */
gceSTATUS
gcoOS_QueryTLS(
OUT gcsTLS_PTR * TLS
);
/* Get access to driver tls. */
gceSTATUS
gcoOS_GetDriverTLS(
IN gceTLS_KEY Key,
OUT gcsDRIVER_TLS_PTR * TLS
);
/*
* Set driver tls.
* May cause memory leak if 'destructor' not set.
*/
gceSTATUS
gcoOS_SetDriverTLS(
IN gceTLS_KEY Key,
IN gcsDRIVER_TLS * TLS
);
/* Destroy the objects associated with the current thread. */
void
gcoOS_FreeThreadData(
void
);
/* Empty function for compatibility. */
gceSTATUS
gcoOS_Construct(
IN gctPOINTER Context,
OUT gcoOS * Os
);
/* Empty function for compatibility. */
gceSTATUS
gcoOS_Destroy(
IN gcoOS Os
);
/* Deprecated API: please use gcoHAL_GetBaseAddr() instead.
** This API was kept only for legacy BSP usage.
**
** Get the base address for the physical memory.
*/
gceSTATUS
gcoOS_GetBaseAddress(
IN gcoOS Os,
OUT gctUINT32_PTR BaseAddress
);
/* Allocate memory from the heap. */
gceSTATUS
gcoOS_Allocate(
IN gcoOS Os,
IN gctSIZE_T Bytes,
OUT gctPOINTER * Memory
);
/* Get allocated memory size. */
gceSTATUS
gcoOS_GetMemorySize(
IN gcoOS Os,
IN gctPOINTER Memory,
OUT gctSIZE_T_PTR MemorySize
);
/* Free allocated memory. */
gceSTATUS
gcoOS_Free(
IN gcoOS Os,
IN gctPOINTER Memory
);
/* Allocate memory. */
gceSTATUS
gcoOS_AllocateSharedMemory(
IN gcoOS Os,
IN gctSIZE_T Bytes,
OUT gctPOINTER * Memory
);
/* Free memory. */
gceSTATUS
gcoOS_FreeSharedMemory(
IN gcoOS Os,
IN gctPOINTER Memory
);
/* Allocate memory. */
gceSTATUS
gcoOS_AllocateMemory(
IN gcoOS Os,
IN gctSIZE_T Bytes,
OUT gctPOINTER * Memory
);
/* Free memory. */
gceSTATUS
gcoOS_FreeMemory(
IN gcoOS Os,
IN gctPOINTER Memory
);
/* Device I/O Control call to the kernel HAL layer. */
gceSTATUS
gcoOS_DeviceControl(
IN gcoOS Os,
IN gctUINT32 IoControlCode,
IN gctPOINTER InputBuffer,
IN gctSIZE_T InputBufferSize,
IN gctPOINTER OutputBuffer,
IN gctSIZE_T OutputBufferSize
);
#define gcmOS_SAFE_FREE(os, mem) \
gcoOS_Free(os, mem); \
mem = gcvNULL
#define gcmOS_SAFE_FREE_SHARED_MEMORY(os, mem) \
gcoOS_FreeSharedMemory(os, mem); \
mem = gcvNULL
#define gcmkOS_SAFE_FREE(os, mem) \
gckOS_Free(os, mem); \
mem = gcvNULL
#define gcdMAX_PATH 512
/* Open a file. */
gceSTATUS
gcoOS_Open(
IN gcoOS Os,
IN gctCONST_STRING FileName,
IN gceFILE_MODE Mode,
OUT gctFILE * File
);
/* Close a file. */
gceSTATUS
gcoOS_Close(
IN gcoOS Os,
IN gctFILE File
);
/* Remove a file. */
gceSTATUS
gcoOS_Remove(
IN gcoOS Os,
IN gctCONST_STRING FileName
);
/* Read data from a file. */
gceSTATUS
gcoOS_Read(
IN gcoOS Os,
IN gctFILE File,
IN gctSIZE_T ByteCount,
IN gctPOINTER Data,
OUT gctSIZE_T * ByteRead
);
/* Write data to a file. */
gceSTATUS
gcoOS_Write(
IN gcoOS Os,
IN gctFILE File,
IN gctSIZE_T ByteCount,
IN gctCONST_POINTER Data
);
/* Flush data to a file. */
gceSTATUS
gcoOS_Flush(
IN gcoOS Os,
IN gctFILE File
);
/* Close a file descriptor. */
gceSTATUS
gcoOS_CloseFD(
IN gcoOS Os,
IN gctINT FD
);
/* Scan a file. */
gceSTATUS
gcoOS_FscanfI(
IN gcoOS Os,
IN gctFILE File,
IN gctCONST_STRING Format,
OUT gctUINT *result
);
/* Dup file descriptor to another. */
gceSTATUS
gcoOS_DupFD(
IN gcoOS Os,
IN gctINT FD,
OUT gctINT * FD2
);
/* Lock a file. */
gceSTATUS
gcoOS_LockFile(
IN gcoOS Os,
IN gctFILE File,
IN gctBOOL Shared,
IN gctBOOL Block
);
/* Unlock a file. */
gceSTATUS
gcoOS_UnlockFile(
IN gcoOS Os,
IN gctFILE File
);
/* Create an endpoint for communication. */
gceSTATUS
gcoOS_Socket(
IN gcoOS Os,
IN gctINT Domain,
IN gctINT Type,
IN gctINT Protocol,
OUT gctINT *SockFd
);
/* Close a socket. */
gceSTATUS
gcoOS_CloseSocket(
IN gcoOS Os,
IN gctINT SockFd
);
/* Initiate a connection on a socket. */
gceSTATUS
gcoOS_Connect(
IN gcoOS Os,
IN gctINT SockFd,
IN gctCONST_POINTER HostName,
IN gctUINT Port);
/* Shut down part of connection on a socket. */
gceSTATUS
gcoOS_Shutdown(
IN gcoOS Os,
IN gctINT SockFd,
IN gctINT How
);
/* Send a message on a socket. */
gceSTATUS
gcoOS_Send(
IN gcoOS Os,
IN gctINT SockFd,
IN gctSIZE_T ByteCount,
IN gctCONST_POINTER Data,
IN gctINT Flags
);
/* Initiate a connection on a socket. */
gceSTATUS
gcoOS_WaitForSend(
IN gcoOS Os,
IN gctINT SockFd,
IN gctINT Seconds,
IN gctINT MicroSeconds);
/* Get environment variable value. */
gceSTATUS
gcoOS_GetEnv(
IN gcoOS Os,
IN gctCONST_STRING VarName,
OUT gctSTRING * Value
);
/* Set environment variable value. */
gceSTATUS
gcoOS_SetEnv(
IN gcoOS Os,
IN gctCONST_STRING VarName,
IN gctSTRING Value
);
/* Get current working directory. */
gceSTATUS
gcoOS_GetCwd(
IN gcoOS Os,
IN gctINT SizeInBytes,
OUT gctSTRING Buffer
);
/* Get file status info. */
gceSTATUS
gcoOS_Stat(
IN gcoOS Os,
IN gctCONST_STRING FileName,
OUT gctPOINTER Buffer
);
/* Set the current position of a file. */
gceSTATUS
gcoOS_Seek(
IN gcoOS Os,
IN gctFILE File,
IN gctUINT32 Offset,
IN gceFILE_WHENCE Whence
);
/* Set the current position of a file. */
gceSTATUS
gcoOS_SetPos(
IN gcoOS Os,
IN gctFILE File,
IN gctUINT32 Position
);
/* Get the current position of a file. */
gceSTATUS
gcoOS_GetPos(
IN gcoOS Os,
IN gctFILE File,
OUT gctUINT32 * Position
);
/* Same as strstr. */
gceSTATUS
gcoOS_StrStr(
IN gctCONST_STRING String,
IN gctCONST_STRING SubString,
OUT gctSTRING * Output
);
/* Find the last occurance of a character inside a string. */
gceSTATUS
gcoOS_StrFindReverse(
IN gctCONST_STRING String,
IN gctINT8 Character,
OUT gctSTRING * Output
);
gceSTATUS
gcoOS_StrDup(
IN gcoOS Os,
IN gctCONST_STRING String,
OUT gctSTRING * Target
);
/* Copy a string. */
gceSTATUS
gcoOS_StrCopySafe(
IN gctSTRING Destination,
IN gctSIZE_T DestinationSize,
IN gctCONST_STRING Source
);
/* Append a string. */
gceSTATUS
gcoOS_StrCatSafe(
IN gctSTRING Destination,
IN gctSIZE_T DestinationSize,
IN gctCONST_STRING Source
);
/* Compare two strings. */
gceSTATUS
gcoOS_StrCmp(
IN gctCONST_STRING String1,
IN gctCONST_STRING String2
);
/* Compare characters of two strings. */
gceSTATUS
gcoOS_StrNCmp(
IN gctCONST_STRING String1,
IN gctCONST_STRING String2,
IN gctSIZE_T Count
);
/* Convert string to float. */
gceSTATUS
gcoOS_StrToFloat(
IN gctCONST_STRING String,
OUT gctFLOAT * Float
);
/* Convert hex string to integer. */
gceSTATUS gcoOS_HexStrToInt(
IN gctCONST_STRING String,
OUT gctINT * Int
);
/* Convert hex string to float. */
gceSTATUS
gcoOS_HexStrToFloat(
IN gctCONST_STRING String,
OUT gctFLOAT * Float
);
/* Convert string to integer. */
gceSTATUS
gcoOS_StrToInt(
IN gctCONST_STRING String,
OUT gctINT * Int
);
gceSTATUS
gcoOS_MemCmp(
IN gctCONST_POINTER Memory1,
IN gctCONST_POINTER Memory2,
IN gctSIZE_T Bytes
);
gceSTATUS
gcoOS_PrintStrSafe(
OUT gctSTRING String,
IN gctSIZE_T StringSize,
IN OUT gctUINT * Offset,
IN gctCONST_STRING Format,
...
);
gceSTATUS
gcoOS_LoadLibrary(
IN gcoOS Os,
IN gctCONST_STRING Library,
OUT gctHANDLE * Handle
);
gceSTATUS
gcoOS_FreeLibrary(
IN gcoOS Os,
IN gctHANDLE Handle
);
gceSTATUS
gcoOS_GetProcAddress(
IN gcoOS Os,
IN gctHANDLE Handle,
IN gctCONST_STRING Name,
OUT gctPOINTER * Function
);
gceSTATUS
gcoOS_Compact(
IN gcoOS Os
);
gceSTATUS
gcoOS_AddSignalHandler (
IN gceSignalHandlerType SignalHandlerType
);
#if VIVANTE_PROFILER_SYSTEM_MEMORY
gceSTATUS
gcoOS_ProfileStart(
IN gcoOS Os
);
gceSTATUS
gcoOS_ProfileEnd(
IN gcoOS Os,
IN gctCONST_STRING Title
);
gceSTATUS
gcoOS_SetProfileSetting(
IN gcoOS Os,
IN gctBOOL Enable,
IN gctCONST_STRING FileName
);
#endif
/* Get the amount of physical system memory */
gceSTATUS
gcoOS_GetPhysicalSystemMemorySize(
OUT gctSIZE_T * PhysicalSystemMemorySize
);
/* Query the video memory. */
gceSTATUS
gcoOS_QueryVideoMemory(
IN gcoOS Os,
OUT gctUINT32 * InternalPhysName,
OUT gctSIZE_T * InternalSize,
OUT gctUINT32 * ExternalPhysName,
OUT gctSIZE_T * ExternalSize,
OUT gctUINT32 * ContiguousPhysName,
OUT gctSIZE_T * ContiguousSize
);
gceSTATUS
gcoOS_QueryCurrentProcessName(
OUT gctSTRING Name,
IN gctSIZE_T Size
);
/*----------------------------------------------------------------------------*/
/*----- Atoms ----------------------------------------------------------------*/
/* Construct an atom. */
gceSTATUS
gcoOS_AtomConstruct(
IN gcoOS Os,
OUT gcsATOM_PTR * Atom
);
/* Destroy an atom. */
gceSTATUS
gcoOS_AtomDestroy(
IN gcoOS Os,
IN gcsATOM_PTR Atom
);
/* Get the 32-bit value protected by an atom. */
gceSTATUS
gcoOS_AtomGet(
IN gcoOS Os,
IN gcsATOM_PTR Atom,
OUT gctINT32_PTR Value
);
/* Set the 32-bit value protected by an atom. */
gceSTATUS
gcoOS_AtomSet(
IN gcoOS Os,
IN gcsATOM_PTR Atom,
IN gctINT32 Value
);
/* Increment an atom. */
gceSTATUS
gcoOS_AtomIncrement(
IN gcoOS Os,
IN gcsATOM_PTR Atom,
OUT gctINT32_PTR OldValue
);
/* Decrement an atom. */
gceSTATUS
gcoOS_AtomDecrement(
IN gcoOS Os,
IN gcsATOM_PTR Atom,
OUT gctINT32_PTR OldValue
);
gctHANDLE
gcoOS_GetCurrentProcessID(
void
);
gctHANDLE
gcoOS_GetCurrentThreadID(
void
);
/*----------------------------------------------------------------------------*/
/*----- Time -----------------------------------------------------------------*/
/* Get the number of milliseconds since the system started. */
gctUINT32
gcoOS_GetTicks(
void
);
/* Get time in microseconds. */
gceSTATUS
gcoOS_GetTime(
gctUINT64_PTR Time
);
/* Get CPU usage in microseconds. */
gceSTATUS
gcoOS_GetCPUTime(
gctUINT64_PTR CPUTime
);
/* Get memory usage. */
gceSTATUS
gcoOS_GetMemoryUsage(
gctUINT32_PTR MaxRSS,
gctUINT32_PTR IxRSS,
gctUINT32_PTR IdRSS,
gctUINT32_PTR IsRSS
);
/* Delay a number of microseconds. */
gceSTATUS
gcoOS_Delay(
IN gcoOS Os,
IN gctUINT32 Delay
);
/*----------------------------------------------------------------------------*/
/*----- Threads --------------------------------------------------------------*/
#ifdef _WIN32
/* Cannot include windows.h here becuase "near" and "far"
* which are used in gcsDEPTH_INFO, are defined to nothing in WinDef.h.
* So, use the real value of DWORD and WINAPI, instead.
* DWORD is unsigned long, and WINAPI is __stdcall.
* If these two are change in WinDef.h, the following two typdefs
* need to be changed, too.
*/
typedef unsigned long gctTHREAD_RETURN;
typedef unsigned long (__stdcall * gcTHREAD_ROUTINE)(void * Argument);
#else
typedef void * gctTHREAD_RETURN;
typedef void * (* gcTHREAD_ROUTINE)(void *);
#endif
/* Create a new thread. */
gceSTATUS
gcoOS_CreateThread(
IN gcoOS Os,
IN gcTHREAD_ROUTINE Worker,
IN gctPOINTER Argument,
OUT gctPOINTER * Thread
);
/* Close a thread. */
gceSTATUS
gcoOS_CloseThread(
IN gcoOS Os,
IN gctPOINTER Thread
);
/*----------------------------------------------------------------------------*/
/*----- Mutexes --------------------------------------------------------------*/
/* Create a new mutex. */
gceSTATUS
gcoOS_CreateMutex(
IN gcoOS Os,
OUT gctPOINTER * Mutex
);
/* Delete a mutex. */
gceSTATUS
gcoOS_DeleteMutex(
IN gcoOS Os,
IN gctPOINTER Mutex
);
/* Acquire a mutex. */
gceSTATUS
gcoOS_AcquireMutex(
IN gcoOS Os,
IN gctPOINTER Mutex,
IN gctUINT32 Timeout
);
/* Release a mutex. */
gceSTATUS
gcoOS_ReleaseMutex(
IN gcoOS Os,
IN gctPOINTER Mutex
);
/*----------------------------------------------------------------------------*/
/*----- Signals --------------------------------------------------------------*/
/* Create a signal. */
gceSTATUS
gcoOS_CreateSignal(
IN gcoOS Os,
IN gctBOOL ManualReset,
OUT gctSIGNAL * Signal
);
/* Destroy a signal. */
gceSTATUS
gcoOS_DestroySignal(
IN gcoOS Os,
IN gctSIGNAL Signal
);
/* Signal a signal. */
gceSTATUS
gcoOS_Signal(
IN gcoOS Os,
IN gctSIGNAL Signal,
IN gctBOOL State
);
/* Wait for a signal. */
gceSTATUS
gcoOS_WaitSignal(
IN gcoOS Os,
IN gctSIGNAL Signal,
IN gctUINT32 Wait
);
/* Map a signal from another process */
gceSTATUS
gcoOS_MapSignal(
IN gctSIGNAL RemoteSignal,
OUT gctSIGNAL * LocalSignal
);
/* Unmap a signal mapped from another process */
gceSTATUS
gcoOS_UnmapSignal(
IN gctSIGNAL Signal
);
/*----------------------------------------------------------------------------*/
/*----- Android Native Fence -------------------------------------------------*/
/* Create native fence. */
gceSTATUS
gcoOS_CreateNativeFence(
IN gcoOS Os,
IN gctSIGNAL Signal,
OUT gctINT * FenceFD
);
/* (CPU) Wait on native fence. */
gceSTATUS
gcoOS_ClientWaitNativeFence(
IN gcoOS Os,
IN gctINT FenceFD,
IN gctUINT32 Timeout
);
/* (GPU) Wait on native fence. */
gceSTATUS
gcoOS_WaitNativeFence(
IN gcoOS Os,
IN gctINT FenceFD,
IN gctUINT32 Timeout
);
/*----------------------------------------------------------------------------*/
/*----- Memory Access and Cache ----------------------------------------------*/
/* Write a register. */
gceSTATUS
gcoOS_WriteRegister(
IN gcoOS Os,
IN gctUINT32 Address,
IN gctUINT32 Data
);
/* Read a register. */
gceSTATUS
gcoOS_ReadRegister(
IN gcoOS Os,
IN gctUINT32 Address,
OUT gctUINT32 * Data
);
gceSTATUS
gcoOS_CacheClean(
IN gcoOS Os,
IN gctUINT32 Node,
IN gctPOINTER Logical,
IN gctSIZE_T Bytes
);
gceSTATUS
gcoOS_CacheFlush(
IN gcoOS Os,
IN gctUINT32 Node,
IN gctPOINTER Logical,
IN gctSIZE_T Bytes
);
gceSTATUS
gcoOS_CacheInvalidate(
IN gcoOS Os,
IN gctUINT32 Node,
IN gctPOINTER Logical,
IN gctSIZE_T Bytes
);
gceSTATUS
gcoOS_MemoryBarrier(
IN gcoOS Os,
IN gctPOINTER Logical
);
gceSTATUS
gcoOS_CPUPhysicalToGPUPhysical(
IN gctPHYS_ADDR_T CPUPhysical,
OUT gctPHYS_ADDR_T * GPUPhysical
);
gceSTATUS
gcoOS_QuerySystemInfo(
IN gcoOS Os,
OUT gcsSystemInfo *Info
);
/*----------------------------------------------------------------------------*/
/*----- Profile --------------------------------------------------------------*/
gceSTATUS
gckOS_GetProfileTick(
OUT gctUINT64_PTR Tick
);
gceSTATUS
gckOS_QueryProfileTickRate(
OUT gctUINT64_PTR TickRate
);
gctUINT32
gckOS_ProfileToMS(
IN gctUINT64 Ticks
);
gceSTATUS
gcoOS_GetProfileTick(
OUT gctUINT64_PTR Tick
);
gceSTATUS
gcoOS_QueryProfileTickRate(
OUT gctUINT64_PTR TickRate
);
#if gcdSTATIC_LINK && defined(WIN32)
void gcoOS_ModuleConstructor(
void
);
void gcoOS_ModuleDestructor(
void
);
#endif
#define _gcmPROFILE_INIT(prefix, freq, start) \
do { \
prefix ## OS_QueryProfileTickRate(&(freq)); \
prefix ## OS_GetProfileTick(&(start)); \
} while (gcvFALSE)
#define _gcmPROFILE_QUERY(prefix, start, ticks) \
do { \
prefix ## OS_GetProfileTick(&(ticks)); \
(ticks) = ((ticks) > (start)) ? ((ticks) - (start)) \
: (~0ull - (start) + (ticks) + 1); \
} while (gcvFALSE)
#if gcdENABLE_PROFILING
# define gcmkPROFILE_INIT(freq, start) _gcmPROFILE_INIT(gck, freq, start)
# define gcmkPROFILE_QUERY(start, ticks) _gcmPROFILE_QUERY(gck, start, ticks)
# define gcmPROFILE_INIT(freq, start) _gcmPROFILE_INIT(gco, freq, start)
# define gcmPROFILE_QUERY(start, ticks) _gcmPROFILE_QUERY(gco, start, ticks)
# define gcmPROFILE_ONLY(x) x
# define gcmPROFILE_ELSE(x) do { } while (gcvFALSE)
# define gcmPROFILE_DECLARE_ONLY(x) x
# define gcmPROFILE_DECLARE_ELSE(x) typedef x
#else
# define gcmkPROFILE_INIT(start, freq) do { } while (gcvFALSE)
# define gcmkPROFILE_QUERY(start, ticks) do { } while (gcvFALSE)
# define gcmPROFILE_INIT(start, freq) do { } while (gcvFALSE)
# define gcmPROFILE_QUERY(start, ticks) do { } while (gcvFALSE)
# define gcmPROFILE_ONLY(x) do { } while (gcvFALSE)
# define gcmPROFILE_ELSE(x) x
# define gcmPROFILE_DECLARE_ONLY(x) do { } while (gcvFALSE)
# define gcmPROFILE_DECLARE_ELSE(x) x
#endif
/*******************************************************************************
** gcoMATH object
*/
#define gcdPI 3.14159265358979323846f
/* Kernel. */
gctINT
gckMATH_ModuloInt(
IN gctINT X,
IN gctINT Y
);
/* User. */
gctUINT32
gcoMATH_Log2in5dot5(
IN gctINT X
);
gctFLOAT
gcoMATH_UIntAsFloat(
IN gctUINT32 X
);
gctUINT32
gcoMATH_FloatAsUInt(
IN gctFLOAT X
);
gctBOOL
gcoMATH_CompareEqualF(
IN gctFLOAT X,
IN gctFLOAT Y
);
gctUINT16
gcoMATH_UInt8AsFloat16(
IN gctUINT8 X
);
gctUINT32
gcoMATH_Float16ToFloat(
IN gctUINT16 In
);
gctUINT16
gcoMATH_FloatToFloat16(
IN gctUINT32 In
);
gctUINT32
gcoMATH_Float11ToFloat(
IN gctUINT32 In
);
gctUINT16
gcoMATH_FloatToFloat11(
IN gctUINT32 In
);
gctUINT32
gcoMATH_Float10ToFloat(
IN gctUINT32 In
);
gctUINT16
gcoMATH_FloatToFloat10(
IN gctUINT32 In
);
gctUINT32
gcoMATH_Float14ToFloat(
IN gctUINT16 In
);
/******************************************************************************\
**************************** Coordinate Structures *****************************
\******************************************************************************/
typedef struct _gcsPOINT
{
gctINT32 x;
gctINT32 y;
}
gcsPOINT;
typedef struct _gcsSIZE
{
gctINT32 width;
gctINT32 height;
}
gcsSIZE;
typedef struct _gcsRECT
{
gctINT32 left;
gctINT32 top;
gctINT32 right;
gctINT32 bottom;
}
gcsRECT;
typedef struct _gcsPIXEL
{
union
{
struct
{
gctFLOAT r, g, b, a;
} f;
struct
{
gctINT32 r, g, b, a;
} i;
struct
{
gctUINT32 r, g, b, a;
} ui;
} color;
gctFLOAT d;
gctUINT32 s;
} gcsPIXEL;
/******************************************************************************\
********************************* gcoSURF Object ********************************
\******************************************************************************/
/*----------------------------------------------------------------------------*/
/*------------------------------- gcoSURF Common ------------------------------*/
/* Color format component parameters. */
typedef struct _gcsFORMAT_COMPONENT
{
gctUINT8 start;
gctUINT8 width;
}
gcsFORMAT_COMPONENT;
/* RGBA color format class. */
typedef struct _gcsFORMAT_CLASS_TYPE_RGBA
{
gcsFORMAT_COMPONENT alpha;
gcsFORMAT_COMPONENT red;
gcsFORMAT_COMPONENT green;
gcsFORMAT_COMPONENT blue;
}
gcsFORMAT_CLASS_TYPE_RGBA;
/* YUV color format class. */
typedef struct _gcsFORMAT_CLASS_TYPE_YUV
{
gcsFORMAT_COMPONENT y;
gcsFORMAT_COMPONENT u;
gcsFORMAT_COMPONENT v;
}
gcsFORMAT_CLASS_TYPE_YUV;
/* Index color format class. */
typedef struct _gcsFORMAT_CLASS_TYPE_INDEX
{
gcsFORMAT_COMPONENT value;
}
gcsFORMAT_CLASS_TYPE_INDEX;
/* Luminance color format class. */
typedef struct _gcsFORMAT_CLASS_TYPE_LUMINANCE
{
gcsFORMAT_COMPONENT alpha;
gcsFORMAT_COMPONENT value;
}
gcsFORMAT_CLASS_TYPE_LUMINANCE;
/* Bump map color format class. */
typedef struct _gcsFORMAT_CLASS_TYPE_BUMP
{
gcsFORMAT_COMPONENT alpha;
gcsFORMAT_COMPONENT l;
gcsFORMAT_COMPONENT v;
gcsFORMAT_COMPONENT u;
gcsFORMAT_COMPONENT q;
gcsFORMAT_COMPONENT w;
}
gcsFORMAT_CLASS_TYPE_BUMP;
/* Depth and stencil format class. */
typedef struct _gcsFORMAT_CLASS_TYPE_DEPTH
{
gcsFORMAT_COMPONENT depth;
gcsFORMAT_COMPONENT stencil;
}
gcsFORMAT_CLASS_TYPE_DEPTH;
typedef union _gcuPIXEL_FORMAT_CLASS
{
gcsFORMAT_CLASS_TYPE_BUMP bump;
gcsFORMAT_CLASS_TYPE_RGBA rgba;
gcsFORMAT_CLASS_TYPE_YUV yuv;
gcsFORMAT_CLASS_TYPE_LUMINANCE lum;
gcsFORMAT_CLASS_TYPE_INDEX index;
gcsFORMAT_CLASS_TYPE_DEPTH depth;
}
gcuPIXEL_FORMAT_CLASS;
/* Format parameters. */
typedef struct _gcsSURF_FORMAT_INFO
{
/* Name of the format */
gctCONST_STRING formatName;
/* Format code and class. */
gceSURF_FORMAT format;
gceFORMAT_CLASS fmtClass;
/* Format data type */
gceFORMAT_DATATYPE fmtDataType;
/* The size of one pixel in bits. */
gctUINT8 bitsPerPixel;
/* Pixel block dimensions. */
gctUINT blockWidth;
gctUINT blockHeight;
/* Pixel block size in bits. */
gctUINT blockSize;
/* Some formats are larger than what the GPU can support. */
/* These formats are read in the number of layers specified. */
gctUINT8 layers;
/* The format is faked and software will interpret it differently
** with HW. Most of them can't be blendable(PE) or filterable(TX).
*/
gctBOOL fakedFormat;
/* Some formats have two neighbour pixels interleaved together. */
/* To describe such format, set the flag to 1 and add another */
/* like this one describing the odd pixel format. */
gctBOOL interleaved;
/* sRGB format. */
gctBOOL sRGB;
/* How GPU read from big-endian host memory */
gceENDIAN_HINT endian;
/* Format components. */
gcuPIXEL_FORMAT_CLASS u;
/* Format components. */
gcuPIXEL_FORMAT_CLASS uOdd;
/* Render format. */
gceSURF_FORMAT closestRenderFormat;
/*gctCLOSEST_FORMAT dynamicClosestRenderFormat;*/
gctUINT renderFormat;
const gceTEXTURE_SWIZZLE * pixelSwizzle;
/* Texture format. */
gceSURF_FORMAT closestTXFormat;
gctUINT txFormat;
const gceTEXTURE_SWIZZLE * txSwizzle;
gctBOOL txIntFilter;
}
gcsSURF_FORMAT_INFO;
/* Frame buffer information. */
typedef struct _gcsSURF_FRAMEBUFFER
{
gctPOINTER logical;
gctUINT width, height;
gctINT stride;
gceSURF_FORMAT format;
}
gcsSURF_FRAMEBUFFER;
/* Generic pixel component descriptors. */
extern gcsFORMAT_COMPONENT gcvPIXEL_COMP_XXX8;
extern gcsFORMAT_COMPONENT gcvPIXEL_COMP_XX8X;
extern gcsFORMAT_COMPONENT gcvPIXEL_COMP_X8XX;
extern gcsFORMAT_COMPONENT gcvPIXEL_COMP_8XXX;
/* Construct a new gcoSURF object. */
gceSTATUS
gcoSURF_Construct(
IN gcoHAL Hal,
IN gctUINT Width,
IN gctUINT Height,
IN gctUINT Depth,
IN gceSURF_TYPE Type,
IN gceSURF_FORMAT Format,
IN gcePOOL Pool,
OUT gcoSURF * Surface
);
/* Destroy an gcoSURF object. */
gceSTATUS
gcoSURF_Destroy(
IN gcoSURF Surface
);
/* Map user-allocated surface. */
gceSTATUS
gcoSURF_MapUserSurface(
IN gcoSURF Surface,
IN gctUINT Alignment,
IN gctPOINTER Logical,
IN gctPHYS_ADDR_T Physical
);
/* Wrapp surface with known logical/GPU address */
gceSTATUS
gcoSURF_WrapSurface(
IN gcoSURF Surface,
IN gctUINT Alignment,
IN gctPOINTER Logical,
IN gctUINT32 Address
);
/* Query vid mem node info. */
gceSTATUS
gcoSURF_QueryVidMemNode(
IN gcoSURF Surface,
OUT gctUINT32 * Node,
OUT gcePOOL * Pool,
OUT gctSIZE_T_PTR Bytes,
OUT gctUINT32 * TsNode,
OUT gcePOOL * TsPool,
OUT gctSIZE_T_PTR TsBytes
);
/* Set the color type of the surface. */
gceSTATUS
gcoSURF_SetColorType(
IN gcoSURF Surface,
IN gceSURF_COLOR_TYPE ColorType
);
/* Get the color type of the surface. */
gceSTATUS
gcoSURF_GetColorType(
IN gcoSURF Surface,
OUT gceSURF_COLOR_TYPE *ColorType
);
/* Set the color space of the surface. */
gceSTATUS
gcoSURF_SetColorSpace(
IN gcoSURF Surface,
IN gceSURF_COLOR_SPACE ColorSpace
);
/* Get the color space of the surface. */
gceSTATUS
gcoSURF_GetColorSpace(
IN gcoSURF Surface,
OUT gceSURF_COLOR_SPACE *ColorSpace
);
/* Set the surface ration angle. */
gceSTATUS
gcoSURF_SetRotation(
IN gcoSURF Surface,
IN gceSURF_ROTATION Rotation
);
gceSTATUS
gcoSURF_IsValid(
IN gcoSURF Surface
);
#if gcdENABLE_3D
/* Verify and return the state of the tile status mechanism. */
gceSTATUS
gcoSURF_IsTileStatusSupported(
IN gcoSURF Surface
);
/* Verify if surface has tile status enabled. */
gceSTATUS
gcoSURF_IsTileStatusEnabled(
IN gcsSURF_VIEW *SurfView
);
/* Verify if surface is compressed. */
gceSTATUS
gcoSURF_IsCompressed(
IN gcsSURF_VIEW *SurfView
);
/* Enable tile status for the specified surface on zero slot. */
gceSTATUS
gcoSURF_EnableTileStatus(
IN gcsSURF_VIEW *Surface
);
/* Enable tile status for the specified surface on specified slot. */
gceSTATUS
gcoSURF_EnableTileStatusEx(
IN gcsSURF_VIEW *surfView,
IN gctUINT RtIndex
);
/* Disable tile status for the specified surface. */
gceSTATUS
gcoSURF_DisableTileStatus(
IN gcsSURF_VIEW *SurfView,
IN gctBOOL Decompress
);
/* Flush tile status cache for the specified surface. */
gceSTATUS
gcoSURF_FlushTileStatus(
IN gcsSURF_VIEW *SurfView,
IN gctBOOL Decompress
);
#endif /* gcdENABLE_3D */
/* Get surface size. */
gceSTATUS
gcoSURF_GetSize(
IN gcoSURF Surface,
OUT gctUINT * Width,
OUT gctUINT * Height,
OUT gctUINT * Depth
);
/* Get surface information */
gceSTATUS
gcoSURF_GetInfo(
IN gcoSURF Surface,
IN gceSURF_INFO_TYPE InfoType,
IN OUT gctINT32 *Value
);
/* Get surface aligned sizes. */
gceSTATUS
gcoSURF_GetAlignedSize(
IN gcoSURF Surface,
OUT gctUINT * Width,
OUT gctUINT * Height,
OUT gctINT * Stride
);
/* Get alignments. */
gceSTATUS
gcoSURF_GetAlignment(
IN gceSURF_TYPE Type,
IN gceSURF_FORMAT Format,
OUT gctUINT * AddressAlignment,
OUT gctUINT * XAlignment,
OUT gctUINT * YAlignment
);
gceSTATUS
gcoSURF_AlignResolveRect(
IN gcoSURF Surf,
IN gcsPOINT_PTR RectOrigin,
IN gcsPOINT_PTR RectSize,
OUT gcsPOINT_PTR AlignedOrigin,
OUT gcsPOINT_PTR AlignedSize
);
/* Get surface type and format. */
gceSTATUS
gcoSURF_GetFormat(
IN gcoSURF Surface,
OUT OPTIONAL gceSURF_TYPE * Type,
OUT OPTIONAL gceSURF_FORMAT * Format
);
/* Get surface information */
gceSTATUS
gcoSURF_GetFormatInfo(
IN gcoSURF Surface,
OUT gcsSURF_FORMAT_INFO_PTR * formatInfo
);
/* Get Surface pack format */
gceSTATUS
gcoSURF_GetPackedFormat(
IN gcoSURF Surface,
OUT gceSURF_FORMAT * Format
);
/* Get surface tiling. */
gceSTATUS
gcoSURF_GetTiling(
IN gcoSURF Surface,
OUT gceTILING * Tiling
);
/* Get bottom buffer offset bytes. */
gceSTATUS
gcoSURF_GetBottomBufferOffset(
IN gcoSURF Surface,
OUT gctUINT_PTR BottomBufferOffset
);
/* Lock the surface. */
gceSTATUS
gcoSURF_Lock(
IN gcoSURF Surface,
IN OUT gctUINT32 * Address,
IN OUT gctPOINTER * Memory
);
/* Unlock the surface. */
gceSTATUS
gcoSURF_Unlock(
IN gcoSURF Surface,
IN gctPOINTER Memory
);
/*. Query surface flags.*/
gceSTATUS
gcoSURF_QueryFlags(
IN gcoSURF Surface,
IN gceSURF_FLAG Flag
);
gceSTATUS
gcoSURF_QueryHints(
IN gcoSURF Surface,
IN gceSURF_TYPE Hints
);
/* Return pixel format parameters; Info is required to be a pointer to an
* array of at least two items because some formats have up to two records
* of description. */
gceSTATUS
gcoSURF_QueryFormat(
IN gceSURF_FORMAT Format,
OUT gcsSURF_FORMAT_INFO_PTR * Info
);
/* Compute the color pixel mask. */
gceSTATUS
gcoSURF_ComputeColorMask(
IN gcsSURF_FORMAT_INFO_PTR Format,
OUT gctUINT32_PTR ColorMask
);
/* Flush the surface. */
gceSTATUS
gcoSURF_Flush(
IN gcoSURF Surface
);
/* Fill surface from it's tile status buffer. */
gceSTATUS
gcoSURF_FillFromTile(
IN gcsSURF_VIEW *SurView
);
/* Fill surface with a value. */
gceSTATUS
gcoSURF_Fill(
IN gcoSURF Surface,
IN gcsPOINT_PTR Origin,
IN gcsSIZE_PTR Size,
IN gctUINT32 Value,
IN gctUINT32 Mask
);
/* Alpha blend two surfaces together. */
gceSTATUS
gcoSURF_Blend(
IN gcoSURF SrcSurf,
IN gcoSURF DstSurf,
IN gcsPOINT_PTR SrcOrigin,
IN gcsPOINT_PTR DstOrigin,
IN gcsSIZE_PTR Size,
IN gceSURF_BLEND_MODE Mode
);
/* Create a new gcoSURF wrapper object. */
gceSTATUS
gcoSURF_ConstructWrapper(
IN gcoHAL Hal,
OUT gcoSURF * Surface
);
/* Set surface flags.*/
gceSTATUS
gcoSURF_SetFlags(
IN gcoSURF Surface,
IN gceSURF_FLAG Flag,
IN gctBOOL Value
);
/* Set the underlying buffer for the surface wrapper. */
gceSTATUS
gcoSURF_SetBuffer(
IN gcoSURF Surface,
IN gceSURF_TYPE Type,
IN gceSURF_FORMAT Format,
IN gctUINT Stride,
IN gctPOINTER Logical,
IN gctUINT64 Physical
);
/* Set the size of the surface in pixels and map the underlying buffer. */
gceSTATUS
gcoSURF_SetWindow(
IN gcoSURF Surface,
IN gctUINT X,
IN gctUINT Y,
IN gctUINT Width,
IN gctUINT Height
);
/* Set the size of the surface in pixels and map the underlying buffer. */
gceSTATUS
gcoSURF_SetImage(
IN gcoSURF Surface,
IN gctUINT X,
IN gctUINT Y,
IN gctUINT Width,
IN gctUINT Height,
IN gctUINT Depth
);
/* Set width/height alignment of the surface directly and calculate stride/size. This is only for dri backend now. Please be careful before use. */
gceSTATUS
gcoSURF_SetAlignment(
IN gcoSURF Surface,
IN gctUINT Width,
IN gctUINT Height
);
/* Increase reference count of the surface. */
gceSTATUS
gcoSURF_ReferenceSurface(
IN gcoSURF Surface
);
/* Get surface reference count. */
gceSTATUS
gcoSURF_QueryReferenceCount(
IN gcoSURF Surface,
OUT gctINT32 * ReferenceCount
);
/* Set surface orientation. */
gceSTATUS
gcoSURF_SetOrientation(
IN gcoSURF Surface,
IN gceORIENTATION Orientation
);
/* Query surface orientation. */
gceSTATUS
gcoSURF_QueryOrientation(
IN gcoSURF Surface,
OUT gceORIENTATION * Orientation
);
gceSTATUS
gcoSURF_NODE_Cache(
IN gcsSURF_NODE_PTR Node,
IN gctPOINTER Logical,
IN gctSIZE_T Bytes,
IN gceCACHEOPERATION Operation
);
gceSTATUS
gcsSURF_NODE_SetHardwareAddress(
IN gcsSURF_NODE_PTR Node,
IN gctUINT32 Address
);
gceSTATUS
gcsSURF_NODE_GetHardwareAddress(
IN gcsSURF_NODE_PTR Node,
OUT gctUINT32_PTR Physical,
OUT gctUINT32_PTR Physical2,
OUT gctUINT32_PTR Physical3,
OUT gctUINT32_PTR PhysicalBottom
);
gctUINT32
gcsSURF_NODE_GetHWAddress(
IN gcsSURF_NODE_PTR Node
);
/* Lock and unlock surface node */
gceSTATUS
gcoSURF_LockNode(
IN gcsSURF_NODE_PTR Node,
OUT gctUINT32 * Address,
OUT gctPOINTER * Memory
);
gceSTATUS
gcoSURF_UnLockNode(
IN gcsSURF_NODE_PTR Node,
IN gceSURF_TYPE Type
);
/* Perform CPU cache operation on surface node */
gceSTATUS
gcoSURF_NODE_CPUCacheOperation(
IN gcsSURF_NODE_PTR Node,
IN gceSURF_TYPE Type,
IN gctSIZE_T Offset,
IN gctSIZE_T Length,
IN gceCACHEOPERATION Operation
);
/* Perform CPU cache operation on surface */
gceSTATUS
gcoSURF_CPUCacheOperation(
IN gcoSURF Surface,
IN gceCACHEOPERATION Operation
);
gceSTATUS
gcoSURF_Swap(
IN gcoSURF Surface1,
IN gcoSURF Surface2
);
gceSTATUS
gcoSURF_ResetSurWH(
IN gcoSURF Surface,
IN gctUINT oriw,
IN gctUINT orih,
IN gctUINT alignw,
IN gctUINT alignh,
IN gceSURF_FORMAT fmt
);
/* Update surface timestamp. */
gceSTATUS
gcoSURF_UpdateTimeStamp(
IN gcoSURF Surface
);
/* Query surface current timestamp. */
gceSTATUS
gcoSURF_QueryTimeStamp(
IN gcoSURF Surface,
OUT gctUINT64 * TimeStamp
);
/*
* Allocate shared buffer for this surface, so that
* surface states can be shared across processes.
*/
gceSTATUS
gcoSURF_AllocShBuffer(
IN gcoSURF Surface,
OUT gctSHBUF * ShBuf
);
/* Bind shared buffer to this surface */
gceSTATUS
gcoSURF_BindShBuffer(
IN gcoSURF Surface,
IN gctSHBUF ShBuf
);
/* Push surface shared states to shared buffer. */
gceSTATUS
gcoSURF_PushSharedInfo(
IN gcoSURF Surface
);
/* Pop shared states from shared buffer. */
gceSTATUS
gcoSURF_PopSharedInfo(
IN gcoSURF Surface
);
#if (gcdENABLE_3D)
/* Copy surface. */
gceSTATUS
gcoSURF_Copy(
IN gcoSURF Surface,
IN gcoSURF Source
);
/* Set number of samples for a gcoSURF object. */
gceSTATUS
gcoSURF_SetSamples(
IN gcoSURF Surface,
IN gctUINT Samples
);
/* Get the number of samples per pixel. */
gceSTATUS
gcoSURF_GetSamples(
IN gcoSURF Surface,
OUT gctUINT_PTR Samples
);
/* Append tile status buffer to user pool surface. */
gceSTATUS
gcoSURF_AppendTileStatus(
IN gcoSURF Surface
);
#endif
gceSTATUS
gcoSURF_WrapUserMemory(
IN gcoHAL Hal,
IN gctUINT Width,
IN gctUINT Height,
IN gctUINT Stride,
IN gctUINT Depth,
IN gceSURF_TYPE Type,
IN gceSURF_FORMAT Format,
IN gctUINT32 Handle,
IN gctUINT32 Flag,
OUT gcoSURF * Surface
);
gceSTATUS
gcoSURF_WrapUserMultiBuffer(
IN gcoHAL Hal,
IN gctUINT Width,
IN gctUINT Height,
IN gceSURF_TYPE Type,
IN gceSURF_FORMAT Format,
IN gctUINT Stride[3],
IN gctUINT32 Handle[3],
IN gctUINT BufferOffset[3],
IN gctUINT32 Flag,
OUT gcoSURF * Surface
);
gceSTATUS
gcoSURF_UpdateMetadata(
IN gcoSURF Surface,
IN gctINT TsFD
);
#define MAX_SURF_MIX_SRC_NUM 64
gceSTATUS
gcoSURF_MixSurfacesCPU(
IN gcoSURF TargetSurface,
IN gctUINT TargetSliceIndex,
IN gcoSURF *SourceSurface,
IN gctUINT *SourceSliceIndices,
IN gctFLOAT *Weights,
IN gctINT Count
);
/******************************************************************************\
******************************* Hash Structure ******************************
\******************************************************************************/
typedef struct _gcsHASH_MD5CTX
{
gctBOOL bigEndian;
gctSIZE_T bytes; /* Number of bytes processed */
gctUINT32 states[4];
gctUINT8 buffer[64];
} gcsHASH_MD5CTX;
void gcsHASH_MD5Init(
gcsHASH_MD5CTX *ctx
);
void gcsHASH_MD5Update(
gcsHASH_MD5CTX *ctx,
const void *data,
gctSIZE_T bytes
);
void gcsHASH_MD5Final(
gcsHASH_MD5CTX *ctx,
gctUINT8 digest[16]
);
/******************************************************************************\
******************************* gcsRECT Structure ******************************
\******************************************************************************/
/* Initialize rectangle structure. */
gceSTATUS
gcsRECT_Set(
OUT gcsRECT_PTR Rect,
IN gctINT32 Left,
IN gctINT32 Top,
IN gctINT32 Right,
IN gctINT32 Bottom
);
/* Return the width of the rectangle. */
gceSTATUS
gcsRECT_Width(
IN gcsRECT_PTR Rect,
OUT gctINT32 * Width
);
/* Return the height of the rectangle. */
gceSTATUS
gcsRECT_Height(
IN gcsRECT_PTR Rect,
OUT gctINT32 * Height
);
/* Ensure that top left corner is to the left and above the right bottom. */
gceSTATUS
gcsRECT_Normalize(
IN OUT gcsRECT_PTR Rect
);
/* Compare two rectangles. */
gceSTATUS
gcsRECT_IsEqual(
IN gcsRECT_PTR Rect1,
IN gcsRECT_PTR Rect2,
OUT gctBOOL * Equal
);
/* Compare the sizes of two rectangles. */
gceSTATUS
gcsRECT_IsOfEqualSize(
IN gcsRECT_PTR Rect1,
IN gcsRECT_PTR Rect2,
OUT gctBOOL * EqualSize
);
gceSTATUS
gcsRECT_RelativeRotation(
IN gceSURF_ROTATION Orientation,
IN OUT gceSURF_ROTATION *Relation);
gceSTATUS
gcsRECT_Rotate(
IN OUT gcsRECT_PTR Rect,
IN gceSURF_ROTATION Rotation,
IN gceSURF_ROTATION toRotation,
IN gctINT32 SurfaceWidth,
IN gctINT32 SurfaceHeight
);
/******************************************************************************\
**************************** gcsBOUNDARY Structure *****************************
\******************************************************************************/
typedef struct _gcsBOUNDARY
{
gctINT x;
gctINT y;
gctINT width;
gctINT height;
}
gcsBOUNDARY;
/******************************************************************************\
********************************* gcoHEAP Object ********************************
\******************************************************************************/
typedef struct _gcoHEAP * gcoHEAP;
/* Construct a new gcoHEAP object. */
gceSTATUS
gcoHEAP_Construct(
IN gcoOS Os,
IN gctSIZE_T AllocationSize,
OUT gcoHEAP * Heap
);
/* Destroy an gcoHEAP object. */
gceSTATUS
gcoHEAP_Destroy(
IN gcoHEAP Heap
);
/* Allocate memory. */
gceSTATUS
gcoHEAP_Allocate(
IN gcoHEAP Heap,
IN gctSIZE_T Bytes,
OUT gctPOINTER * Node
);
gceSTATUS
gcoHEAP_GetMemorySize(
IN gcoHEAP Heap,
IN gctPOINTER Memory,
OUT gctSIZE_T_PTR MemorySize
);
/* Free memory. */
gceSTATUS
gcoHEAP_Free(
IN gcoHEAP Heap,
IN gctPOINTER Node
);
#if (VIVANTE_PROFILER_SYSTEM_MEMORY || gcdDEBUG)
/* Profile the heap. */
gceSTATUS
gcoHEAP_ProfileStart(
IN gcoHEAP Heap
);
gceSTATUS
gcoHEAP_ProfileEnd(
IN gcoHEAP Heap,
IN gctCONST_STRING Title
);
#endif
/******************************************************************************\
******************************* Debugging Macros *******************************
\******************************************************************************/
void
gcoOS_SetDebugLevel(
IN gctUINT32 Level
);
void
gcoOS_GetDebugLevel(
OUT gctUINT32_PTR DebugLevel
);
void
gcoOS_GetDebugZone(
IN gctUINT32 Zone,
OUT gctUINT32_PTR DebugZone
);
void
gcoOS_SetDebugZone(
IN gctUINT32 Zone
);
void
gcoOS_SetDebugFile(
IN gctCONST_STRING FileName
);
void
gcoOS_EnableDebugDump(
IN gctBOOL Enable
);
gctFILE
gcoOS_ReplaceDebugFile(
IN gctFILE fp
);
/*******************************************************************************
**
** gcmFATAL
**
** Print a message to the debugger and execute a break point.
**
** ARGUMENTS:
**
** message Message.
** ... Optional arguments.
*/
void
gckOS_DebugFatal(
IN gctCONST_STRING Message,
...
);
void
gcoOS_DebugFatal(
IN gctCONST_STRING Message,
...
);
#if gcmIS_DEBUG(gcdDEBUG_FATAL)
# define gcmFATAL gcoOS_DebugFatal
# define gcmkFATAL gckOS_DebugFatal
#elif gcdHAS_ELLIPSIS
# define gcmFATAL(...)
# define gcmkFATAL(...)
#else
gcmINLINE static void
__dummy_fatal(
IN gctCONST_STRING Message,
...
)
{
}
# define gcmFATAL __dummy_fatal
# define gcmkFATAL __dummy_fatal
#endif
#define gcmENUM2TEXT(e) case e: return #e
/*******************************************************************************
**
** gcmTRACE
**
** Print a message to the debugfer if the correct level has been set. In
** retail mode this macro does nothing.
**
** ARGUMENTS:
**
** level Level of message.
** message Message.
** ... Optional arguments.
*/
#define gcvLEVEL_NONE -1
#define gcvLEVEL_ERROR 0
#define gcvLEVEL_WARNING 1
#define gcvLEVEL_INFO 2
#define gcvLEVEL_VERBOSE 3
void
gckOS_DebugTrace(
IN gctUINT32 Level,
IN gctCONST_STRING Message,
...
);
void
gcoOS_DebugTrace(
IN gctUINT32 Level,
IN gctCONST_STRING Message,
...
);
#if gcmIS_DEBUG(gcdDEBUG_TRACE)
# define gcmTRACE gcoOS_DebugTrace
# define gcmkTRACE gckOS_DebugTrace
# define gcmkTRACE_N(Level, ArgumentSize, ...) \
gckOS_DebugTrace(Level, __VA_ARGS__)
#elif gcdHAS_ELLIPSIS
# define gcmTRACE(...)
# define gcmkTRACE(...)
# define gcmkTRACE_N(...)
#else
gcmINLINE static void
__dummy_trace(
IN gctUINT32 Level,
IN gctCONST_STRING Message,
...
)
{
}
gcmINLINE static void
__dummy_trace_n(
IN gctUINT32 Level,
IN gctUINT ArgumentSize,
IN gctCONST_STRING Message,
...
)
{
}
# define gcmTRACE __dummy_trace
# define gcmkTRACE __dummy_trace
# define gcmkTRACE_N __dummy_trace_n
#endif
/*******************************************************************************
**
** gcmTRACE_ZONE
**
** Print a message to the debugger if the correct level and zone has been
** set. In retail mode this macro does nothing.
**
** ARGUMENTS:
**
** Level Level of message.
** Zone Zone of message.
** Message Message.
** ... Optional arguments.
*/
void
gckOS_DebugTraceZone(
IN gctUINT32 Level,
IN gctUINT32 Zone,
IN gctCONST_STRING Message,
...
);
void
gcoOS_DebugTraceZone(
IN gctUINT32 Level,
IN gctUINT32 Zone,
IN gctCONST_STRING Message,
...
);
#if gcmIS_DEBUG(gcdDEBUG_TRACE)
# define gcmTRACE_ZONE gcoOS_DebugTraceZone
# define gcmkTRACE_ZONE gckOS_DebugTraceZone
# define gcmkTRACE_ZONE_N(Level, Zone, ArgumentSize, ...) \
gckOS_DebugTraceZone(Level, Zone, __VA_ARGS__)
#elif gcdHAS_ELLIPSIS
# define gcmTRACE_ZONE(...)
# define gcmkTRACE_ZONE(...)
# define gcmkTRACE_ZONE_N(...)
#else
gcmINLINE static void
__dummy_trace_zone(
IN gctUINT32 Level,
IN gctUINT32 Zone,
IN gctCONST_STRING Message,
...
)
{
}
gcmINLINE static void
__dummy_trace_zone_n(
IN gctUINT32 Level,
IN gctUINT32 Zone,
IN gctUINT ArgumentSize,
IN gctCONST_STRING Message,
...
)
{
}
# define gcmTRACE_ZONE __dummy_trace_zone
# define gcmkTRACE_ZONE __dummy_trace_zone
# define gcmkTRACE_ZONE_N __dummy_trace_zone_n
#endif
/*******************************************************************************
**
** gcmDEBUG_ONLY
**
** Execute a statement or function only in DEBUG mode.
**
** ARGUMENTS:
**
** f Statement or function to execute.
*/
#if gcmIS_DEBUG(gcdDEBUG_CODE)
# define gcmDEBUG_ONLY(f) f
#else
# define gcmDEBUG_ONLY(f)
#endif
/*******************************************************************************
**
** gcmSTACK_PUSH
** gcmSTACK_POP
** gcmSTACK_DUMP
** gcmSTACK_REMOVE
**
** Push or pop a function with entry arguments on the trace stack.
**
** ARGUMENTS:
**
** Function Name of function.
** Line Line number.
** Text Optional text.
** ... Optional arguments for text.
**
** Thread Thread id.
*/
void
gcoOS_StackPush(
IN gctINT8_PTR Identity,
IN gctCONST_STRING Function,
IN gctINT Line,
IN gctCONST_STRING Text,
...
);
void
gcoOS_StackPop(
IN gctINT8_PTR Identity,
IN gctCONST_STRING Function
);
void
gcoOS_StackDump(
void);
void
gcoOS_StackRemove(
IN gctHANDLE Thread
);
#if gcmIS_DEBUG(gcdDEBUG_STACK)
# define gcmSTACK_PUSH gcoOS_StackPush
# define gcmSTACK_POP gcoOS_StackPop
# define gcmSTACK_DUMP gcoOS_StackDump
# define gcmSTACK_REMOVE gcoOS_StackRemove
#elif gcdHAS_ELLIPSIS
# define gcmSTACK_PUSH(...)
# define gcmSTACK_POP(...)
# define gcmSTACK_DUMP()
# define gcmSTACK_REMOVE(...)
#else
gcmINLINE static void
__dummy_stack_push(
IN gctCONST_STRING Function,
IN gctINT Line,
IN gctCONST_STRING Text,
...
)
{
}
gcmINLINE static void
__dummy_stack_pop(
IN gctINT8_PTR Identity,
IN gctCONST_STRING Function
);
gcmINLINE static void
__dummy_stack_remove(
IN gctHANDLE Thread
);
# define gcmSTACK_PUSH __dummy_stack_push
# define gcmSTACK_POP(a,b) __dummy_stack_pop
# define gcmSTACK_DUMP()
# define gcmSTACK_REMOVE(a) __dummy_stack_remove
#endif
/*******************************************************************************
**
** gcmBINARY_TRACE
**
** Push or pop a function with entry arguments on the trace stack.
**
** ARGUMENTS:
**
** Function Name of function
** Line Line number
** Text Optional text
** ... Optional arguments for text.
*/
void
gcoOS_BinaryTrace(
IN gctCONST_STRING Function,
IN gctINT Line,
IN gctCONST_STRING Text OPTIONAL,
...
);
void
gckOS_BinaryTrace(
IN gctCONST_STRING Function,
IN gctINT Line,
IN gctCONST_STRING Text OPTIONAL,
...
);
#if gcdBINARY_TRACE
# define gcmBINARY_TRACE gcoOS_BinaryTrace
# define gcmkBINARY_TRACE gckOS_BinaryTrace
#elif gcdHAS_ELLIPSIS
# define gcmBINARY_TRACE(Function, Line, Text, ...)
# define gcmkBINARY_TRACE(Function, Line, Text, ...)
#else
gcmINLINE static void
__dummy_binary_trace(
IN gctCONST_STRING Function,
IN gctINT Line,
IN gctCONST_STRING Text,
)
{
}
# define gcmBINARY_TRACE __dummy_binary_trace
# define gcmkBINARY_TRACE __dummy_binary_trace
#endif
/*******************************************************************************
**
** gcmSYSTRACE_BEGIN
** gcmSYSTRACE_END
**
** Systrace is a performance tunning tool on linux.
**
** ARGUMENTS:
**
** FuncName Function name
** Zone Systrace zone. Only specified zones are traced.
*/
void
gcoOS_SysTraceBegin(
IN gctUINT32 Zone,
IN gctCONST_STRING FuncName
);
void
gcoOS_SysTraceEnd(
IN gctUINT32 Zone
);
#if defined(LINUX) && gcdSYSTRACE
# define gcmSYSTRACE_BEGIN gcoOS_SysTraceBegin
# define gcmSYSTRACE_END gcoOS_SysTraceEnd
#elif gcdHAS_ELLIPSIS
# define gcmSYSTRACE_BEGIN(...)
# define gcmSYSTRACE_END(...)
#else
gcmINLINE static void
__dummy_systrace_begin(
IN gctUINT32 Zone,
IN gctCONST_STRING FuncName
)
{
}
gcmINLINE static void
__dummy_systrace_end(
IN gctUINT32 Zone
)
{
}
# define gcmSYSTRACE_BEGIN __dummy_systrace_begin
# define gcmSYSTRACE_END __dummy_systrace_end
#endif
/******************************************************************************\
******************************** Logging Macros ********************************
\******************************************************************************/
#define gcdHEADER_LEVEL gcvLEVEL_VERBOSE
/* Always enable header/footer when systrace build is on */
#if defined(LINUX) && gcdSYSTRACE
#undef gcdEMPTY_HEADER_FOOTER
#endif
#ifndef gcdEMPTY_HEADER_FOOTER
#define gcdEMPTY_HEADER_FOOTER 0
#endif
#if gcdENABLE_PROFILING
void
gcoOS_ProfileDB(
IN gctCONST_STRING Function,
IN OUT gctBOOL_PTR Initialized
);
#define gcmHEADER() \
gctINT8 __user__ = 1; \
static gctBOOL __profile__initialized__ = gcvFALSE; \
gcmSTACK_PUSH(&__user__, __FUNCTION__, __LINE__, gcvNULL, gcvNULL); \
gcoOS_ProfileDB(__FUNCTION__, &__profile__initialized__)
#define gcmHEADER_ARG(...) \
gctINT8 __user__ = 1; \
static gctBOOL __profile__initialized__ = gcvFALSE; \
gcmSTACK_PUSH(&__user__, __FUNCTION__, __LINE__, Text, __VA_ARGS__); \
gcoOS_ProfileDB(__FUNCTION__, &__profile__initialized__)
#define gcmFOOTER() \
gcmSTACK_POP(&__user__, __FUNCTION__); \
gcoOS_ProfileDB(__FUNCTION__, gcvNULL)
#define gcmFOOTER_NO() \
gcmSTACK_POP(&__user__, __FUNCTION__); \
gcoOS_ProfileDB(__FUNCTION__, gcvNULL)
#define gcmFOOTER_ARG(...) \
gcmSTACK_POP(&__user__, __FUNCTION__); \
gcoOS_ProfileDB(__FUNCTION__, gcvNULL)
#define gcmFOOTER_KILL() \
gcmSTACK_POP(&__user__, __FUNCTION__); \
gcoOS_ProfileDB(gcvNULL, gcvNULL)
#else /* !gcdENABLE_PROFILING */
#if gcdEMPTY_HEADER_FOOTER
# define gcmHEADER()
#elif gcdHAS_ELLIPSIS
#define gcmHEADER() \
gctINT8 __user__ = 1; \
gctINT8_PTR __user_ptr__ = &__user__; \
gcmSTACK_PUSH(__user_ptr__, __FUNCTION__, __LINE__, gcvNULL, gcvNULL); \
gcmSYSTRACE_BEGIN(_GC_OBJ_ZONE, __FUNCTION__); \
gcmBINARY_TRACE(__FUNCTION__, __LINE__, gcvNULL, gcvNULL); \
gcmTRACE_ZONE(gcdHEADER_LEVEL, _GC_OBJ_ZONE, \
"++%s(%d)", __FUNCTION__, __LINE__)
#else
gcmINLINE static void
__dummy_header(void)
{
}
# define gcmHEADER __dummy_header
#endif
#if gcdHAS_ELLIPSIS
#if gcdEMPTY_HEADER_FOOTER
# define gcmHEADER_ARG(Text, ...)
#else
# define gcmHEADER_ARG(Text, ...) \
gctINT8 __user__ = 1; \
gctINT8_PTR __user_ptr__ = &__user__; \
gcmSTACK_PUSH(__user_ptr__, __FUNCTION__, __LINE__, Text, __VA_ARGS__); \
gcmSYSTRACE_BEGIN(_GC_OBJ_ZONE, __FUNCTION__); \
gcmBINARY_TRACE(__FUNCTION__, __LINE__, Text, __VA_ARGS__); \
gcmTRACE_ZONE(gcdHEADER_LEVEL, _GC_OBJ_ZONE, \
"++%s(%d): " Text, __FUNCTION__, __LINE__, __VA_ARGS__)
#endif
#else
gcmINLINE static void
__dummy_header_arg(
IN gctCONST_STRING Text,
...
)
{
}
# define gcmHEADER_ARG __dummy_header_arg
#endif
#if gcdEMPTY_HEADER_FOOTER
# define gcmFOOTER()
#elif gcdHAS_ELLIPSIS
# define gcmFOOTER() \
gcmSTACK_POP(__user_ptr__, __FUNCTION__); \
gcmSYSTRACE_END(_GC_OBJ_ZONE); \
gcmBINARY_TRACE(__FUNCTION__, __LINE__, gcvNULL, gcvNULL); \
gcmTRACE_ZONE(gcdHEADER_LEVEL, _GC_OBJ_ZONE, \
"--%s(%d): status=%d(%s)", \
__FUNCTION__, __LINE__, \
status, gcoOS_DebugStatus2Name(status)); \
*__user_ptr__ -= 1
#else
gcmINLINE static void
__dummy_footer(void)
{
}
# define gcmFOOTER __dummy_footer
#endif
#if gcdEMPTY_HEADER_FOOTER
# define gcmFOOTER_NO()
#elif gcdHAS_ELLIPSIS
#define gcmFOOTER_NO() \
gcmSTACK_POP(__user_ptr__, __FUNCTION__); \
gcmSYSTRACE_END(_GC_OBJ_ZONE); \
gcmBINARY_TRACE(__FUNCTION__, __LINE__, gcvNULL, gcvNULL); \
gcmTRACE_ZONE(gcdHEADER_LEVEL, _GC_OBJ_ZONE, \
"--%s(%d)", __FUNCTION__, __LINE__); \
*__user_ptr__ -= 1
#else
gcmINLINE static void
__dummy_footer_no(void)
{
}
# define gcmFOOTER_NO __dummy_footer_no
#endif
#if gcdEMPTY_HEADER_FOOTER
# define gcmFOOTER_KILL()
#elif gcdHAS_ELLIPSIS
#define gcmFOOTER_KILL() \
gcmSTACK_POP(__user_ptr__, __FUNCTION__); \
gcmSYSTRACE_END(_GC_OBJ_ZONE); \
gcmBINARY_TRACE(__FUNCTION__, __LINE__, gcvNULL, gcvNULL); \
gcmTRACE_ZONE(gcdHEADER_LEVEL, _GC_OBJ_ZONE, \
"--%s(%d)", __FUNCTION__, __LINE__); \
*__user_ptr__ -= 1
#else
gcmINLINE static void
__dummy_footer_kill(void)
{
}
# define gcmFOOTER_KILL __dummy_footer_kill
#endif
#if gcdHAS_ELLIPSIS
#if gcdEMPTY_HEADER_FOOTER
# define gcmFOOTER_ARG(Text, ...)
#else
# define gcmFOOTER_ARG(Text, ...) \
gcmSTACK_POP(__user_ptr__, __FUNCTION__); \
gcmSYSTRACE_END(_GC_OBJ_ZONE); \
gcmBINARY_TRACE(__FUNCTION__, __LINE__, Text, __VA_ARGS__); \
gcmTRACE_ZONE(gcdHEADER_LEVEL, _GC_OBJ_ZONE, \
"--%s(%d): " Text, __FUNCTION__, __LINE__, __VA_ARGS__); \
*__user_ptr__ -= 1
#endif
#else
gcmINLINE static void
__dummy_footer_arg(
IN gctCONST_STRING Text,
...
)
{
}
# define gcmFOOTER_ARG __dummy_footer_arg
#endif
#endif /* gcdENABLE_PROFILING */
#if gcdHAS_ELLIPSIS
#define gcmkHEADER() \
gctINT8 __kernel__ = 1; \
gctINT8_PTR __kernel_ptr__ = &__kernel__; \
gcmkBINARY_TRACE(__FUNCTION__, __LINE__, gcvNULL, gcvNULL); \
gcmkTRACE_ZONE(gcdHEADER_LEVEL, _GC_OBJ_ZONE, \
"++%s(%d)", __FUNCTION__, __LINE__)
#else
gcmINLINE static void
__dummy_kheader(void)
{
}
# define gcmkHEADER __dummy_kheader
#endif
#if gcdHAS_ELLIPSIS
# define gcmkHEADER_ARG(Text, ...) \
gctINT8 __kernel__ = 1; \
gctINT8_PTR __kernel_ptr__ = &__kernel__; \
gcmkBINARY_TRACE(__FUNCTION__, __LINE__, Text, __VA_ARGS__); \
gcmkTRACE_ZONE(gcdHEADER_LEVEL, _GC_OBJ_ZONE, \
"++%s(%d): " Text, __FUNCTION__, __LINE__, __VA_ARGS__)
#else
gcmINLINE static void
__dummy_kheader_arg(
IN gctCONST_STRING Text,
...
)
{
}
# define gcmkHEADER_ARG __dummy_kheader_arg
#endif
#if gcdHAS_ELLIPSIS
#define gcmkFOOTER() \
gcmkBINARY_TRACE(__FUNCTION__, __LINE__, gcvNULL, status); \
gcmkTRACE_ZONE(gcdHEADER_LEVEL, _GC_OBJ_ZONE, \
"--%s(%d): status=%d(%s)", \
__FUNCTION__, __LINE__, status, gckOS_DebugStatus2Name(status)); \
*__kernel_ptr__ -= 1
#else
gcmINLINE static void
__dummy_kfooter(void)
{
}
# define gcmkFOOTER __dummy_kfooter
#endif
#if gcdHAS_ELLIPSIS
#define gcmkFOOTER_NO() \
gcmkBINARY_TRACE(__FUNCTION__, __LINE__, gcvNULL, gcvNULL); \
gcmkTRACE_ZONE(gcdHEADER_LEVEL, _GC_OBJ_ZONE, \
"--%s(%d)", __FUNCTION__, __LINE__); \
*__kernel_ptr__ -= 1
#else
gcmINLINE static void
__dummy_kfooter_no(void)
{
}
# define gcmkFOOTER_NO __dummy_kfooter_no
#endif
#if gcdHAS_ELLIPSIS
# define gcmkFOOTER_ARG(Text, ...) \
gcmkBINARY_TRACE(__FUNCTION__, __LINE__, Text, __VA_ARGS__); \
gcmkTRACE_ZONE(gcdHEADER_LEVEL, _GC_OBJ_ZONE, \
"--%s(%d): " Text, \
__FUNCTION__, __LINE__, __VA_ARGS__); \
*__kernel_ptr__ -= 1
#else
gcmINLINE static void
__dummy_kfooter_arg(
IN gctCONST_STRING Text,
...
)
{
}
# define gcmkFOOTER_ARG __dummy_kfooter_arg
#endif
#define gcmOPT_VALUE(ptr) (((ptr) == gcvNULL) ? 0 : *(ptr))
#define gcmOPT_VALUE_INDEX(ptr, index) (((ptr) == gcvNULL) ? 0 : ptr[index])
#define gcmOPT_POINTER(ptr) (((ptr) == gcvNULL) ? gcvNULL : *(ptr))
#define gcmOPT_STRING(ptr) (((ptr) == gcvNULL) ? "(nil)" : (ptr))
void
gckOS_Print(
IN gctCONST_STRING Message,
...
);
void
gcoOS_Print(
IN gctCONST_STRING Message,
...
);
#define gcmPRINT gcoOS_Print
#define gcmkPRINT gckOS_Print
#define gcmkPRINT_N(ArgumentSize, ...) gckOS_Print(__VA_ARGS__)
#if gcdHAS_ELLIPSIS
# define gcmPRINT_ONCE(Text, ...) \
{ \
static gctBOOL _once = gcvFALSE; \
if (!_once) \
{ \
gcmPRINT(Text, __VA_ARGS__); \
_once = gcvTRUE; \
} \
} \
#else
gcmINLINE static void
__dummy_printonce_arg(
IN gctCONST_STRING Text,
...
)
{
}
# define gcmPRINT_ONCE __dummy_printonce_arg
#endif
#if gcdFEATURE_SANITYCHECK
#define gcmFEATURE_CHECKED gcmPRINT_ONCE
#else
#define gcmFEATURE_CHECKED(Text, ...)
#endif
#if gcdPRINT_VERSION
# define gcmPRINT_VERSION() do { \
_gcmPRINT_VERSION(gcm); \
gcmSTACK_DUMP(); \
} while (0)
# define gcmkPRINT_VERSION() _gcmPRINT_VERSION(gcmk)
# define _gcmPRINT_VERSION(prefix) \
prefix##TRACE(gcvLEVEL_ERROR, \
"Vivante HAL version %s", \
gcvVERSION_STRING)
#else
# define gcmPRINT_VERSION() do { gcmSTACK_DUMP(); } while (gcvFALSE)
# define gcmkPRINT_VERSION() do { } while (gcvFALSE)
#endif
void
gckOS_Dump(
IN gckOS Os,
IN gctCONST_STRING Format,
...
);
void
gckOS_DumpBuffer(
IN gckOS Os,
IN gceDUMP_BUFFER_TYPE Type,
IN gctPOINTER Buffer,
IN gctUINT64 Address,
IN gctSIZE_T Size
);
#if gcdDUMP_IN_KERNEL
# define gcmkDUMP gckOS_Dump
# define gcmkDUMP_BUFFER gckOS_DumpBuffer
#else
# define gcmkDUMP(...) do {} while (0)
# define gcmkDUMP_BUFFER(...) do {} while (0)
#endif
/*******************************************************************************
**
** gcmDUMP_FRAMERATE
**
** Print average frame rate
**
*/
gceSTATUS
gcoOS_DumpFrameRate(
void
);
# define gcmDUMP_FRAMERATE gcoOS_DumpFrameRate
/*******************************************************************************
**
** gcoOS_SetDumpFlag
**
** Dump print switch.
**
** ARGUMENTS:
**
** DumpState
** True to enable dump prints.
*/
gceSTATUS
gcoOS_SetDumpFlag(
IN gctBOOL DumpState
);
/*******************************************************************************
**
** gcmDUMP
**
** Print a dump message.
**
** ARGUMENTS:
**
** gctSTRING Message.
**
** ... Optional arguments.
*/
#if gcdDUMP
gceSTATUS
gcoOS_Dump(
IN gcoOS Os,
IN gctCONST_STRING String,
...
);
# define gcmDUMP gcoOS_Dump
#else
# define gcmDUMP(...) do {} while (0)
#endif
/*******************************************************************************
**
** gcmDUMP_BUFFER
**
** Print a buffer to the dump.
**
** ARGUMENTS:
**
** gctSTRING Tag
** Tag for dump.
**
** gctUINT32 Address
** GPU address of buffer.
**
** gctPOINTER Logical
** Logical address of buffer.
**
** gctUINT32 Offset
** Offset into buffer.
**
** gctSIZE_T Bytes
** Number of bytes.
*/
#if gcdDUMP
gceSTATUS
gcoOS_DumpBuffer(
IN gcoOS Os,
IN gceDUMP_BUFFER_TYPE Type,
IN gctUINT32 Address,
IN gctPOINTER Logical,
IN gctSIZE_T Offset,
IN gctSIZE_T Bytes
);
# define gcmDUMP_BUFFER gcoOS_DumpBuffer
#else
# define gcmDUMP_BUFFER(...) do {} while (0)
#endif
#if gcdDUMP
void
gcoOS_DumpLock(
void
);
# define gcmDUMP_LOCK gcoOS_DumpLock
#else
# define gcmDUMP_LOCK(...) do {} while (0)
#endif
#if gcdDUMP
void
gcoOS_DumpUnlock(
void
);
# define gcmDUMP_UNLOCK gcoOS_DumpUnlock
#else
# define gcmDUMP_UNLOCK(...) do {} while (0)
#endif
/*******************************************************************************
**
** gcmDUMP_API
**
** Print a dump message for a high level API prefixed by the function name.
**
** ARGUMENTS:
**
** gctSTRING Message.
**
** ... Optional arguments.
*/
gceSTATUS gcoOS_DumpApi(IN gctCONST_STRING String, ...);
#if gcdDUMP_API
# define gcmDUMP_API gcoOS_DumpApi
#else
# define gcmDUMP_API(...) do {} while (0)
#endif
/*******************************************************************************
**
** gcmDUMP_API_ARRAY
**
** Print an array of data.
**
** ARGUMENTS:
**
** gctUINT32_PTR Pointer to array.
** gctUINT32 Size.
*/
gceSTATUS gcoOS_DumpArray(IN gctCONST_POINTER Data, IN gctUINT32 Size);
#if gcdDUMP_API
# define gcmDUMP_API_ARRAY gcoOS_DumpArray
#else
# define gcmDUMP_API_ARRAY(...) do {} while (0)
#endif
/*******************************************************************************
**
** gcmDUMP_API_ARRAY_TOKEN
**
** Print an array of data terminated by a token.
**
** ARGUMENTS:
**
** gctUINT32_PTR Pointer to array.
** gctUINT32 Termination.
*/
gceSTATUS gcoOS_DumpArrayToken(IN gctCONST_POINTER Data, IN gctUINT32 Termination);
#if gcdDUMP_API
# define gcmDUMP_API_ARRAY_TOKEN gcoOS_DumpArrayToken
#else
# define gcmDUMP_API_ARRAY_TOKEN(...) do {} while (0)
#endif
/*******************************************************************************
**
** gcmDUMP_API_DATA
**
** Print an array of bytes.
**
** ARGUMENTS:
**
** gctCONST_POINTER Pointer to array.
** gctSIZE_T Size.
*/
gceSTATUS gcoOS_DumpApiData(IN gctCONST_POINTER Data, IN gctSIZE_T Size);
#if gcdDUMP_API
# define gcmDUMP_API_DATA gcoOS_DumpApiData
#else
# define gcmDUMP_API_DATA(...) do {} while (0)
#endif
/*******************************************************************************
** gcmDUMP_2D_COMMAND
**
** Print the 2D command buffer.
**
** ARGUMENTS:
**
** gctUINT32_PTR Pointer to the command buffer.
** gctUINT32 Command buffer size.
*/
gceSTATUS gcoOS_Dump2DCommand(IN gctUINT32_PTR Command, IN gctUINT32 Size);
#if gcdDUMP_2D
# define gcmDUMP_2D_COMMAND(cmd, size) \
if (Hardware->newDump2DLevel > 1) \
gcoOS_Dump2DCommand(cmd, size)
#else
# define gcmDUMP_2D_COMMAND(...) do {} while (0)
#endif
/*******************************************************************************
** gcmDUMP_2D_SURFACE
**
** Print the 2D surface memory.
**
** ARGUMENTS:
**
** gctBOOL Src.
** gctUINT32 Address.
*/
gceSTATUS gcoOS_Dump2DSurface(IN gctBOOL Src, IN gctUINT32 Address);
#if gcdDUMP_2D
# define gcmDUMP_2D_SURFACE(src, addr) \
if (Hardware->newDump2DLevel > 2) \
gcoOS_Dump2DSurface(src, addr)
#else
# define gcmDUMP_2D_SURFACE(...) do {} while (0)
#endif
/*******************************************************************************
** gcmDUMP_ADD_MEMORY_INFO
**
** Record the memory info.
**
** ARGUMENTS:
**
** gctUINT32 Address.
** gctSIZE_T Size.
*/
gceSTATUS gcfAddMemoryInfo(IN gctUINT32 GPUAddress, IN gctPOINTER Logical, IN gctUINT64 Physical, IN gctUINT32 Size);
#if gcdDUMP_2D
# define gcmDUMP_ADD_MEMORY_INFO gcfAddMemoryInfo
#else
# define gcmDUMP_ADD_MEMORY_INFO(...) do {} while (0)
#endif
/*******************************************************************************
** gcmDUMP_DEL_MEMORY_INFO
**
** Record the memory info.
**
** ARGUMENTS:
**
** gctUINT32 Address.
*/
gceSTATUS gcfDelMemoryInfo(IN gctUINT32 Address);
#if gcdDUMP_2D
# define gcmDUMP_DEL_MEMORY_INFO gcfDelMemoryInfo
#else
# define gcmDUMP_DEL_MEMORY_INFO(...) do {} while (0)
#endif
/*******************************************************************************
**
** gcmTRACE_RELEASE
**
** Print a message to the shader debugger.
**
** ARGUMENTS:
**
** message Message.
** ... Optional arguments.
*/
#define gcmTRACE_RELEASE gcoOS_DebugShaderTrace
void
gcoOS_DebugShaderTrace(
IN gctCONST_STRING Message,
...
);
void
gcoOS_SetDebugShaderFiles(
IN gctCONST_STRING VSFileName,
IN gctCONST_STRING FSFileName
);
void
gcoOS_SetDebugShaderFileType(
IN gctUINT32 ShaderType
);
void
gcoOS_EnableDebugBuffer(
IN gctBOOL Enable
);
/*******************************************************************************
**
** gcmBREAK
**
** Break into the debugger. In retail mode this macro does nothing.
**
** ARGUMENTS:
**
** None.
*/
void
gcoOS_DebugBreak(
void
);
void
gckOS_DebugBreak(
void
);
#if gcmIS_DEBUG(gcdDEBUG_BREAK)
# define gcmBREAK gcoOS_DebugBreak
# define gcmkBREAK gckOS_DebugBreak
#else
# define gcmBREAK()
# define gcmkBREAK()
#endif
/*******************************************************************************
**
** gcmASSERT
**
** Evaluate an expression and break into the debugger if the expression
** evaluates to false. In retail mode this macro does nothing.
**
** ARGUMENTS:
**
** exp Expression to evaluate.
*/
#if gcmIS_DEBUG(gcdDEBUG_ASSERT)
# define _gcmASSERT(prefix, exp) \
do \
{ \
if (!(exp)) \
{ \
prefix##TRACE(gcvLEVEL_ERROR, \
#prefix "ASSERT at %s(%d)", \
__FUNCTION__, __LINE__); \
prefix##TRACE(gcvLEVEL_ERROR, \
"(%s)", #exp); \
prefix##BREAK(); \
} \
} \
while (gcvFALSE)
# define gcmASSERT(exp) _gcmASSERT(gcm, exp)
# define gcmkASSERT(exp) _gcmASSERT(gcmk, exp)
#else
# define gcmASSERT(exp)
# define gcmkASSERT(exp)
#endif
/*******************************************************************************
**
** gcmSTATIC_ASSERT
**
** Tests a software assertion at compile time. If the specific constant
** expression is false, the compiler displays the specified message and
** the compilation fails with an error, otherwise the declaration has
** no effect.
** Static assert is suitable for both user and kernel space.
**
** ARGUMENTS:
**
** exp Constant expression.
** message Error message displayed on assertion failure.
*/
#if defined(__GNUC__) && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 6) || (__GNUC__ > 4))
# define gcmSTATIC_ASSERT(constExp, message) \
do \
{ \
_Static_assert((constExp), message); \
} \
while (0)
#elif defined(_MSC_VER) && (_MSC_VER >= 1600)
# define gcmSTATIC_ASSERT(constExp, message) \
static_assert((constExp), message)
#else
# define gcmSTATIC_ASSERT(constExp, message) \
do {} while (0)
#endif
/*******************************************************************************
**
** gcmVERIFY
**
** Verify if an expression returns true. If the expression does not
** evaluates to true, an assertion will happen in debug mode.
**
** ARGUMENTS:
**
** exp Expression to evaluate.
*/
#if gcmIS_DEBUG(gcdDEBUG_ASSERT)
# define gcmVERIFY(exp) gcmASSERT(exp)
# define gcmkVERIFY(exp) gcmkASSERT(exp)
#else
# define gcmVERIFY(exp) (void)exp
# define gcmkVERIFY(exp) (void)exp
#endif
/*******************************************************************************
**
** gcmVERIFY_OK
**
** Verify a fucntion returns gcvSTATUS_OK. If the function does not return
** gcvSTATUS_OK, an assertion will happen in debug mode.
**
** ARGUMENTS:
**
** func Function to evaluate.
*/
void
gcoOS_Verify(
IN gceSTATUS status
);
void
gckOS_Verify(
IN gceSTATUS status
);
#if gcmIS_DEBUG(gcdDEBUG_ASSERT)
# define gcmVERIFY_OK(func) \
do \
{ \
gceSTATUS verifyStatus = func; \
gcoOS_Verify(verifyStatus); \
if (verifyStatus != gcvSTATUS_OK) \
{ \
gcmTRACE(\
gcvLEVEL_ERROR, \
"gcmVERIFY_OK(%d): function returned %d", \
__LINE__, verifyStatus \
); \
} \
gcmASSERT(verifyStatus == gcvSTATUS_OK); \
} \
while (gcvFALSE)
# define gcmkVERIFY_OK(func) \
do \
{ \
gceSTATUS verifyStatus = func; \
if (verifyStatus != gcvSTATUS_OK) \
{ \
gcmkTRACE(\
gcvLEVEL_ERROR, \
"gcmkVERIFY_OK(%d): function returned %d", \
__LINE__, verifyStatus \
); \
} \
gckOS_Verify(verifyStatus); \
gcmkASSERT(verifyStatus == gcvSTATUS_OK); \
} \
while (gcvFALSE)
#else
# define gcmVERIFY_OK(func) func
# define gcmkVERIFY_OK(func) func
#endif
gctCONST_STRING
gcoOS_DebugStatus2Name(
gceSTATUS status
);
gctCONST_STRING
gckOS_DebugStatus2Name(
gceSTATUS status
);
/*******************************************************************************
**
** gcmERR_BREAK
**
** Executes a break statement on error.
**
** ASSUMPTIONS:
**
** 'status' variable of gceSTATUS type must be defined.
**
** ARGUMENTS:
**
** func Function to evaluate.
*/
#define _gcmERR_BREAK(prefix, func){ \
status = func; \
if (gcmIS_ERROR(status)) \
{ \
prefix##PRINT_VERSION(); \
prefix##TRACE(gcvLEVEL_ERROR, \
#prefix "ERR_BREAK: status=%d(%s) @ %s(%d)", \
status, gcoOS_DebugStatus2Name(status), __FUNCTION__, __LINE__); \
break; \
} \
do { } while (gcvFALSE); \
}
#define _gcmkERR_BREAK(prefix, func){ \
status = func; \
if (gcmIS_ERROR(status)) \
{ \
prefix##PRINT_VERSION(); \
prefix##TRACE(gcvLEVEL_ERROR, \
#prefix "ERR_BREAK: status=%d(%s) @ %s(%d)", \
status, gckOS_DebugStatus2Name(status), __FUNCTION__, __LINE__); \
break; \
} \
do { } while (gcvFALSE); \
}
#define gcmERR_BREAK(func) _gcmERR_BREAK(gcm, func)
#define gcmkERR_BREAK(func) _gcmkERR_BREAK(gcmk, func)
/*******************************************************************************
**
** gcmERR_RETURN
**
** Executes a return on error.
**
** ASSUMPTIONS:
**
** 'status' variable of gceSTATUS type must be defined.
**
** ARGUMENTS:
**
** func Function to evaluate.
*/
#define _gcmERR_RETURN(prefix, func) \
status = func; \
if (gcmIS_ERROR(status)) \
{ \
prefix##PRINT_VERSION(); \
prefix##TRACE(gcvLEVEL_ERROR, \
#prefix "ERR_RETURN: status=%d(%s) @ %s(%d)", \
status, gcoOS_DebugStatus2Name(status), __FUNCTION__, __LINE__); \
prefix##FOOTER(); \
return status; \
} \
do { } while (gcvFALSE)
#define _gcmkERR_RETURN(prefix, func) \
status = func; \
if (gcmIS_ERROR(status)) \
{ \
prefix##PRINT_VERSION(); \
prefix##TRACE(gcvLEVEL_ERROR, \
#prefix "ERR_RETURN: status=%d(%s) @ %s(%d)", \
status, gckOS_DebugStatus2Name(status), __FUNCTION__, __LINE__); \
prefix##FOOTER(); \
return status; \
} \
do { } while (gcvFALSE)
#define gcmERR_RETURN(func) _gcmERR_RETURN(gcm, func)
#define gcmkERR_RETURN(func) _gcmkERR_RETURN(gcmk, func)
/*******************************************************************************
**
** gcmONERROR
**
** Jump to the error handler in case there is an error.
**
** ASSUMPTIONS:
**
** 'status' variable of gceSTATUS type must be defined.
**
** ARGUMENTS:
**
** func Function to evaluate.
*/
#define _gcmONERROR(prefix, func) \
do \
{ \
status = func; \
if (gcmIS_ERROR(status)) \
{ \
prefix##PRINT_VERSION(); \
prefix##TRACE(gcvLEVEL_ERROR, \
#prefix "ONERROR: status=%d(%s) @ %s(%d)", \
status, gcoOS_DebugStatus2Name(status), __FUNCTION__, __LINE__); \
goto OnError; \
} \
} \
while (gcvFALSE)
#define _gcmkONERROR(prefix, func) \
do \
{ \
status = func; \
if (gcmIS_ERROR(status)) \
{ \
prefix##PRINT_VERSION(); \
prefix##TRACE(gcvLEVEL_ERROR, \
#prefix "ONERROR: status=%d(%s) @ %s(%d)", \
status, gckOS_DebugStatus2Name(status), __FUNCTION__, __LINE__); \
goto OnError; \
} \
} \
while (gcvFALSE)
#define gcmONERROR(func) _gcmONERROR(gcm, func)
#define gcmkONERROR(func) _gcmkONERROR(gcmk, func)
#define gcmGET_INDEX_SIZE(type, size) \
switch (type) \
{ \
case gcvINDEX_8: \
size = 1; \
break; \
case gcvINDEX_16: \
size = 2; \
break; \
case gcvINDEX_32: \
size = 4; \
break; \
default: \
gcmONERROR(gcvSTATUS_INVALID_ARGUMENT); \
} \
/*******************************************************************************
**
** gcmkSAFECASTSIZET
**
** Check wether value of a gctSIZE_T varible beyond the capability
** of 32bits GPU hardware.
**
** ASSUMPTIONS:
**
**
**
** ARGUMENTS:
**
** x A gctUINT32 variable
** y A gctSIZE_T variable
*/
#define gcmkSAFECASTSIZET(x, y) \
do \
{ \
gctUINT32 tmp = (gctUINT32)(y); \
if (gcmSIZEOF(gctSIZE_T) > gcmSIZEOF(gctUINT32)) \
{ \
gcmkASSERT(tmp <= gcvMAXUINT32); \
} \
(x) = tmp; \
} \
while (gcvFALSE)
#define gcmSAFECASTSIZET(x, y) \
do \
{ \
gctUINT32 tmp = (gctUINT32)(y); \
if (gcmSIZEOF(gctSIZE_T) > gcmSIZEOF(gctUINT32)) \
{ \
gcmASSERT(tmp <= gcvMAXUINT32); \
} \
(x) = tmp; \
} \
while (gcvFALSE)
/*******************************************************************************
**
** gcmkSAFECASTPHYSADDRT
**
** Check whether value of a gctPHYS_ADDR_T variable beyond the capability
** of 32bits GPU hardware.
**
** ASSUMPTIONS:
**
**
**
** ARGUMENTS:
**
** x A gctUINT32 variable
** y A gctPHYS_ADDR_T variable
*/
#define gcmkSAFECASTPHYSADDRT(x, y) \
do \
{ \
gctUINT32 tmp = (gctUINT32)(y); \
if (gcmSIZEOF(gctPHYS_ADDR_T) > gcmSIZEOF(gctUINT32)) \
{ \
gcmkASSERT(tmp <= gcvMAXUINT32); \
} \
(x) = tmp; \
} \
while (gcvFALSE)
/*******************************************************************************
**
** gcmSAFECASTPHYSADDRT
**
** Check whether value of a gctPHYS_ADDR_T variable beyond the capability
** of 32bits GPU hardware.
**
** ASSUMPTIONS:
**
**
**
** ARGUMENTS:
**
** x A gctUINT32 variable
** y A gctPHYS_ADDR_T variable
*/
#define gcmSAFECASTPHYSADDRT(x, y) \
do \
{ \
gctUINT32 tmp = (gctUINT32)(y); \
if (gcmSIZEOF(gctPHYS_ADDR_T) > gcmSIZEOF(gctUINT32)) \
{ \
gcmASSERT(tmp <= gcvMAXUINT32); \
} \
(x) = tmp; \
} \
while (gcvFALSE)
/*******************************************************************************
**
** gcmVERIFY_LOCK
**
** Verifies whether the surface is locked.
**
** ARGUMENTS:
**
** surfaceInfo Pointer to the surface iniformational structure.
*/
#define gcmVERIFY_LOCK(surfaceInfo) \
if (!surfaceInfo->node.valid) \
{ \
gcmONERROR(gcvSTATUS_MEMORY_UNLOCKED); \
} \
/*******************************************************************************
**
** gcmVERIFY_NODE_LOCK
**
** Verifies whether the surface node is locked.
**
** ARGUMENTS:
**
** surfaceInfo Pointer to the surface iniformational structure.
*/
#define gcmVERIFY_NODE_LOCK(surfaceNode) \
if (!(surfaceNode)->valid) \
{ \
status = gcvSTATUS_MEMORY_UNLOCKED; \
break; \
} \
do { } while (gcvFALSE)
/*******************************************************************************
**
** gcmBADOBJECT_BREAK
**
** Executes a break statement on bad object.
**
** ARGUMENTS:
**
** obj Object to test.
** t Expected type of the object.
*/
#define gcmBADOBJECT_BREAK(obj, t) \
if ((obj == gcvNULL) \
|| (((gcsOBJECT *)(obj))->type != t) \
) \
{ \
status = gcvSTATUS_INVALID_OBJECT; \
break; \
} \
do { } while (gcvFALSE)
/*******************************************************************************
**
** gcmCHECK_STATUS
**
** Executes a break statement on error.
**
** ASSUMPTIONS:
**
** 'status' variable of gceSTATUS type must be defined.
**
** ARGUMENTS:
**
** func Function to evaluate.
*/
#define _gcmCHECK_STATUS(prefix, func) \
do \
{ \
last = func; \
if (gcmIS_ERROR(last)) \
{ \
prefix##TRACE(gcvLEVEL_ERROR, \
#prefix "CHECK_STATUS: status=%d(%s) @ %s(%d)", \
last, gcoOS_DebugStatus2Name(last), __FUNCTION__, __LINE__); \
status = last; \
} \
} \
while (gcvFALSE)
#define _gcmkCHECK_STATUS(prefix, func) \
do \
{ \
last = func; \
if (gcmIS_ERROR(last)) \
{ \
prefix##TRACE(gcvLEVEL_ERROR, \
#prefix "CHECK_STATUS: status=%d(%s) @ %s(%d)", \
last, gckOS_DebugStatus2Name(last), __FUNCTION__, __LINE__); \
status = last; \
} \
} \
while (gcvFALSE)
#define gcmCHECK_STATUS(func) _gcmCHECK_STATUS(gcm, func)
#define gcmkCHECK_STATUS(func) _gcmkCHECK_STATUS(gcmk, func)
/*******************************************************************************
**
** gcmVERIFY_ARGUMENT
**
** Assert if an argument does not apply to the specified expression. If
** the argument evaluates to false, gcvSTATUS_INVALID_ARGUMENT will be
** returned from the current function. In retail mode this macro does
** nothing.
**
** ARGUMENTS:
**
** arg Argument to evaluate.
*/
# define _gcmVERIFY_ARGUMENT(prefix, arg) \
do \
{ \
if (!(arg)) \
{ \
prefix##TRACE(gcvLEVEL_ERROR, #prefix "VERIFY_ARGUMENT failed:"); \
prefix##ASSERT(arg); \
prefix##FOOTER_ARG("status=%d", gcvSTATUS_INVALID_ARGUMENT); \
return gcvSTATUS_INVALID_ARGUMENT; \
} \
} \
while (gcvFALSE)
# define gcmVERIFY_ARGUMENT(arg) _gcmVERIFY_ARGUMENT(gcm, arg)
# define gcmkVERIFY_ARGUMENT(arg) _gcmVERIFY_ARGUMENT(gcmk, arg)
/*******************************************************************************
**
** gcmDEBUG_VERIFY_ARGUMENT
**
** Works just like gcmVERIFY_ARGUMENT, but is only valid in debug mode.
** Use this to verify arguments inside non-public API functions.
*/
#if gcdDEBUG
# define gcmDEBUG_VERIFY_ARGUMENT(arg) _gcmVERIFY_ARGUMENT(gcm, arg)
# define gcmkDEBUG_VERIFY_ARGUMENT(arg) _gcmkVERIFY_ARGUMENT(gcm, arg)
#else
# define gcmDEBUG_VERIFY_ARGUMENT(arg)
# define gcmkDEBUG_VERIFY_ARGUMENT(arg)
#endif
/*******************************************************************************
**
** gcmVERIFY_ARGUMENT_RETURN
**
** Assert if an argument does not apply to the specified expression. If
** the argument evaluates to false, gcvSTATUS_INVALID_ARGUMENT will be
** returned from the current function. In retail mode this macro does
** nothing.
**
** ARGUMENTS:
**
** arg Argument to evaluate.
*/
# define _gcmVERIFY_ARGUMENT_RETURN(prefix, arg, value) \
do \
{ \
if (!(arg)) \
{ \
prefix##TRACE(gcvLEVEL_ERROR, \
#prefix "gcmVERIFY_ARGUMENT_RETURN failed:"); \
prefix##ASSERT(arg); \
prefix##FOOTER_ARG("value=%d", value); \
return value; \
} \
} \
while (gcvFALSE)
# define gcmVERIFY_ARGUMENT_RETURN(arg, value) \
_gcmVERIFY_ARGUMENT_RETURN(gcm, arg, value)
# define gcmkVERIFY_ARGUMENT_RETURN(arg, value) \
_gcmVERIFY_ARGUMENT_RETURN(gcmk, arg, value)
#define MAX_LOOP_COUNT 0x7FFFFFFF
/******************************************************************************\
****************************** User Debug Option ******************************
\******************************************************************************/
typedef struct _gcsUSER_DEBUG_OPTION
{
gceDEBUG_MSG debugMsg;
}
gcsUSER_DEBUG_OPTION;
gcsUSER_DEBUG_OPTION *
gcoHAL_GetUserDebugOption(
void
);
#if gcdHAS_ELLIPSIS
#define gcmUSER_DEBUG_MSG(level, ...) \
do \
{ \
if (level <= gcoHAL_GetUserDebugOption()->debugMsg) \
{ \
gcoOS_Print(__VA_ARGS__); \
} \
} while (gcvFALSE)
#define gcmUSER_DEBUG_ERROR_MSG(...) gcmUSER_DEBUG_MSG(gcvDEBUG_MSG_ERROR, "Error: " __VA_ARGS__)
#define gcmUSER_DEBUG_WARNING_MSG(...) gcmUSER_DEBUG_MSG(gcvDEBUG_MSG_WARNING, "Warring: " __VA_ARGS__)
#else
#define gcmUSER_DEBUG_MSG
#define gcmUSER_DEBUG_ERROR_MSG
#define gcmUSER_DEBUG_WARNING_MSG
#endif
/*******************************************************************************
**
** A set of macros to aid state loading.
**
** ARGUMENTS:
**
** CommandBuffer Pointer to a gcoCMDBUF object.
** StateDelta Pointer to a gcsSTATE_DELTA state delta structure.
** Memory Destination memory pointer of gctUINT32_PTR type.
** PartOfContext Whether or not the state is a part of the context.
** FixedPoint Whether or not the state is of the fixed point format.
** Count Number of consecutive states to be loaded.
** Address State address.
** Data Data to be set to the state.
*/
/*----------------------------------------------------------------------------*/
#if gcmIS_DEBUG(gcdDEBUG_CODE)
# define gcmSTORELOADSTATE(CommandBuffer, Memory, Address, Count) \
CommandBuffer->lastLoadStatePtr = gcmPTR_TO_UINT64(Memory); \
CommandBuffer->lastLoadStateAddress = Address; \
CommandBuffer->lastLoadStateCount = Count
# define gcmVERIFYLOADSTATE(CommandBuffer, Memory, Address) \
gcmASSERT(\
(gctUINT) (Memory - gcmUINT64_TO_TYPE(CommandBuffer->lastLoadStatePtr, gctUINT32_PTR) - 1) \
== \
(gctUINT) (Address - CommandBuffer->lastLoadStateAddress) \
); \
\
gcmASSERT(CommandBuffer->lastLoadStateCount > 0); \
\
CommandBuffer->lastLoadStateCount -= 1
# define gcmVERIFYLOADSTATEDONE(CommandBuffer) \
gcmASSERT(CommandBuffer->lastLoadStateCount == 0);
# define gcmDEFINELOADSTATEBASE() \
gctUINT32_PTR LoadStateBase;
# define gcmSETLOADSTATEBASE(CommandBuffer, OutSide) \
if (OutSide) \
{\
LoadStateBase = (gctUINT32_PTR)*OutSide; \
}\
else\
{\
LoadStateBase = (gctUINT_PTR)CommandBuffer->buffer;\
}
# define gcmVERIFYLOADSTATEALIGNED(CommandBuffer, Memory) \
gcmASSERT(((Memory - LoadStateBase) & 1) == 0);
# define gcmUNSETLOADSTATEBASE() \
LoadStateBase = LoadStateBase;
#else
# define gcmSTORELOADSTATE(CommandBuffer, Memory, Address, Count)
# define gcmVERIFYLOADSTATE(CommandBuffer, Memory, Address)
# define gcmVERIFYLOADSTATEDONE(CommandBuffer)
# define gcmDEFINELOADSTATEBASE()
# define gcmSETLOADSTATEBASE(CommandBuffer, OutSide)
# define gcmVERIFYLOADSTATEALIGNED(CommandBuffer, Memory)
# define gcmUNSETLOADSTATEBASE()
#endif
/*----------------------------------------------------------------------------*/
/* This style of dump is deprecated. */
# define gcmDUMPSTATEDATA(StateDelta, FixedPoint, Address, Data)
#define gcmDEFINESTATEBUFFER(CommandBuffer, StateDelta, Memory, ReserveSize) \
gctSIZE_T ReserveSize; \
gcoCMDBUF CommandBuffer; \
gctUINT32_PTR Memory; \
gcsSTATE_DELTA_PTR StateDelta; \
gceENGINE CurrentEngine = gcvENGINE_RENDER
#define gcmBEGINSTATEBUFFER(Hardware, CommandBuffer, StateDelta, Memory, ReserveSize) \
{ \
gcmONERROR(gcoBUFFER_Reserve(\
Hardware->engine[CurrentEngine].buffer, ReserveSize, gcvTRUE, gcvCOMMAND_3D, &CommandBuffer \
)); \
\
Memory = (gctUINT32_PTR) gcmUINT64_TO_PTR(CommandBuffer->lastReserve); \
\
StateDelta = Hardware->delta; \
\
}
#define gcmENDSTATEBUFFER(Hardware, CommandBuffer, Memory, ReserveSize) \
{ \
gcmASSERT(\
gcmUINT64_TO_TYPE(CommandBuffer->lastReserve, gctUINT8_PTR) + ReserveSize \
== \
(gctUINT8_PTR) Memory \
); \
}
/*----------------------------------------------------------------------------*/
#define gcmBEGINSTATEBATCH(CommandBuffer, Memory, FixedPoint, Address, Count) \
{ \
gcmASSERT(((Memory - gcmUINT64_TO_TYPE(CommandBuffer->lastReserve, gctUINT32_PTR)) & 1) == 0); \
gcmASSERT((gctUINT32)Count <= 1024); \
\
gcmVERIFYLOADSTATEDONE(CommandBuffer); \
\
gcmSTORELOADSTATE(CommandBuffer, Memory, Address, Count); \
\
*Memory++ \
= gcmSETFIELDVALUE(0, AQ_COMMAND_LOAD_STATE_COMMAND, OPCODE, LOAD_STATE) \
| gcmSETFIELD (0, AQ_COMMAND_LOAD_STATE_COMMAND, FLOAT, FixedPoint) \
| gcmSETFIELD (0, AQ_COMMAND_LOAD_STATE_COMMAND, COUNT, Count) \
| gcmSETFIELD (0, AQ_COMMAND_LOAD_STATE_COMMAND, ADDRESS, Address); \
}
#define gcmENDSTATEBATCH(CommandBuffer, Memory) \
{ \
gcmVERIFYLOADSTATEDONE(CommandBuffer); \
\
gcmASSERT(((Memory - gcmUINT64_TO_TYPE(CommandBuffer->lastReserve, gctUINT32_PTR)) & 1) == 0); \
}
/*----------------------------------------------------------------------------*/
#define gcmSETSTATEDATA(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Data) \
{ \
gctUINT32 __temp_data32__; \
\
gcmVERIFYLOADSTATE(CommandBuffer, Memory, Address); \
\
gcmSAFECASTSIZET(__temp_data32__, Data); \
\
*Memory++ = __temp_data32__; \
\
gcoHARDWARE_UpdateDelta(\
StateDelta, Address, 0, __temp_data32__ \
); \
\
gcmDUMPSTATEDATA(StateDelta, FixedPoint, Address, __temp_data32__); \
}
#define gcmSETSTATEDATAWITHMASK(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Mask, Data) \
{ \
gctUINT32 __temp_data32__; \
\
gcmVERIFYLOADSTATE(CommandBuffer, Memory, Address); \
\
__temp_data32__ = Data; \
\
*Memory++ = __temp_data32__; \
\
gcoHARDWARE_UpdateDelta(\
StateDelta, Address, Mask, __temp_data32__ \
); \
\
gcmDUMPSTATEDATA(StateDelta, FixedPoint, Address, __temp_data32__); \
}
#define gcmSETCTRLSTATE(StateDelta, CommandBuffer, Memory, Address, Data) \
{ \
gctUINT32 __temp_data32__; \
\
gcmVERIFYLOADSTATE(CommandBuffer, Memory, Address); \
\
__temp_data32__ = Data; \
\
*Memory++ = __temp_data32__; \
\
gcmDUMPSTATEDATA(StateDelta, gcvFALSE, Address, __temp_data32__); \
}
#define gcmSETFILLER(CommandBuffer, Memory) \
{ \
gcmVERIFYLOADSTATEDONE(CommandBuffer); \
\
*(gctUINT32_PTR)Memory = 0x18000000; \
Memory += 1; \
}
/*----------------------------------------------------------------------------*/
#define gcmSETSINGLESTATE(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Data) \
{ \
gcmBEGINSTATEBATCH(CommandBuffer, Memory, FixedPoint, Address, 1); \
gcmSETSTATEDATA(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Data); \
gcmENDSTATEBATCH(CommandBuffer, Memory); \
}
#define gcmSETSINGLESTATEWITHMASK(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Mask, Data) \
{ \
gcmBEGINSTATEBATCH(CommandBuffer, Memory, FixedPoint, Address, 1); \
gcmSETSTATEDATAWITHMASK(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Mask, Data); \
gcmENDSTATEBATCH(CommandBuffer, Memory); \
}
#define gcmSETSINGLECTRLSTATE(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Data) \
{ \
gcmBEGINSTATEBATCH(CommandBuffer, Memory, FixedPoint, Address, 1); \
gcmSETCTRLSTATE(StateDelta, CommandBuffer, Memory, Address, Data); \
gcmENDSTATEBATCH(CommandBuffer, Memory); \
}
#define gcmSETSEMASTALLPIPE(StateDelta, CommandBuffer, Memory, Data) \
{ \
gcmSETSINGLECTRLSTATE(StateDelta, CommandBuffer, Memory, gcvFALSE, 0x0E02, Data); \
\
*Memory++ = gcmSETFIELDVALUE(0, STALL_COMMAND, OPCODE, STALL); \
\
*Memory++ = Data; \
\
gcmDUMP(gcvNULL, "#[stall 0x%08X 0x%08X]", \
gcmSETFIELDVALUE(0, AQ_SEMAPHORE, SOURCE, FRONT_END), \
gcmSETFIELDVALUE(0, AQ_SEMAPHORE, DESTINATION, PIXEL_ENGINE)); \
}
/*******************************************************************************
**
** gcmSETSTARTDECOMMAND
**
** Form a START_DE command.
**
** ARGUMENTS:
**
** Memory Destination memory pointer of gctUINT32_PTR type.
** Count Number of the rectangles.
*/
#define gcmSETSTARTDECOMMAND(Memory, Count) \
{ \
*Memory++ \
= gcmSETFIELDVALUE(0, AQ_COMMAND_START_DE_COMMAND, OPCODE, START_DE) \
| gcmSETFIELD (0, AQ_COMMAND_START_DE_COMMAND, COUNT, Count) \
| gcmSETFIELD (0, AQ_COMMAND_START_DE_COMMAND, DATA_COUNT, 0); \
\
*Memory++ = 0xDEADDEED; \
}
/*****************************************
** Temp command buffer macro
*/
#define gcmDEFINESTATEBUFFER_NEW(CommandBuffer, StateDelta, Memory) \
gcmDEFINELOADSTATEBASE() \
gcsTEMPCMDBUF CommandBuffer = gcvNULL; \
gctUINT32_PTR Memory; \
gcsSTATE_DELTA_PTR StateDelta; \
gceENGINE CurrentEngine = gcvENGINE_RENDER
#define gcmBEGINSTATEBUFFER_NEW(Hardware, CommandBuffer, StateDelta, Memory, OutSide) \
{ \
if (OutSide) \
{\
Memory = (gctUINT32_PTR)*OutSide; \
}\
else \
{\
gcmONERROR(gcoBUFFER_StartTEMPCMDBUF(\
Hardware->engine[CurrentEngine].buffer, Hardware->engine[CurrentEngine].queue, &CommandBuffer \
));\
\
Memory = (gctUINT32_PTR)(CommandBuffer->buffer); \
\
}\
StateDelta = Hardware->tempDelta; \
\
gcmSETLOADSTATEBASE(CommandBuffer,OutSide);\
}
#define gcmENDSTATEBUFFER_NEW(Hardware, CommandBuffer, Memory, OutSide) \
{ \
if (OutSide) \
{\
*OutSide = Memory; \
}\
else \
{\
CommandBuffer->currentByteSize = (gctUINT32)((gctUINT8_PTR)Memory - \
(gctUINT8_PTR)CommandBuffer->buffer); \
\
gcmONERROR(gcoBUFFER_EndTEMPCMDBUF(Hardware->engine[CurrentEngine].buffer, gcvFALSE));\
if (Hardware->constructType != gcvHARDWARE_2D) \
{ \
gcoHARDWARE_UpdateTempDelta(Hardware);\
} \
}\
gcmUNSETLOADSTATEBASE()\
}
#define gcmDEFINECTRLSTATEBUFFER(CommandBuffer, Memory) \
gcmDEFINELOADSTATEBASE() \
gcsTEMPCMDBUF CommandBuffer = gcvNULL; \
gctUINT32_PTR Memory; \
gceENGINE CurrentEngine = gcvENGINE_RENDER
#define gcmBEGINCTRLSTATEBUFFER(Hardware, CommandBuffer, Memory, OutSide) \
{ \
if (OutSide) \
{ \
Memory = (gctUINT32_PTR)*OutSide; \
} \
else \
{ \
gcmONERROR(gcoBUFFER_StartTEMPCMDBUF(\
Hardware->engine[CurrentEngine].buffer, \
Hardware->engine[CurrentEngine].queue, &CommandBuffer \
)); \
\
Memory = (gctUINT32_PTR)(CommandBuffer->buffer); \
} \
gcmSETLOADSTATEBASE(CommandBuffer,OutSide); \
}
/*----------------------------------------------------------------------------*/
#define gcmBEGINSTATEBATCH_NEW(CommandBuffer, Memory, FixedPoint, Address, Count) \
{ \
gcmVERIFYLOADSTATEALIGNED(CommandBuffer,Memory);\
gcmASSERT((gctUINT32)Count <= 1024); \
\
*Memory++ \
= gcmSETFIELDVALUE(0, AQ_COMMAND_LOAD_STATE_COMMAND, OPCODE, LOAD_STATE) \
| gcmSETFIELD (0, AQ_COMMAND_LOAD_STATE_COMMAND, FLOAT, FixedPoint) \
| gcmSETFIELD (0, AQ_COMMAND_LOAD_STATE_COMMAND, COUNT, Count) \
| gcmSETFIELD (0, AQ_COMMAND_LOAD_STATE_COMMAND, ADDRESS, Address); \
}
#define gcmENDSTATEBATCH_NEW(CommandBuffer, Memory) \
gcmVERIFYLOADSTATEALIGNED(CommandBuffer,Memory);
/*----------------------------------------------------------------------------*/
#define gcmSETSTATEDATA_NEW(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Data) \
{ \
gctUINT32 __temp_data32__; \
\
gcmSAFECASTSIZET(__temp_data32__, Data); \
\
*Memory++ = __temp_data32__; \
\
gcoHARDWARE_UpdateDelta(\
StateDelta, Address, 0, __temp_data32__ \
); \
\
gcmDUMPSTATEDATA(StateDelta, FixedPoint, Address, __temp_data32__); \
}
#define gcmSETSTATEDATAWITHMASK_NEW(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Mask, Data) \
{ \
gctUINT32 __temp_data32__; \
\
__temp_data32__ = Data; \
\
*Memory++ = __temp_data32__; \
\
gcoHARDWARE_UpdateDelta(\
StateDelta, Address, Mask, __temp_data32__ \
); \
\
gcmDUMPSTATEDATA(StateDelta, FixedPoint, Address, __temp_data32__); \
}
#define gcmSETCTRLSTATE_NEW(StateDelta, CommandBuffer, Memory, Address, Data) \
{ \
gctUINT32 __temp_data32__; \
\
__temp_data32__ = Data; \
\
*Memory++ = __temp_data32__; \
\
gcmDUMPSTATEDATA(StateDelta, gcvFALSE, Address, __temp_data32__); \
}
#define gcmSETFILLER_NEW(CommandBuffer, Memory) \
{ \
*(gctUINT32_PTR)Memory = 0x18000000; \
Memory += 1; \
}
/*----------------------------------------------------------------------------*/
#define gcmSETSINGLESTATE_DUMMY(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Data) \
{ \
gctUINT32 __temp_data32__; \
__temp_data32__ = Data ; \
gcmVERIFYLOADSTATEALIGNED(CommandBuffer, Memory); \
*Memory++ = \
(gctUINT32)(0) | (0xFFFF & Address); \
*Memory++ = __temp_data32__; \
gcmENDSTATEBATCH_NEW(CommandBuffer, Memory); \
}
#define gcmSETSINGLESTATE_NEW(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Data) \
{ \
gcmBEGINSTATEBATCH_NEW(CommandBuffer, Memory, FixedPoint, Address, 1); \
gcmSETSTATEDATA_NEW(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Data); \
gcmENDSTATEBATCH_NEW(CommandBuffer, Memory); \
}
#define gcmSETSINGLESTATEWITHMASK_NEW(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Mask, Data) \
{ \
gcmBEGINSTATEBATCH_NEW(CommandBuffer, Memory, FixedPoint, Address, 1); \
gcmSETSTATEDATAWITHMASK_NEW(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Mask, Data); \
gcmENDSTATEBATCH_NEW(CommandBuffer, Memory); \
}
#define gcmSETSINGLECTRLSTATE_NEW(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Data) \
{ \
gcmBEGINSTATEBATCH_NEW(CommandBuffer, Memory, FixedPoint, Address, 1); \
gcmSETCTRLSTATE_NEW(StateDelta, CommandBuffer, Memory, Address, Data); \
gcmENDSTATEBATCH_NEW(CommandBuffer, Memory); \
}
#define gcmSETSEMASTALLPIPE_NEW(StateDelta, CommandBuffer, Memory, Data) \
{ \
gcmSETSINGLECTRLSTATE_NEW(StateDelta, CommandBuffer, Memory, gcvFALSE, 0x0E02, Data); \
\
*Memory++ = gcmSETFIELDVALUE(0, STALL_COMMAND, OPCODE, STALL); \
\
*Memory++ = Data; \
\
gcmDUMP(gcvNULL, "#[stall 0x%08X 0x%08X]", \
gcmSETFIELDVALUE(0, AQ_SEMAPHORE, SOURCE, FRONT_END), \
gcmSETFIELDVALUE(0, AQ_SEMAPHORE, DESTINATION, PIXEL_ENGINE)); \
}
#define gcmSETSTARTDECOMMAND_NEW(CommandBuffer, Memory, Count) \
{ \
*Memory++ \
= gcmSETFIELDVALUE(0, AQ_COMMAND_START_DE_COMMAND, OPCODE, START_DE) \
| gcmSETFIELD (0, AQ_COMMAND_START_DE_COMMAND, COUNT, Count) \
| gcmSETFIELD (0, AQ_COMMAND_START_DE_COMMAND, DATA_COUNT, 0); \
\
*Memory++ = 0xDEADDEED; \
\
}
#define gcmSETSTATEDATA_NEW_FAST(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Data) \
{ \
gctUINT32 __temp_data32__; \
\
__temp_data32__ = Data; \
\
*Memory++ = __temp_data32__; \
\
gcmDUMPSTATEDATA(StateDelta, FixedPoint, Address, __temp_data32__); \
}
#define gcmSETSTATEDATAWITHMASK_NEW_FAST(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Mask, Data) \
{ \
gctUINT32 __temp_data32__; \
\
__temp_data32__ = Data; \
\
*Memory++ = __temp_data32__; \
\
gcmDUMPSTATEDATA(StateDelta, FixedPoint, Address, __temp_data32__); \
}
#define gcmSETSINGLESTATE_NEW_FAST(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Data) \
{ \
gcmBEGINSTATEBATCH_NEW(CommandBuffer, Memory, FixedPoint, Address, 1); \
gcmSETSTATEDATA_NEW_FAST(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Data); \
gcmENDSTATEBATCH_NEW(CommandBuffer, Memory); \
}
#define gcmSETSINGLESTATEWITHMASK_NEW_FAST(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Mask, Data) \
{ \
gcmBEGINSTATEBATCH_NEW(CommandBuffer, Memory, FixedPoint, Address, 1); \
gcmSETSTATEDATAWITHMASK_NEW_FAST(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Mask, Data); \
gcmENDSTATEBATCH_NEW(CommandBuffer, Memory); \
}
#define gcmSETSTATEDATA_FAST(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Data) \
{ \
gctUINT32 __temp_data32__; \
\
gcmVERIFYLOADSTATE(CommandBuffer, Memory, Address); \
\
gcmSAFECASTSIZET(__temp_data32__, Data); \
\
*Memory++ = __temp_data32__; \
\
gcmDUMPSTATEDATA(StateDelta, FixedPoint, Address, __temp_data32__); \
}
#define gcmSETSTATEDATAWITHMASK_FAST(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Mask, Data) \
{ \
gctUINT32 __temp_data32__; \
\
gcmVERIFYLOADSTATE(CommandBuffer, Memory, Address); \
\
__temp_data32__ = Data; \
\
*Memory++ = __temp_data32__; \
\
gcmDUMPSTATEDATA(StateDelta, FixedPoint, Address, __temp_data32__); \
}
#define gcmSETSINGLESTATE_FAST(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Data) \
{ \
gcmBEGINSTATEBATCH(CommandBuffer, Memory, FixedPoint, Address, 1); \
gcmSETSTATEDATA_FAST(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Data); \
gcmENDSTATEBATCH(CommandBuffer, Memory); \
}
#define gcmSETSINGLESTATEWITHMASK_FAST(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Mask, Data) \
{ \
gcmBEGINSTATEBATCH(CommandBuffer, Memory, FixedPoint, Address, 1); \
gcmSETSTATEDATAWITHMASK_FAST(StateDelta, CommandBuffer, Memory, FixedPoint, \
Address, Mask, Data); \
gcmENDSTATEBATCH(CommandBuffer, Memory); \
}
#define gcmDEFINESTATEBUFFER_NEW_FAST(CommandBuffer, Memory) \
gcmDEFINELOADSTATEBASE() \
gcsTEMPCMDBUF CommandBuffer = gcvNULL; \
gctUINT32_PTR Memory;
#define gcmDEFINESTATEBUFFER_FAST(CommandBuffer, Memory, ReserveSize) \
gctSIZE_T ReserveSize; \
gcoCMDBUF CommandBuffer; \
gctUINT32_PTR Memory;
#define gcmBEGINSTATEBUFFER_FAST(Hardware, CommandBuffer, Memory, ReserveSize) \
{ \
gcmONERROR(gcoBUFFER_Reserve(\
Hardware->engine[gcvENGINE_RENDER].buffer, ReserveSize, gcvTRUE, &CommandBuffer \
)); \
\
Memory = (gctUINT32_PTR) gcmUINT64_TO_PTR(CommandBuffer->lastReserve); \
\
}
#define gcmBEGINSTATEBUFFER_NEW_FAST(Hardware, CommandBuffer, Memory, OutSide) \
{ \
if (OutSide) \
{\
Memory = (gctUINT32_PTR)*OutSide; \
}\
else \
{\
gcmONERROR(gcoBUFFER_StartTEMPCMDBUF(\
Hardware->engine[gcvENGINE_RENDER].buffer, Hardware->engine[gcvENGINE_RENDER].queue, &CommandBuffer \
));\
\
Memory = (gctUINT32_PTR)(CommandBuffer->buffer); \
\
}\
\
gcmSETLOADSTATEBASE(CommandBuffer,OutSide);\
}
#define gcmENDSTATEBUFFER_NEW_FAST(Hardware, CommandBuffer, Memory, OutSide) \
{ \
if (OutSide) \
{\
*OutSide = Memory; \
}\
else \
{\
CommandBuffer->currentByteSize = (gctUINT32)((gctUINT8_PTR)Memory - \
(gctUINT8_PTR)CommandBuffer->buffer); \
\
gcmONERROR(gcoBUFFER_EndTEMPCMDBUF(Hardware->engine[gcvENGINE_RENDER].buffer, gcvFALSE));\
}\
gcmUNSETLOADSTATEBASE()\
}
/*******************************************************************************
**
** gcmCONFIGUREUNIFORMS
**
** Configure uniforms according to chip and numConstants.
*/
#if !gcdENABLE_UNIFIED_CONSTANT
#define gcmCONFIGUREUNIFORMS(ChipModel, ChipRevision, NumConstants, \
UnifiedConst, VsConstBase, PsConstBase, VsConstMax, PsConstMax, ConstMax) \
{ \
if (ChipModel == gcv2000 && (ChipRevision == 0x5118 || ChipRevision == 0x5140)) \
{ \
UnifiedConst = gcvFALSE; \
VsConstBase = 0x1400; \
PsConstBase = 0x1C00; \
VsConstMax = 256; \
PsConstMax = 64; \
ConstMax = 320; \
} \
else if (NumConstants == 320) \
{ \
UnifiedConst = gcvFALSE; \
VsConstBase = 0x1400; \
PsConstBase = 0x1C00; \
VsConstMax = 256; \
PsConstMax = 64; \
ConstMax = 320; \
} \
/* All GC1000 series chips can only support 64 uniforms for ps on non-unified const mode. */ \
else if (NumConstants > 256 && ChipModel == gcv1000) \
{ \
UnifiedConst = gcvFALSE; \
VsConstBase = 0x1400; \
PsConstBase = 0x1C00; \
VsConstMax = 256; \
PsConstMax = 64; \
ConstMax = 320; \
} \
else if (NumConstants > 256) \
{ \
UnifiedConst = gcvFALSE; \
VsConstBase = 0x1400; \
PsConstBase = 0x1C00; \
VsConstMax = 256; \
PsConstMax = 256; \
ConstMax = 512; \
} \
else if (NumConstants == 256) \
{ \
UnifiedConst = gcvFALSE; \
VsConstBase = 0x1400; \
PsConstBase = 0x1C00; \
VsConstMax = 256; \
PsConstMax = 256; \
ConstMax = 512; \
} \
else \
{ \
UnifiedConst = gcvFALSE; \
VsConstBase = 0x1400; \
PsConstBase = 0x1C00; \
VsConstMax = 168; \
PsConstMax = 64; \
ConstMax = 232; \
} \
}
#else
#define gcmCONFIGUREUNIFORMS(ChipModel, ChipRevision, Halti5Avail, SmallBatch, NumConstants, \
UnifiedConst, VsConstBase, PsConstBase, VsConstMax, PsConstMax, ConstMax) \
{ \
if (NumConstants > 256) \
{ \
UnifiedConst = gcvTRUE; \
if (SmallBatch) \
{ \
VsConstBase = 0xD000; \
PsConstBase = 0xD000; \
} \
else if (Halti5Avail) \
{ \
VsConstBase = 0xD000; \
PsConstBase = 0xD800; \
} \
else \
{\
VsConstBase = 0xC000; \
PsConstBase = 0xC000; \
}\
if ((ChipModel == gcv880) && ((ChipRevision & 0xfff0) == 0x5120)) \
{ \
VsConstMax = 512; \
PsConstMax = 64; \
ConstMax = 576; \
} \
else \
{ \
VsConstMax = gcmMIN(512, NumConstants - 64); \
PsConstMax = gcmMIN(512, NumConstants - 64); \
ConstMax = NumConstants; \
} \
} \
else if (NumConstants == 256) \
{ \
if (ChipModel == gcv2000 && (ChipRevision == 0x5118 || ChipRevision == 0x5140)) \
{ \
UnifiedConst = gcvFALSE; \
VsConstBase = 0x1400; \
PsConstBase = 0x1C00; \
VsConstMax = 256; \
PsConstMax = 64; \
ConstMax = 320; \
} \
else \
{ \
UnifiedConst = gcvFALSE; \
VsConstBase = 0x1400; \
PsConstBase = 0x1C00; \
VsConstMax = 256; \
PsConstMax = 256; \
ConstMax = 512; \
} \
} \
else \
{ \
UnifiedConst = gcvFALSE; \
VsConstBase = 0x1400; \
PsConstBase = 0x1C00; \
VsConstMax = 168; \
PsConstMax = 64; \
ConstMax = 232; \
} \
}
#endif
/*******************************************************************************
**
** gcmCONFIGUREUNIFORMS2
** only fix clang build error
**
** Configure uniforms according to chip and numConstants.
*/
#if !gcdENABLE_UNIFIED_CONSTANT
#define gcmCONFIGUREUNIFORMS2(ChipModel, ChipRevision, NumConstants, \
UnifiedConst, VsConstMax, PsConstMax) \
{ \
if (ChipModel == gcv2000 && (ChipRevision == 0x5118 || ChipRevision == 0x5140)) \
{ \
UnifiedConst = gcvFALSE; \
VsConstMax = 256; \
PsConstMax = 64; \
} \
else if (NumConstants == 320) \
{ \
UnifiedConst = gcvFALSE; \
VsConstMax = 256; \
PsConstMax = 64; \
} \
/* All GC1000 series chips can only support 64 uniforms for ps on non-unified const mode. */ \
else if (NumConstants > 256 && ChipModel == gcv1000) \
{ \
UnifiedConst = gcvFALSE; \
VsConstMax = 256; \
PsConstMax = 64; \
} \
else if (NumConstants > 256) \
{ \
UnifiedConst = gcvFALSE; \
VsConstMax = 256; \
PsConstMax = 256; \
} \
else if (NumConstants == 256) \
{ \
UnifiedConst = gcvFALSE; \
VsConstMax = 256; \
PsConstMax = 256; \
} \
else \
{ \
UnifiedConst = gcvFALSE; \
VsConstMax = 168; \
PsConstMax = 64; \
} \
}
#else
#define gcmCONFIGUREUNIFORMS2(ChipModel, ChipRevision, Halti5Avail, SmallBatch, NumConstants, \
UnifiedConst, VsConstMax, PsConstMax) \
{ \
if (NumConstants > 256) \
{ \
UnifiedConst = gcvTRUE; \
if ((ChipModel == gcv880) && ((ChipRevision & 0xfff0) == 0x5120)) \
{ \
VsConstMax = 512; \
PsConstMax = 64; \
} \
else \
{ \
VsConstMax = gcmMIN(512, NumConstants - 64); \
PsConstMax = gcmMIN(512, NumConstants - 64); \
} \
} \
else if (NumConstants == 256) \
{ \
if (ChipModel == gcv2000 && (ChipRevision == 0x5118 || ChipRevision == 0x5140)) \
{ \
UnifiedConst = gcvFALSE; \
VsConstMax = 256; \
PsConstMax = 64; \
} \
else \
{ \
UnifiedConst = gcvFALSE; \
VsConstMax = 256; \
PsConstMax = 256; \
} \
} \
else \
{ \
UnifiedConst = gcvFALSE; \
VsConstMax = 168; \
PsConstMax = 64; \
} \
}
#endif
#define gcmAnyTileStatusEnableForFullMultiSlice(SurfView, anyTsEnableForMultiSlice)\
{\
gctUINT i = 0; \
for (; i < (SurfView->surf->requestD); i++)\
{\
if ((SurfView->surf->tileStatusNode.pool != gcvPOOL_UNKNOWN) && \
(SurfView->surf->tileStatusDisabled[i] == gcvFALSE))\
{\
*anyTsEnableForMultiSlice = gcvTRUE;\
break;\
}\
}\
}\
#define gcmAnyTileStatusEnableForMultiSlice(SurfView, anyTsEnableForMultiSlice)\
{\
gctUINT i = SurfView->firstSlice; \
for (; i < (SurfView->firstSlice + SurfView->numSlices); i++)\
{\
if ((SurfView->surf->tileStatusNode.pool != gcvPOOL_UNKNOWN) && \
(SurfView->surf->tileStatusDisabled[i] == gcvFALSE))\
{\
*anyTsEnableForMultiSlice = gcvTRUE;\
break;\
}\
}\
}\
#define gcmCanTileStatusEnabledForMultiSlice(SurfView, canTsEnabled)\
{\
if (SurfView->numSlices > 1)\
{\
if (SurfView->surf->tileStatusNode.pool != gcvPOOL_UNKNOWN) \
{\
gctUINT i = 0;\
for (; i < SurfView->numSlices; i++)\
{\
if (SurfView->surf->tileStatusDisabled[i] == gcvTRUE)\
{\
*canTsEnabled = gcvFALSE;\
break;\
}\
if (SurfView->surf->fcValue[i] != SurfView->surf->fcValue[0])\
{\
*canTsEnabled = gcvFALSE;\
break;\
}\
\
if (SurfView->surf->fcValueUpper[i] != SurfView->surf->fcValueUpper[0])\
{\
*canTsEnabled = gcvFALSE;\
break;\
}\
}\
}\
else\
{\
*canTsEnabled = gcvFALSE;\
}\
}\
else\
{\
if ((SurfView->surf->tileStatusNode.pool == gcvPOOL_UNKNOWN) || (SurfView->surf->tileStatusDisabled[SurfView->firstSlice] == gcvTRUE))\
{\
*canTsEnabled = gcvFALSE;\
}\
}\
}\
#define gcmCONFIGUSC(prefix, featureUSC, featureSeparateLS, featureComputeOnly, \
featureTS, featureGS, featureUSCFullCacheFix, featureL1CacheSize, featureUSCMaxPages, \
attribCacheRatio, L1CacheRatio) \
{ \
attribCacheRatio = 0x2; \
\
if (featureUSC) \
{ \
if (featureSeparateLS) \
{ \
L1CacheRatio = 0x0; \
} \
else \
{ \
gctUINT L1cacheSize; \
\
if (featureComputeOnly) \
{ \
L1cacheSize = featureL1CacheSize; \
} \
else \
{ \
gctUINT attribBufSizeInKB; \
if (featureTS) \
{ \
/* GS/TS must be bundled. */ \
prefix##ASSERT(featureGS); \
featureGS = featureGS; \
attribBufSizeInKB = 42; \
} \
else \
{ \
prefix##ASSERT(!featureGS); \
attribBufSizeInKB = 8; \
} \
if (attribBufSizeInKB < featureUSCMaxPages) \
{ \
L1cacheSize = featureUSCMaxPages - attribBufSizeInKB; \
} \
else \
{ \
attribBufSizeInKB -= 2; \
L1cacheSize = 2; \
} \
} \
prefix##ASSERT(L1cacheSize); \
if (L1cacheSize >= featureL1CacheSize) \
{ \
L1CacheRatio = 0x0; \
prefix##ASSERT(featureUSCFullCacheFix); \
featureUSCFullCacheFix = featureUSCFullCacheFix; \
} \
else \
{ \
static const gctINT s_uscCacheRatio[] = \
{ \
100000,/* 1.0f */ \
50000, /* 0.5f */ \
25000, /* 0.25f */ \
12500, /* 0.125f */ \
62500, /* 0.0625f */ \
3125, /* 0.03125f */ \
75000, /* 0.75f */ \
0, /*0.0f */ \
}; \
gctINT maxL1cacheSize = L1cacheSize * 100000; \
gctINT delta = 2147483647; /* start with very big delta */ \
gctINT i = 0; \
gctINT curIndex = -1; \
for (; i < gcmCOUNTOF(s_uscCacheRatio); ++i) \
{ \
gctINT curL1cacheSize = featureL1CacheSize * s_uscCacheRatio[i]; \
\
if ((maxL1cacheSize >= curL1cacheSize) && \
((maxL1cacheSize - curL1cacheSize) < delta)) \
{ \
curIndex = i; \
delta = maxL1cacheSize - curL1cacheSize; \
} \
} \
prefix##ASSERT(-1 != curIndex); \
L1CacheRatio = curIndex; \
} \
} \
} \
} \
#define gcmCONFIGUSC2(prefix, featureUSC, featureSeparateLS, featureComputeOnly, \
featureTS, featureL1CacheSize, featureUSCMaxPages, \
attribCacheRatio, L1CacheRatio) \
{ \
attribCacheRatio = 0x2; \
\
if (featureUSC) \
{ \
if (featureSeparateLS) \
{ \
L1CacheRatio = 0x0; \
} \
else \
{ \
gctUINT L1cacheSize; \
\
if (featureComputeOnly) \
{ \
L1cacheSize = featureL1CacheSize; \
} \
else \
{ \
gctUINT attribBufSizeInKB; \
if (featureTS) \
{ \
/* GS/TS must be bundled. */ \
attribBufSizeInKB = 42; \
} \
else \
{ \
attribBufSizeInKB = 8; \
} \
if (attribBufSizeInKB < featureUSCMaxPages) \
{ \
L1cacheSize = featureUSCMaxPages - attribBufSizeInKB; \
} \
else \
{ \
attribBufSizeInKB -= 2; \
L1cacheSize = 2; \
} \
} \
prefix##ASSERT(L1cacheSize); \
if (L1cacheSize >= featureL1CacheSize) \
{ \
L1CacheRatio = 0x0; \
} \
else \
{ \
static const gctINT s_uscCacheRatio[] = \
{ \
100000,/* 1.0f */ \
50000, /* 0.5f */ \
25000, /* 0.25f */ \
12500, /* 0.125f */ \
62500, /* 0.0625f */ \
3125, /* 0.03125f */ \
75000, /* 0.75f */ \
0, /*0.0f */ \
}; \
gctINT maxL1cacheSize = L1cacheSize * 100000; \
gctINT delta = 2147483647; /* start with very big delta */ \
gctINT i = 0; \
gctINT curIndex = -1; \
for (; i < gcmCOUNTOF(s_uscCacheRatio); ++i) \
{ \
gctINT curL1cacheSize = featureL1CacheSize * s_uscCacheRatio[i]; \
\
if ((maxL1cacheSize >= curL1cacheSize) && \
((maxL1cacheSize - curL1cacheSize) < delta)) \
{ \
curIndex = i; \
delta = maxL1cacheSize - curL1cacheSize; \
} \
} \
prefix##ASSERT(-1 != curIndex); \
L1CacheRatio = curIndex; \
} \
} \
} \
} \
#if VIVANTE_PROFILER_SYSTEM_MEMORY
typedef struct _memory_profile_info
{
struct
{
gctUINT64 currentSize;
gctUINT64 peakSize;
gctUINT64 total_allocate;
gctUINT64 total_free;
gctUINT32 total_allocateCount;
gctUINT32 total_freeCount;
} system_memory, gpu_memory;
} memory_profile_info;
gceSTATUS
gcoOS_GetMemoryProfileInfo(
size_t size,
struct _memory_profile_info *info
);
gceSTATUS gcoOS_DumpMemoryProfile(void);
gceSTATUS gcoOS_InitMemoryProfile(void);
gceSTATUS gcoOS_DeInitMemoryProfile(void);
#endif
#ifdef __cplusplus
}
#endif
#endif /* __gc_hal_base_h_ */