/**************************************************************************** * * Copyright (c) 2005 - 2023 by Vivante Corp. All rights reserved. * * The material in this file is confidential and contains trade secrets * of Vivante Corporation. This is proprietary information owned by * Vivante Corporation. No part of this work may be disclosed, * reproduced, copied, transmitted, or used in any way for any purpose, * without the express written permission of Vivante Corporation. * *****************************************************************************/ #ifndef __gc_hal_base_h_ #define __gc_hal_base_h_ #include "gc_hal_enum.h" #include "gc_hal_types.h" #include "gc_hal_debug_zones.h" #include "shared/gc_hal_base_shared.h" #ifdef __QNXNTO__ # define CHECK_PRINTF_FORMAT(string_index, first_to_check) \ __attribute__((__format__(__printf__, (string_index), (first_to_check)))) #else # define CHECK_PRINTF_FORMAT(string_index, first_to_check) #endif #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 struct _gcoDEVICE *gcoDEVICE; #if gcdENABLE_MULTI_DEVICE_MANAGEMENT typedef struct _gcsHARDWARE_PROFILE gcsHARDWARE_PROFILE; #endif 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; #if gcdENABLE_CLEAR_FENCE typedef struct _gcsUSER_FENCE_INFO *gcsUSER_FENCE_INFO_PTR; #endif /* Immuatable features from database */ typedef struct _gcsNN_FIXED_FEATURE { gctUINT vipCoreCount; gctUINT vipRingCount; 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; gctUINT nnClusterNumForPowerControl; gctUINT vipMinAxiBurstSize; gctUINT nnInLinesPerCycle; gctUINT nnPreprocessorMaxSegmentPerCycle; /* stream processor info */ gctUINT streamProcessorExecCount; gctUINT streamProcessorVectorSize; /* add related information for check in/out size */ gctUINT outImageXStrideBits; gctUINT outImageYStrideBits; gctUINT inImageXStrideBits; gctUINT inImageYStrideBits; gctUINT outImageXSizeBits; gctUINT outImageYSizeBits; gctUINT inImageXSizeBits; gctUINT inImageYSizeBits; gctUINT smallAccumBits; gctUINT coefDecompressPerfX; } gcsNN_FIXED_FEATURE; /* Features can be customized from outside */ typedef struct _gcsNN_CUSTOMIZED_FEATURE { gctUINT nnActiveCoreCount; gctUINT nnCoreCount; /* total nn core count */ gctUINT nnCoreCountInt8; /* total nn core count supporting int8 */ gctUINT nnCoreCountInt16; /* total nn core count supporting int16 */ gctUINT nnCoreCountUint16; /* total nn core count supporting uint16 */ gctUINT nnCoreCountFloat16; /* total nn core count supporting float16 */ gctUINT nnCoreCountBFloat16; /* total nn core count supporting Bfloat16 */ 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; gctFLOAT axiSRAMLatency; } 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; gctFLOAT totalAxiSRAMLatency; } 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 device index of this thread. */ gctUINT32 currentDevIndex; /* 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; gctHANDLE graph; /* If true, do not releas 2d engine and hardware in hal layer */ gctBOOL release2DUpper; /* Driver tls. */ gcsDRIVER_TLS_PTR driverTLS[gcvTLS_KEY_COUNT]; #if gcdENABLE_SW_PREEMPTION /* PriorityID. */ gctUINT priorityID; #endif } 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_GetProductNameWithHardware(IN gcoHARDWARE Hardware, OUT gctSTRING *ProductName, OUT gctUINT *PID); gceSTATUS gcoHAL_SetFscaleValue(IN gcoHAL Hal, IN gctUINT CoreIndex, IN gctUINT FscaleValue, IN gctUINT ShaderFscaleValue); gceSTATUS gcoHAL_CancelJob(gcoHAL Hal); 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); gceSTATUS gcoHAL_GetExportedVideoMemoryFd(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_IsFeatureAvailableWithHardware(IN gcoHARDWARE Hardware, 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_QueryChipIdentityWithHardware(IN gcoHARDWARE Hardware, OUT gceCHIPMODEL *ChipModel, OUT gctUINT32 *ChipRevision); 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_PROCESSOR_MODE *Mode, OUT gctUINT32_PTR CoreIndex); gceSTATUS gcoHAL_QueryHwDeviceIdByEnv(IN gcoHAL Hal, OUT gctUINT32 *DeviceID, OUT gctBOOL *HasEnv); gceSTATUS gcoHAL_QuerySRAM(IN gcoHAL Hal, IN gcePOOL Type, OUT gctUINT32 *Size, OUT gctADDRESS *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 *Address, 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); /* Send fence command for GL_TIME_ELAPSED. */ gceSTATUS gcoHAL_TimeQuery_SendFence(IN gcoHAL Hal, IN gctADDRESS physical); /* Wait fence result for GL_TIME_ELAPSED. */ gceSTATUS gcoHAL_TimeQuery_WaitFence(IN gcoHAL Hal, IN gcsSURF_NODE_PTR node, IN gctPOINTER nodeHeaderLocked, IN gctPOINTER logical); #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_Query2DCoreCount(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_QueryUscAttribCacheRatio(IN gcoHAL Hal, OUT gctUINT32 *UscAttribCacheRatio); 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_SetDeviceIndex(IN gcoHAL Hal, IN gctUINT32 DeviceIndex); gceSTATUS gcoHAL_GetCurrentDeviceIndex(IN gcoHAL Hal, OUT gctUINT32 *DeviceIndex); gceSTATUS gcoHAL_SetCoreIndex(IN gcoHAL Hal, IN gctUINT32 Core); gceSTATUS gcoHAL_GetCurrentCoreIndex(IN gcoHAL Hal, OUT gctUINT32 *Core); gceSTATUS gcoHAL_InitCoreIndexByType(IN gcoHAL Hal, IN gceHARDWARE_TYPE Type, IN gctBOOL Init, OUT gctUINT32 *CoreIndex); 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, OUT gctBOOL *OldValue); gceSTATUS gcoHAL_AllocateVideoMemory(IN gctUINT Alignment, IN gceVIDMEM_TYPE Type, IN gctUINT32 Flag, IN OUT gcePOOL *Pool, IN OUT gctSIZE_T *Bytes, OUT gctUINT32_PTR Node); gceSTATUS gcoHAL_LockVideoMemory(IN gctUINT32 Node, IN gctBOOL Cacheable, IN gceENGINE engine, OUT gctADDRESS *Address, OUT gctPOINTER *Logical); gceSTATUS gcoHAL_LockVideoMemoryEx(IN gctUINT32 Node, IN gctBOOL Cacheable, IN gceENGINE engine, IN gceLOCK_VIDEO_MEMORY_OP Op, OUT gctADDRESS *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, IN gceLOCK_VIDEO_MEMORY_OP Op); 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_PrepareVideoMemory(IN gctUINT32 Node); gceSTATUS gcoHAL_FinishVideoMemory(IN gctUINT32 Node); 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); gceSTATUS gcoHAL_GetLastCommitStatus(IN gcoHAL Hal, OUT gctBOOL *Pending); gceSTATUS gcoHAL_SetLastCommitStatus(IN gcoHAL Hal, IN gctBOOL Pending); gceSTATUS gcoHAL_CommitDone(IN gcoHAL Hal); gceSTATUS gcoHAL_IsFlatMapped(IN gctPHYS_ADDR_T PhysicalAddress, OUT gctADDRESS *Address); gceSTATUS gcoHAL_QueryMCFESemaphoreCapacity(IN gcoHAL Hal, OUT gctUINT32 *Capacity); #if gcdENABLE_MP_SWITCH gceSTATUS gcoHAL_SwitchMpMode(gcoHAL Hal); #endif gceSTATUS gcoHAL_CommandBufferAutoCommit(gcoHAL Hal, gctBOOL AutoCommit); gceSTATUS gcoHAL_CommandBufferAutoSync(gcoHAL Hal, gctBOOL AutoSync); #if gcdENABLE_MULTI_DEVICE_MANAGEMENT gceSTATUS gcoHAL_SwitchContext(IN gcoHAL Hal, IN gcoHARDWARE Hardware, OUT gcoHARDWARE *SavedHardware, OUT gceHARDWARE_TYPE *SavedType, OUT gctUINT32 *SavedHwDeviceIndex, OUT gctUINT32 *SavedCoreIndex); gceSTATUS gcoHAL_RestoreContext(IN gcoHAL Hal, IN gcoHARDWARE Hardware, IN gceHARDWARE_TYPE Type, IN gctUINT32 HwDeviceIndex, IN gctUINT32 CoreIndex); gceSTATUS gcoHAL_ShowDeviceInfo(gcoHAL Hal); #endif /****************************************************************************** ********************************** 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); gceSTATUS gcoOS_Realloc(IN gcoOS Os, IN gctSIZE_T Bytes, IN gctSIZE_T OrgBytes, 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); /* Realloc memory. */ gceSTATUS gcoOS_ReallocMemory(IN gcoOS Os, IN gctSIZE_T Bytes, IN gctSIZE_T OrgBytes, 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 #define gcdMAX_ARGUMENT_SIZE 1024 #define gcdMAX_ARGUMENT_COUNT 64 /* 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 occurrence 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 string to double. */ gceSTATUS gcoOS_StrToDouble(IN gctCONST_STRING String, OUT gctDOUBLE* Double); /* 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, ...) CHECK_PRINTF_FORMAT(4, 5); 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 gceProfilerMode ProfileMode, IN gctCONST_STRING FileName); #endif /* Get the amount of physical system memory */ gceSTATUS gcoOS_GetPhysicalSystemMemorySize(OUT gctUINT64 *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); gceSTATUS gcoOS_QueryCurrentProcessArguments(OUT gctCHAR Argv[gcdMAX_ARGUMENT_COUNT][gcdMAX_ARGUMENT_SIZE], OUT gctUINT32 *Argc, IN gctUINT32 MaxArgc, IN gctUINT32 MaxSizePerArg); /*----------------------------------------------------------------------------*/ /*----- 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 milliseconds. */ gceSTATUS gcoOS_Delay(IN gcoOS Os, IN gctUINT32 Delay); /* Delay a number of microseconds. */ gceSTATUS gcoOS_DelayUs(IN gcoOS Os, IN gctUINT32 Delay); /*----------------------------------------------------------------------------*/ /*----- Threads --------------------------------------------------------------*/ #ifdef _WIN32 /* Cannot include windows.h here because "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_CacheCleanEx(IN gcoOS Os, IN gctUINT32 Node, IN gctPOINTER Logical, IN gctSIZE_T Offset, IN gctSIZE_T Bytes); gceSTATUS gcoOS_CacheFlushEx(IN gcoOS Os, IN gctUINT32 Node, IN gctPOINTER Logical, IN gctSIZE_T Offset, IN gctSIZE_T Bytes); gceSTATUS gcoOS_CacheInvalidateEx(IN gcoOS Os, IN gctUINT32 Node, IN gctPOINTER Logical, IN gctSIZE_T Offset, 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 gcoHAL_QueryCPUFrequency(IN gctUINT32 CPUId, OUT gctUINT32_PTR CPUFrequency); 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 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 #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) #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 _gcs2D_RGBU32 { gctUINT32 R; gctUINT32 G; gctUINT32 B; } gcs2D_RGBU32; 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; /* Intensity format class. */ typedef struct _gcsFORMAT_CLASs_TYPE_INTENSITY { gcsFORMAT_COMPONENT value; } gcsFORMAT_CLASs_TYPE_INTENSITY; 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; gcsFORMAT_CLASs_TYPE_INTENSITY intensity; } 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; typedef union _gcu2D_STATE_VALUE { gcs2D_RGBU32 minValue; gcs2D_RGBU32 maxMinReciprocal; gcs2D_RGBU32 stdReciprocal; gcs2D_RGBU32 meanValue; gctBOOL enable; gctUINT32 stepReciprocal; gce2D_NORMALIZATION_MODE normalizationMode; gctBOOL byPassQuantization; gce2D_U8ToU10_CONVERSION_MODE u8Tu10_Mode; gce2D_MULTICORE_MODE multicoreMode; } gcu2D_STATE_VALUE; /* Set 2D state */ typedef struct _gcs2D_STATE_CONFIG { gce2D_STATE_KEY state; gcu2D_STATE_VALUE value; } gcs2D_STATE_CONFIG; /* 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); gceSTATUS gcoSURF_ConstructWithUserPool(IN gcoHAL Hal, IN gctUINT Width, IN gctUINT Height, IN gctUINT Depth, IN gceSURF_TYPE Type, IN gceSURF_FORMAT Format, IN gctPOINTER TileStatusLogical, IN gctPHYS_ADDR_T TileStatusPhysical, IN gctPOINTER Logical, IN gctPHYS_ADDR_T Physical, OUT gcoSURF *Surface); /* Destroy an gcoSURF object. */ gceSTATUS gcoSURF_Destroy(IN gcoSURF Surface); gceSTATUS gcoSURF_DestroyForAllHWType(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 gctADDRESS 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); /* Query vid mem Multi node info. */ gceSTATUS gcoSURF_QueryVidMemMultiNode(IN gcoSURF Surface, OUT gctUINT32 *Node, OUT gcePOOL *Pool, OUT gctSIZE_T_PTR Bytes, OUT gctUINT32 *Node2, OUT gcePOOL *Pool2, OUT gctSIZE_T_PTR Bytes2, OUT gctUINT32 *Node3, OUT gcePOOL *Pool3, OUT gctSIZE_T_PTR Bytes3); /* 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 gctADDRESS *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); gceSTATUS gcoSURF_3DBlitClearTileStatus(IN gcsSURF_VIEW *SurfView, IN gctBOOL ClearAsDirty); /* 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 gcoSURF_NODE_CacheEx(IN gcsSURF_NODE_PTR Node, IN gctPOINTER Logical, IN gctSIZE_T Offset, IN gctSIZE_T Bytes, IN gceCACHEOPERATION Operation); gceSTATUS gcsSURF_NODE_SetHardwareAddress(IN gcsSURF_NODE_PTR Node, IN gctADDRESS Address); gceSTATUS gcsSURF_NODE_GetHardwareAddress(IN gcsSURF_NODE_PTR Node, OUT gctADDRESS *Physical, OUT gctADDRESS *Physical2, OUT gctADDRESS *Physical3, OUT gctADDRESS *PhysicalBottom); gctADDRESS gcsSURF_NODE_GetHWAddress(IN gcsSURF_NODE_PTR Node); /* Lock and unlock surface node */ gceSTATUS gcoSURF_LockNode(IN gcsSURF_NODE_PTR Node, OUT gctADDRESS *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); #ifdef EMULATOR /* Wrap user memory by external address. */ gceSTATUS gcoSURF_WrapUserMemory_2(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_PTR Address, IN gctUINT32 Flag, OUT gcoSURF * Surface); #endif 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 . ** ... 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 /******************************************************************************* ** ** 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 . ** ... 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, ...) CHECK_PRINTF_FORMAT(2, 3); void gcoOS_DebugTrace(IN gctUINT32 Level, IN gctCONST_STRING Message, ...) CHECK_PRINTF_FORMAT(2, 3); #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 debuger 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 tuning 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() \ do { \ gcmkBINARY_TRACE(__FUNCTION__, __LINE__, gcvNULL, gcvNULL); \ gcmkTRACE_ZONE(gcdHEADER_LEVEL, _GC_OBJ_ZONE, \ "++%s(%d)", __FUNCTION__, __LINE__); \ } while (0) #else gcmINLINE static void __dummy_kheader(void) { } # define gcmkHEADER __dummy_kheader #endif #if gcdHAS_ELLIPSIS # define gcmkHEADER_ARG(Text, ...) \ do { \ gcmkBINARY_TRACE(__FUNCTION__, __LINE__, Text, __VA_ARGS__); \ gcmkTRACE_ZONE(gcdHEADER_LEVEL, _GC_OBJ_ZONE, \ "++%s(%d): " Text, \ __FUNCTION__, __LINE__, __VA_ARGS__); \ } while (0) #else gcmINLINE static void __dummy_kheader_arg(IN gctCONST_STRING Text, ...) { } # define gcmkHEADER_ARG __dummy_kheader_arg #endif #if gcdHAS_ELLIPSIS # define gcmkFOOTER() \ do { \ gcmkBINARY_TRACE(__FUNCTION__, __LINE__, gcvNULL, status); \ gcmkTRACE_ZONE(gcdHEADER_LEVEL, _GC_OBJ_ZONE, \ "--%s(%d): status=%d(%s)", \ __FUNCTION__, __LINE__, status, \ gckOS_DebugStatus2Name(status)); \ } while (0) #else gcmINLINE static void __dummy_kfooter(void) { } # define gcmkFOOTER __dummy_kfooter #endif #if gcdHAS_ELLIPSIS # define gcmkFOOTER_NO() \ do { \ gcmkBINARY_TRACE(__FUNCTION__, __LINE__, gcvNULL, gcvNULL); \ gcmkTRACE_ZONE(gcdHEADER_LEVEL, _GC_OBJ_ZONE, \ "--%s(%d)", __FUNCTION__, __LINE__); \ } while (0) #else gcmINLINE static void __dummy_kfooter_no(void) { } # define gcmkFOOTER_NO __dummy_kfooter_no #endif #if gcdHAS_ELLIPSIS # define gcmkFOOTER_ARG(Text, ...) \ do { \ gcmkBINARY_TRACE(__FUNCTION__, __LINE__, Text, __VA_ARGS__); \ gcmkTRACE_ZONE(gcdHEADER_LEVEL, _GC_OBJ_ZONE, \ "--%s(%d): " Text, \ __FUNCTION__, __LINE__, __VA_ARGS__); \ } while (0) #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, ...) CHECK_PRINTF_FORMAT(1, 2); void gcoOS_Print(IN gctCONST_STRING Message, ...) CHECK_PRINTF_FORMAT(1, 2); #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. ** ** gctADDRESS 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 gctADDRESS 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) \ do { \ if (Hardware->newDump2DLevel > 1) \ gcoOS_Dump2DCommand(cmd, size); \ } while (0) #else # define gcmDUMP_2D_COMMAND(...) \ do { \ } while (0) #endif /******************************************************************************* ** gcmDUMP_2D_SURFACE ** ** Print the 2D surface memory. ** ** ARGUMENTS: ** ** gctBOOL Src. ** gctADDRESS Address. */ gceSTATUS gcoOS_Dump2DSurface(IN gctBOOL Src, IN gctADDRESS Address); #if gcdDUMP_2D # define gcmDUMP_2D_SURFACE(src, addr) \ do { \ if (Hardware->newDump2DLevel > 2) \ gcoOS_Dump2DSurface(src, addr); \ } while (0) #else # define gcmDUMP_2D_SURFACE(...) \ do { \ } while (0) #endif /******************************************************************************* ** gcmDUMP_ADD_MEMORY_INFO ** ** Record the memory info. ** ** ARGUMENTS: ** ** gctADDRESS Address. ** gctSIZE_T Size. */ gceSTATUS gcfAddMemoryInfo(IN gctADDRESS 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: ** ** gctADDRESS Address. */ gceSTATUS gcfDelMemoryInfo(IN gctADDRESS 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: ** ** gctCONST_STRING 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 function 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) \ do { \ 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; \ } \ } while (gcvFALSE) #define _gcmkERR_RETURN(prefix, func) \ do { \ 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; \ } \ } 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) /* Ignore the debug info when the specific error occurs. */ #define _gcmkONERROR_EX(prefix, func, error) \ do { \ status = func; \ if (gcmIS_ERROR(status)) { \ if (status != (error)) { \ 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 gcmkONERROR_EX(func, error) _gcmkONERROR_EX(gcmk, func, error) #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 whether value of a gctSIZE_T variable 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) /******************************************************************************* ** ** gcmkSAFECASTVA ** ** Check whether value of a gctADDRESS variable beyond the capability ** of 32bits GPU hardware. ** ** ASSUMPTIONS: ** ** ** ** ARGUMENTS: ** ** x A gctUINT32 variable ** y A gctADDRESS variable */ #define gcmkSAFECASTVA(x, y) \ do { \ gctUINT32 tmp = (gctUINT32)(y); \ if (gcmSIZEOF(gctADDRESS) > gcmSIZEOF(gctUINT32)) { \ gcmkASSERT(tmp <= gcvMAXUINT32); \ } \ (x) = tmp; \ } while (gcvFALSE) /******************************************************************************* ** ** gcmSAFECASTVA ** ** Check whether value of a gctADDRESS variable beyond the capability ** of 32bits GPU hardware. ** ** ASSUMPTIONS: ** ** ** ** ARGUMENTS: ** ** x A gctUINT32 variable ** y A gctADDRESS variable */ #define gcmSAFECASTVA(x, y) \ do { \ gctUINT32 tmp = (gctUINT32)(y); \ if (gcmSIZEOF(gctADDRESS) > 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 /******************************************************************************* ** ** _gcmCHECK_ADD_OVERFLOW */ #define _gcmCHECK_ADD_OVERFLOW(x, y) \ (\ ((x) > 0 && (y) > 0 && gcvMAXSIZE_T - (x) < (y)) ? gcvSTATUS_RESLUT_OVERFLOW : gcvSTATUS_OK \ ) #define gcmCHECK_ADD_OVERFLOW(x, y) _gcmCHECK_ADD_OVERFLOW(x, y) #define gcmkCHECK_ADD_OVERFLOW(x, y) _gcmCHECK_ADD_OVERFLOW(x, y) #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 /*----------------------------------------------------------------------------*/ #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); \ \ gcmSAFECASTSIZET(__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); \ \ gcmSAFECASTSIZET(__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__; \ \ gcmSAFECASTSIZET(__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__; \ \ gcmSAFECASTSIZET(__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_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 gcmSETBLOCKCTRLSTATE_NEW(StateDelta, CommandBuffer, Memory, \ FixedPoint, Address, Data, Count) \ { \ gctUINT32 c; \ gcmBEGINSTATEBATCH_NEW(CommandBuffer, Memory, \ FixedPoint, Address, Count); \ for (c = 0; c < Count; c++) { \ gcmSETCTRLSTATE_NEW(StateDelta, CommandBuffer, \ Memory, Address, Data); \ } \ gcmENDSTATEBATCH_NEW(CommandBuffer, Memory); \ } #define gcmSETCTRLSTATES_NEW(StateDelta, CommandBuffer, Memory, \ FixedPoint, Address, Data, Count) \ { \ gctUINT32 c; \ gcmBEGINSTATEBATCH_NEW(CommandBuffer, Memory, \ FixedPoint, Address, Count); \ for (c = 0; c < Count; c++) { \ gcmSETCTRLSTATE_NEW(StateDelta, CommandBuffer, \ Memory, Address, Data[c]); \ } \ 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 gcmSETSTATEDATA_NEW_FAST(StateDelta, CommandBuffer, Memory, \ FixedPoint, Address, Data) \ { \ gctUINT32 __temp_data32__; \ \ gcmSAFECASTSIZET(__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 gcmDEFINESTATEBUFFER_NEW_FAST(CommandBuffer, Memory) \ gcmDEFINELOADSTATEBASE() \ gcsTEMPCMDBUF CommandBuffer = gcvNULL; \ gctUINT32_PTR Memory; #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, ComputeOnly, 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 if (NumConstants == 160 && ComputeOnly) { \ UnifiedConst = gcvTRUE; \ VsConstBase = 0xD000; \ PsConstBase = 0xD800; \ VsConstMax = 0; \ PsConstMax = 160; \ ConstMax = 160; \ } 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, ComputeOnly, 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 if (NumConstants == 160 && ComputeOnly) \ { \ UnifiedConst = gcvTRUE; \ VsConstMax = 0; \ PsConstMax = 160; \ } \ 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, Hardware, featureUSC, featureSeparateLS, featureComputeOnly, \ featureTS, featureL1CacheSize, featureUSCMaxPages, \ attribCacheRatio, L1CacheRatio) \ { \ attribCacheRatio = 0x2; \ \ if (featureUSC) \ { \ if (featureSeparateLS) \ { \ L1CacheRatio = 0x0; \ } \ else \ { \ gctUINT L1cacheSize; \ \ if (featureComputeOnly) \ { \ L1cacheSize = featureL1CacheSize; \ attribCacheRatio = 0x7; \ } \ else \ { \ gctUINT attribBufSizeInKB; \ if (featureTS) \ { \ /* GS/TS must be bundled. */ \ attribBufSizeInKB = 42; \ attribCacheRatio = (Hardware->identity.chipModel != gcv8800)? \ 0x3 \ : 0x4; \ } \ 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 void gcd_2D_printf( const char *format, ... ); #if gcd_2D_PRINT_TIME_STAMP void gcd_2D_print_time_stamp( IN const char* function_name, IN char* order ); #define gcmPRINT_2D_TIME_STAMP(function_name, order) \ gcd_2D_print_time_stamp(function_name, order) #else #define gcmPRINT_2D_TIME_STAMP(function_name, order) #endif #ifdef __cplusplus } #endif #endif /* __gc_hal_base_h_ */