| /*************************************************************************/ /*! |
| @File |
| @Title pdump functions |
| @Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved |
| @Description Main APIs for pdump functions |
| @License Dual MIT/GPLv2 |
| |
| The contents of this file are subject to the MIT license as set out below. |
| |
| Permission is hereby granted, free of charge, to any person obtaining a copy |
| of this software and associated documentation files (the "Software"), to deal |
| in the Software without restriction, including without limitation the rights |
| to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| copies of the Software, and to permit persons to whom the Software is |
| furnished to do so, subject to the following conditions: |
| |
| The above copyright notice and this permission notice shall be included in |
| all copies or substantial portions of the Software. |
| |
| Alternatively, the contents of this file may be used under the terms of |
| the GNU General Public License Version 2 ("GPL") in which case the provisions |
| of GPL are applicable instead of those above. |
| |
| If you wish to allow use of your version of this file only under the terms of |
| GPL, and not to allow others to use your version of this file under the terms |
| of the MIT license, indicate your decision by deleting the provisions above |
| and replace them with the notice and other provisions required by GPL as set |
| out in the file called "GPL-COPYING" included in this distribution. If you do |
| not delete the provisions above, a recipient may use your version of this file |
| under the terms of either the MIT license or GPL. |
| |
| This License is also included in this distribution in the file called |
| "MIT-COPYING". |
| |
| EXCEPT AS OTHERWISE STATED IN A NEGOTIATED AGREEMENT: (A) THE SOFTWARE IS |
| PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING |
| BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR |
| PURPOSE AND NONINFRINGEMENT; AND (B) IN NO EVENT SHALL THE AUTHORS OR |
| COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER |
| IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ /**************************************************************************/ |
| |
| #ifndef PDUMP_KM_H |
| #define PDUMP_KM_H |
| |
| #if defined(PDUMP) |
| #include <stdarg.h> |
| #endif |
| |
| /* services/srvkm/include/ */ |
| #include "device.h" |
| |
| /* include/ */ |
| #include "pvrsrv_error.h" |
| |
| |
| #if defined(__KERNEL__) && defined(LINUX) && !defined(__GENKSYMS__) |
| #define __pvrsrv_defined_struct_enum__ |
| #include <services_kernel_client.h> |
| #endif |
| |
| #include "connection_server.h" |
| /* |
| * Pull in pdump flags from services include |
| */ |
| #include "pdump.h" |
| #include "pdumpdefs.h" |
| |
| /* Define this to enable the PDUMP_HERE trace in the server */ |
| #undef PDUMP_TRACE |
| |
| #if defined(PDUMP_TRACE) |
| #define PDUMP_HERE_VAR IMG_UINT32 here = 0; |
| #define PDUMP_HERE(a) { here = (a); if (ui32Flags & PDUMP_FLAGS_DEBUG) PVR_DPF((PVR_DBG_WARNING, "HERE %d", (a))); } |
| #define PDUMP_HEREA(a) { here = (a); PVR_DPF((PVR_DBG_WARNING, "HERE ALWAYS %d", (a))); } |
| #else |
| #define PDUMP_HERE_VAR IMG_UINT32 here = 0; |
| #define PDUMP_HERE(a) here = (a); |
| #define PDUMP_HEREA(a) here = (a); |
| #endif |
| |
| #define PDUMP_PD_UNIQUETAG (IMG_HANDLE)0 |
| #define PDUMP_PT_UNIQUETAG (IMG_HANDLE)0 |
| |
| /* Invalid value for PDump block number */ |
| #define PDUMP_BLOCKNUM_INVALID IMG_UINT32_MAX |
| |
| typedef struct _PDUMP_CONNECTION_DATA_ PDUMP_CONNECTION_DATA; |
| |
| /* PDump transition events */ |
| typedef enum _PDUMP_TRANSITION_EVENT_ |
| { |
| PDUMP_TRANSITION_EVENT_NONE, /* No event */ |
| PDUMP_TRANSITION_EVENT_BLOCK_FINISHED, /* Block mode event, current PDump-block has finished */ |
| PDUMP_TRANSITION_EVENT_BLOCK_STARTED, /* Block mode event, new PDump-block has started */ |
| PDUMP_TRANSITION_EVENT_RANGE_ENTERED, /* Transition into capture range */ |
| PDUMP_TRANSITION_EVENT_RANGE_EXITED, /* Transition out of capture range */ |
| } PDUMP_TRANSITION_EVENT; |
| |
| typedef PVRSRV_ERROR (*PFN_PDUMP_TRANSITION)(void *pvData, void *pvDevice, PDUMP_TRANSITION_EVENT eEvent, IMG_UINT32 ui32PDumpFlags); |
| typedef void (*PFN_PDUMP_SYNCBLOCKS)(void *pvData, PDUMP_TRANSITION_EVENT eEvent); |
| |
| |
| #ifdef PDUMP |
| |
| /*! Macro used to record a panic in the PDump script stream */ |
| #define PDUMP_PANIC(_id, _msg) do \ |
| { PVRSRV_ERROR _eE;\ |
| _eE = PDumpPanic(((RGX_PDUMP_PANIC_ ## _id) & 0xFFFF), _msg, __func__, __LINE__); \ |
| PVR_LOG_IF_ERROR(_eE, "PDumpPanic");\ |
| MSC_SUPPRESS_4127\ |
| } while (0) |
| |
| /*! Macro used to record a driver error in the PDump script stream to invalidate the capture */ |
| #define PDUMP_ERROR(_err, _msg) \ |
| (void)PDumpCaptureError(_err, _msg, __func__, __LINE__) |
| |
| #define SZ_MSG_SIZE_MAX PVRSRV_PDUMP_MAX_COMMENT_SIZE |
| #define SZ_SCRIPT_SIZE_MAX PVRSRV_PDUMP_MAX_COMMENT_SIZE |
| #define SZ_FILENAME_SIZE_MAX (PVRSRV_PDUMP_MAX_FILENAME_SIZE+sizeof(PDUMP_PARAM_N_FILE_NAME)) |
| |
| #define PDUMP_GET_SCRIPT_STRING() \ |
| IMG_HANDLE hScript; \ |
| void *pvScriptAlloc; \ |
| IMG_UINT32 ui32MaxLen = SZ_SCRIPT_SIZE_MAX-1; \ |
| pvScriptAlloc = OSAllocMem( SZ_SCRIPT_SIZE_MAX ); \ |
| if (!pvScriptAlloc) \ |
| { \ |
| PVR_DPF((PVR_DBG_ERROR, "PDUMP_GET_SCRIPT_STRING() failed to allocate memory for script buffer")); \ |
| return PVRSRV_ERROR_OUT_OF_MEMORY; \ |
| } \ |
| \ |
| hScript = (IMG_HANDLE) pvScriptAlloc; |
| |
| #define PDUMP_GET_MSG_STRING() \ |
| IMG_CHAR *pszMsg; \ |
| void *pvMsgAlloc; \ |
| IMG_UINT32 ui32MaxLen = SZ_MSG_SIZE_MAX-1; \ |
| pvMsgAlloc = OSAllocMem( SZ_MSG_SIZE_MAX ); \ |
| if (!pvMsgAlloc) \ |
| { \ |
| PVR_DPF((PVR_DBG_ERROR, "PDUMP_GET_MSG_STRING() failed to allocate memory for message buffer")); \ |
| return PVRSRV_ERROR_OUT_OF_MEMORY; \ |
| } \ |
| pszMsg = (IMG_CHAR *)pvMsgAlloc; |
| |
| #define PDUMP_GET_SCRIPT_AND_FILE_STRING() \ |
| IMG_HANDLE hScript; \ |
| IMG_CHAR *pszFileName; \ |
| IMG_UINT32 ui32MaxLenScript = SZ_SCRIPT_SIZE_MAX-1; \ |
| void *pvScriptAlloc; \ |
| void *pvFileAlloc; \ |
| pvScriptAlloc = OSAllocMem( SZ_SCRIPT_SIZE_MAX ); \ |
| if (!pvScriptAlloc) \ |
| { \ |
| PVR_DPF((PVR_DBG_ERROR, "PDUMP_GET_SCRIPT_AND_FILE_STRING() failed to allocate memory for script buffer")); \ |
| return PVRSRV_ERROR_OUT_OF_MEMORY; \ |
| } \ |
| \ |
| hScript = (IMG_HANDLE) pvScriptAlloc; \ |
| pvFileAlloc = OSAllocMem( SZ_FILENAME_SIZE_MAX ); \ |
| if (!pvFileAlloc) \ |
| { \ |
| PVR_DPF((PVR_DBG_ERROR, "PDUMP_GET_SCRIPT_AND_FILE_STRING() failed to allocate memory for filename buffer")); \ |
| OSFreeMem(pvScriptAlloc); \ |
| return PVRSRV_ERROR_OUT_OF_MEMORY; \ |
| } \ |
| pszFileName = (IMG_CHAR *)pvFileAlloc; |
| |
| #define PDUMP_RELEASE_SCRIPT_STRING() \ |
| if (pvScriptAlloc) \ |
| { \ |
| OSFreeMem(pvScriptAlloc); \ |
| pvScriptAlloc = NULL; \ |
| } |
| |
| #define PDUMP_RELEASE_MSG_STRING() \ |
| if (pvMsgAlloc) \ |
| { \ |
| OSFreeMem(pvMsgAlloc); \ |
| pvMsgAlloc = NULL; \ |
| } |
| |
| #define PDUMP_RELEASE_FILE_STRING() \ |
| if (pvFileAlloc) \ |
| { \ |
| OSFreeMem(pvFileAlloc); \ |
| pvFileAlloc = NULL; \ |
| } |
| |
| #define PDUMP_RELEASE_SCRIPT_AND_FILE_STRING() \ |
| if (pvScriptAlloc) \ |
| { \ |
| OSFreeMem(pvScriptAlloc); \ |
| pvScriptAlloc = NULL; \ |
| } \ |
| if (pvFileAlloc) \ |
| { \ |
| OSFreeMem(pvFileAlloc); \ |
| pvFileAlloc = NULL; \ |
| } |
| |
| |
| /* Shared across pdump_x files */ |
| PVRSRV_ERROR PDumpInitCommon(void); |
| void PDumpDeInitCommon(void); |
| PVRSRV_ERROR PDumpReady(void); |
| void PDumpGetParameterZeroPageInfo(PDUMP_FILEOFFSET_T *puiZeroPageOffset, |
| size_t *puiZeroPageSize, |
| const IMG_CHAR **ppszZeroPageFilename); |
| |
| void PDumpConnectionNotify(void); |
| void PDumpDisconnectionNotify(void); |
| |
| void PDumpStopInitPhase(void); |
| PVRSRV_ERROR PDumpSetFrameKM(CONNECTION_DATA *psConnection, |
| PVRSRV_DEVICE_NODE * psDeviceNode, |
| IMG_UINT32 ui32Frame); |
| PVRSRV_ERROR PDumpGetFrameKM(CONNECTION_DATA *psConnection, |
| PVRSRV_DEVICE_NODE * psDeviceNode, |
| IMG_UINT32* pui32Frame); |
| PVRSRV_ERROR PDumpCommentKM(IMG_CHAR *pszComment, IMG_UINT32 ui32Flags); |
| |
| PVRSRV_ERROR PDumpSetDefaultCaptureParamsKM(IMG_UINT32 ui32Mode, |
| IMG_UINT32 ui32Start, |
| IMG_UINT32 ui32End, |
| IMG_UINT32 ui32Interval, |
| IMG_UINT32 ui32MaxParamFileSize); |
| |
| |
| PVRSRV_ERROR PDumpReg32(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32RegAddr, |
| IMG_UINT32 ui32RegValue, |
| IMG_UINT32 ui32Flags); |
| |
| PVRSRV_ERROR PDumpReg64(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32RegAddr, |
| IMG_UINT64 ui64RegValue, |
| IMG_UINT32 ui32Flags); |
| |
| PVRSRV_ERROR PDumpRegLabelToReg64(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32RegDst, |
| IMG_UINT32 ui32RegSrc, |
| IMG_UINT32 ui32Flags); |
| |
| PVRSRV_ERROR PDumpPhysHandleToInternalVar64(IMG_CHAR *pszInternalVar, |
| IMG_HANDLE hPdumpPages, |
| IMG_UINT32 ui32Flags); |
| |
| PVRSRV_ERROR PDumpMemLabelToInternalVar64(IMG_CHAR *pszInternalVar, |
| PMR *psPMR, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffset, |
| IMG_UINT32 ui32Flags); |
| |
| PVRSRV_ERROR PDumpWriteVarORValueOp(const IMG_CHAR *pszInternalVariable, |
| const IMG_UINT64 ui64Value, |
| const IMG_UINT32 ui32PDumpFlags); |
| |
| PVRSRV_ERROR PDumpWriteVarANDValueOp(const IMG_CHAR *pszInternalVariable, |
| const IMG_UINT64 ui64Value, |
| const IMG_UINT32 ui32PDumpFlags); |
| |
| PVRSRV_ERROR PDumpWriteVarSHRValueOp(const IMG_CHAR *pszInternalVariable, |
| const IMG_UINT64 ui64Value, |
| const IMG_UINT32 ui32PDumpFlags); |
| |
| PVRSRV_ERROR PDumpInternalVarToReg32(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32Reg, |
| IMG_CHAR *pszInternalVar, |
| IMG_UINT32 ui32Flags); |
| |
| PVRSRV_ERROR PDumpInternalVarToReg64(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32Reg, |
| IMG_CHAR *pszInternalVar, |
| IMG_UINT32 ui32Flags); |
| |
| PVRSRV_ERROR PDumpMemLabelToMem32(PMR *psPMRSource, |
| PMR *psPMRDest, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffsetSource, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffsetDest, |
| IMG_UINT32 ui32Flags); |
| |
| PVRSRV_ERROR PDumpMemLabelToMem64(PMR *psPMRSource, |
| PMR *psPMRDest, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffsetSource, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffsetDest, |
| IMG_UINT32 ui32Flags); |
| |
| PVRSRV_ERROR PDumpRegLabelToMem32(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32Reg, |
| PMR *psPMR, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffset, |
| IMG_UINT32 ui32Flags); |
| |
| PVRSRV_ERROR PDumpRegLabelToMem64(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32Reg, |
| PMR *psPMR, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffset, |
| IMG_UINT32 ui32Flags); |
| |
| PVRSRV_ERROR PDumpRegLabelToInternalVar(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32Reg, |
| IMG_CHAR *pszInternalVar, |
| IMG_UINT32 ui32Flags); |
| |
| PVRSRV_ERROR PDumpSAW(IMG_CHAR *pszDevSpaceName, |
| IMG_UINT32 ui32HPOffsetBytes, |
| IMG_UINT32 ui32NumSaveBytes, |
| IMG_CHAR *pszOutfileName, |
| IMG_UINT32 ui32OutfileOffsetByte, |
| PDUMP_FLAGS_T uiPDumpFlags); |
| |
| PVRSRV_ERROR PDumpRegPolKM(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32RegAddr, |
| IMG_UINT32 ui32RegValue, |
| IMG_UINT32 ui32Mask, |
| IMG_UINT32 ui32Flags, |
| PDUMP_POLL_OPERATOR eOperator); |
| |
| PVRSRV_ERROR PDumpBitmapKM(PVRSRV_DEVICE_NODE *psDeviceNode, |
| IMG_CHAR *pszFileName, |
| IMG_UINT32 ui32FileOffset, |
| IMG_UINT32 ui32Width, |
| IMG_UINT32 ui32Height, |
| IMG_UINT32 ui32StrideInBytes, |
| IMG_DEV_VIRTADDR sDevBaseAddr, |
| IMG_UINT32 ui32MMUContextID, |
| IMG_UINT32 ui32Size, |
| PDUMP_PIXEL_FORMAT ePixelFormat, |
| IMG_UINT32 ui32AddrMode, |
| IMG_UINT32 ui32PDumpFlags); |
| |
| |
| /**************************************************************************/ /*! |
| @Function PDumpImageDescriptor |
| @Description PDumps image data out as an IMGBv2 data section |
| @Input psDeviceNode Pointer to device node. |
| @Input ui32MMUContextID PDUMP MMU context ID. |
| @Input pszSABFileName Pointer to string containing file name of |
| Image being SABed |
| @Input sData GPU virtual address of this surface. |
| @Input ui32DataSize Image data size |
| @Input ui32LogicalWidth Image logical width |
| @Input ui32LogicalHeight Image logical height |
| @Input ui32PhysicalWidth Image physical width |
| @Input ui32PhysicalHeight Image physical height |
| @Input ePixFmt Image pixel format |
| @Input eFBCompression FB compression mode |
| @Input paui32FBCClearColour FB clear colour (Only applicable to FBC surfaces) |
| @Input eFBCSwizzle FBC channel swizzle (Only applicable to FBC surfaces) |
| @Input sHeader GPU virtual address of the headers of this |
| surface (Only applicable to FBC surfaces) |
| @Input ui32DataSize Header size (Only applicable to FBC surfaces) |
| @Input ui32PDumpFlags PDUMP flags |
| @Return PVRSRV_ERROR: PVRSRV_OK on success. Otherwise, a PVRSRV_ |
| error code |
| */ /***************************************************************************/ |
| PVRSRV_ERROR PDumpImageDescriptor(PVRSRV_DEVICE_NODE *psDeviceNode, |
| IMG_UINT32 ui32MMUContextID, |
| IMG_CHAR *pszSABFileName, |
| IMG_DEV_VIRTADDR sData, |
| IMG_UINT32 ui32DataSize, |
| IMG_UINT32 ui32LogicalWidth, |
| IMG_UINT32 ui32LogicalHeight, |
| IMG_UINT32 ui32PhysicalWidth, |
| IMG_UINT32 ui32PhysicalHeight, |
| PDUMP_PIXEL_FORMAT ePixFmt, |
| IMG_MEMLAYOUT eMemLayout, |
| IMG_FB_COMPRESSION eFBCompression, |
| const IMG_UINT32 *paui32FBCClearColour, |
| PDUMP_FBC_SWIZZLE eFBCSwizzle, |
| IMG_DEV_VIRTADDR sHeader, |
| IMG_UINT32 ui32HeaderSize, |
| IMG_UINT32 ui32PDumpFlags); |
| |
| /**************************************************************************/ /*! |
| @Function PDumpDataDescriptor |
| @Description PDumps non-image data out as an IMGCv1 data section |
| @Input psDeviceNode Pointer to device node. |
| @Input ui32MMUContextID PDUMP MMU context ID. |
| @Input pszSABFileName Pointer to string containing file name of |
| Data being SABed |
| @Input sData GPU virtual address of this data. |
| @Input ui32DataSize Data size |
| @Input ui32ElementType Data element type |
| @Input ui32ElementCount Number of data elements |
| @Input ui32PDumpFlags PDUMP flags |
| @Return PVRSRV_ERROR: PVRSRV_OK on success. Otherwise, a PVRSRV_ |
| error code |
| */ /***************************************************************************/ |
| PVRSRV_ERROR PDumpDataDescriptor(PVRSRV_DEVICE_NODE *psDeviceNode, |
| IMG_UINT32 ui32MMUContextID, |
| IMG_CHAR *pszSABFileName, |
| IMG_DEV_VIRTADDR sData, |
| IMG_UINT32 ui32DataSize, |
| IMG_UINT32 ui32ElementType, |
| IMG_UINT32 ui32ElementCount, |
| IMG_UINT32 ui32PDumpFlags); |
| |
| |
| PVRSRV_ERROR PDumpReadRegKM(IMG_CHAR *pszPDumpRegName, |
| IMG_CHAR *pszFileName, |
| IMG_UINT32 ui32FileOffset, |
| IMG_UINT32 ui32Address, |
| IMG_UINT32 ui32Size, |
| IMG_UINT32 ui32PDumpFlags); |
| |
| __printf(2, 3) |
| PVRSRV_ERROR PDumpCommentWithFlagsNoLock(IMG_UINT32 ui32Flags, |
| IMG_CHAR* pszFormat, |
| ...); |
| |
| PVRSRV_ERROR PDumpCommentWithFlagsNoLockVA(IMG_UINT32 ui32Flags, |
| const IMG_CHAR * pszFormat, |
| va_list args); |
| |
| __printf(2, 3) |
| PVRSRV_ERROR PDumpCommentWithFlags(IMG_UINT32 ui32Flags, |
| IMG_CHAR* pszFormat, |
| ...); |
| |
| PVRSRV_ERROR PDumpCommentWithFlagsVA(IMG_UINT32 ui32Flags, |
| const IMG_CHAR * pszFormat, |
| va_list args); |
| |
| PVRSRV_ERROR PDumpPanic(IMG_UINT32 ui32PanicNo, |
| IMG_CHAR* pszPanicMsg, |
| const IMG_CHAR* pszPPFunc, |
| IMG_UINT32 ui32PPline); |
| |
| PVRSRV_ERROR PDumpCaptureError(PVRSRV_ERROR ui32ErrorNo, |
| IMG_CHAR* pszErrorMsg, |
| const IMG_CHAR* pszPPFunc, |
| IMG_UINT32 ui32PPline); |
| |
| PVRSRV_ERROR PDumpPDReg(PDUMP_MMU_ATTRIB *psMMUAttrib, |
| IMG_UINT32 ui32Reg, |
| IMG_UINT32 ui32dwData, |
| IMG_HANDLE hUniqueTag); |
| PVRSRV_ERROR PDumpPDRegWithFlags(PDUMP_MMU_ATTRIB *psMMUAttrib, |
| IMG_UINT32 ui32Reg, |
| IMG_UINT32 ui32Data, |
| IMG_UINT32 ui32Flags, |
| IMG_HANDLE hUniqueTag); |
| |
| PVRSRV_ERROR PDumpIsLastCaptureFrameKM(IMG_BOOL *pbIsLastCaptureFrame); |
| |
| PVRSRV_ERROR PDumpGetStateKM(IMG_UINT64 *ui64State); |
| |
| PVRSRV_ERROR PDumpGetCurrentBlockKM(IMG_UINT32 *pui32CurrentBlock); |
| |
| PVRSRV_ERROR PDumpForceCaptureStopKM(void); |
| |
| PVRSRV_ERROR PDumpIsCaptureFrameKM(IMG_BOOL *bIsCaptureRange); |
| |
| PVRSRV_ERROR PDumpRegRead32(IMG_CHAR *pszPDumpRegName, |
| const IMG_UINT32 dwRegOffset, |
| IMG_UINT32 ui32Flags); |
| PVRSRV_ERROR PDumpRegRead64(IMG_CHAR *pszPDumpRegName, |
| const IMG_UINT32 dwRegOffset, |
| IMG_UINT32 ui32Flags); |
| PVRSRV_ERROR PDumpRegRead64ToInternalVar(IMG_CHAR *pszPDumpRegName, |
| IMG_CHAR *pszInternalVar, |
| const IMG_UINT32 dwRegOffset, |
| IMG_UINT32 ui32Flags); |
| |
| PVRSRV_ERROR PDumpIDLWithFlags(IMG_UINT32 ui32Clocks, IMG_UINT32 ui32Flags); |
| PVRSRV_ERROR PDumpIDL(IMG_UINT32 ui32Clocks); |
| |
| PVRSRV_ERROR PDumpRegBasedCBP(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32RegOffset, |
| IMG_UINT32 ui32WPosVal, |
| IMG_UINT32 ui32PacketSize, |
| IMG_UINT32 ui32BufferSize, |
| IMG_UINT32 ui32Flags); |
| |
| PVRSRV_ERROR PDumpTRG(IMG_CHAR *pszMemSpace, |
| IMG_UINT32 ui32MMUCtxID, |
| IMG_UINT32 ui32RegionID, |
| IMG_BOOL bEnable, |
| IMG_UINT64 ui64VAddr, |
| IMG_UINT64 ui64LenBytes, |
| IMG_UINT32 ui32XStride, |
| IMG_UINT32 ui32Flags); |
| |
| void PDumpLock(void); |
| void PDumpUnlock(void); |
| PVRSRV_ERROR PDumpIfKM(IMG_CHAR *pszPDumpCond, IMG_UINT32 ui32PDumpFlags); |
| PVRSRV_ERROR PDumpElseKM(IMG_CHAR *pszPDumpCond, IMG_UINT32 ui32PDumpFlags); |
| PVRSRV_ERROR PDumpFiKM(IMG_CHAR *pszPDumpCond, IMG_UINT32 ui32PDumpFlags); |
| |
| void PDumpPowerTransitionStart(void); |
| void PDumpPowerTransitionEnd(void); |
| IMG_BOOL PDumpInPowerTransition(void); |
| IMG_BOOL PDumpIsContCaptureOn(void); |
| |
| /*! |
| * @name PDumpWriteParameter |
| * @brief General function for writing to PDump stream. Used |
| * mainly for memory dumps to parameter stream. |
| * Usually more convenient to use PDumpWriteScript below |
| * for the script stream. |
| * @param psui8Data - data to write |
| * @param ui32Size - size of write |
| * @param ui32Flags - PDump flags |
| * @param pui32FileOffset - on return contains the file offset to |
| * the start of the parameter data |
| * @param aszFilenameStr - pointer to at least a 20 char buffer to |
| * return the parameter filename |
| * @return error |
| */ |
| PVRSRV_ERROR PDumpWriteParameter(IMG_UINT8 *psui8Data, IMG_UINT32 ui32Size, |
| IMG_UINT32 ui32Flags, IMG_UINT32* pui32FileOffset, |
| IMG_CHAR* aszFilenameStr); |
| |
| /*! |
| * @name PDumpWriteScript |
| * @brief Write an PDumpOS created string to the "script" output stream |
| * @param hString - PDump OS layer handle of string buffer to write |
| * @param ui32Flags - PDump flags |
| * @return IMG_TRUE on success. |
| */ |
| IMG_BOOL PDumpWriteScript(IMG_HANDLE hString, IMG_UINT32 ui32Flags); |
| |
| /**************************************************************************/ /*! |
| @Function PDumpSNPrintf |
| @Description Printf to OS-specific PDump state buffer. This function is |
| only called if PDUMP is defined. |
| @Input hBuf handle of buffer to write into |
| @Input ui32ScriptSizeMax maximum size of data to write (chars) |
| @Input pszFormat format string |
| @Return None |
| */ /**************************************************************************/ |
| __printf(3, 4) |
| PVRSRV_ERROR PDumpSNPrintf(IMG_HANDLE hBuf, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, ...); |
| |
| |
| /* |
| PDumpWriteShiftedMaskedValue(): |
| |
| loads the "reference" address into an internal PDump register, |
| optionally shifts it right, |
| optionally shifts it left, |
| optionally masks it |
| then finally writes the computed value to the given destination address |
| |
| i.e. it emits pdump language equivalent to this expression: |
| |
| dest = ((&ref) >> SHRamount << SHLamount) & MASK |
| */ |
| extern PVRSRV_ERROR |
| PDumpWriteShiftedMaskedValue(const IMG_CHAR *pszDestRegspaceName, |
| const IMG_CHAR *pszDestSymbolicName, |
| IMG_DEVMEM_OFFSET_T uiDestOffset, |
| const IMG_CHAR *pszRefRegspaceName, |
| const IMG_CHAR *pszRefSymbolicName, |
| IMG_DEVMEM_OFFSET_T uiRefOffset, |
| IMG_UINT32 uiSHRAmount, |
| IMG_UINT32 uiSHLAmount, |
| IMG_UINT32 uiMask, |
| IMG_DEVMEM_SIZE_T uiWordSize, |
| IMG_UINT32 uiPDumpFlags); |
| |
| /* |
| PDumpWriteSymbAddress(): |
| writes the address of the "reference" to the offset given |
| */ |
| extern PVRSRV_ERROR |
| PDumpWriteSymbAddress(const IMG_CHAR *pszDestSpaceName, |
| IMG_DEVMEM_OFFSET_T uiDestOffset, |
| const IMG_CHAR *pszRefSymbolicName, |
| IMG_DEVMEM_OFFSET_T uiRefOffset, |
| const IMG_CHAR *pszPDumpDevName, |
| IMG_UINT32 ui32WordSize, |
| IMG_UINT32 ui32AlignShift, |
| IMG_UINT32 ui32Shift, |
| IMG_UINT32 uiPDumpFlags); |
| |
| /* Register the connection with the PDump subsystem */ |
| extern PVRSRV_ERROR PDumpRegisterConnection(void *hSyncPrivData, |
| PFN_PDUMP_SYNCBLOCKS pfnPDumpSyncBlocks, |
| PDUMP_CONNECTION_DATA **ppsPDumpConnectionData); |
| |
| /* Unregister the connection with the PDump subsystem */ |
| extern void PDumpUnregisterConnection(PDUMP_CONNECTION_DATA *psPDumpConnectionData); |
| |
| /* Register for notification of PDump Transition into/out of capture range */ |
| extern PVRSRV_ERROR PDumpRegisterTransitionCallback(PDUMP_CONNECTION_DATA *psPDumpConnectionData, |
| PFN_PDUMP_TRANSITION pfnCallback, |
| void *hPrivData, |
| void *pvDevice, |
| void **ppvHandle); |
| |
| /* Unregister notification of PDump Transition */ |
| extern void PDumpUnregisterTransitionCallback(void *pvHandle); |
| |
| /* Notify PDump of a Transition into/out of capture range */ |
| extern PVRSRV_ERROR PDumpTransition(PDUMP_CONNECTION_DATA *psPDumpConnectionData, PDUMP_TRANSITION_EVENT eEvent, IMG_UINT32 ui32PDumpFlags); |
| |
| |
| #define PDUMP_LOCK(_ui32PDumpFlags) do \ |
| { if ((_ui32PDumpFlags & PDUMP_FLAGS_PDUMP_LOCK_HELD) == 0)\ |
| {\ |
| PDumpLock();\ |
| }\ |
| MSC_SUPPRESS_4127\ |
| } while (0) |
| |
| #define PDUMP_UNLOCK(_ui32PDumpFlags) do \ |
| { if ((_ui32PDumpFlags & PDUMP_FLAGS_PDUMP_LOCK_HELD) == 0)\ |
| {\ |
| PDumpUnlock();\ |
| }\ |
| MSC_SUPPRESS_4127\ |
| } while (0) |
| |
| #define PDUMPINIT PDumpInitCommon |
| #define PDUMPDEINIT PDumpDeInitCommon |
| #define PDUMPREG32 PDumpReg32 |
| #define PDUMPREG64 PDumpReg64 |
| #define PDUMPREGREAD32 PDumpRegRead32 |
| #define PDUMPREGREAD64 PDumpRegRead64 |
| #define PDUMPCOMMENT(...) PDumpCommentWithFlags(PDUMP_FLAGS_CONTINUOUS, __VA_ARGS__) |
| #define PDUMPCOMMENTWITHFLAGS PDumpCommentWithFlags |
| #define PDUMPREGPOL PDumpRegPolKM |
| #define PDUMPPDREG PDumpPDReg |
| #define PDUMPPDREGWITHFLAGS PDumpPDRegWithFlags |
| #define PDUMPREGBASEDCBP PDumpRegBasedCBP |
| #define PDUMPENDINITPHASE PDumpStopInitPhase |
| #define PDUMPIDLWITHFLAGS PDumpIDLWithFlags |
| #define PDUMPIDL PDumpIDL |
| #define PDUMPPOWCMDSTART PDumpPowerTransitionStart |
| #define PDUMPPOWCMDEND PDumpPowerTransitionEnd |
| #define PDUMPPOWCMDINTRANS PDumpInPowerTransition |
| |
| #define PDUMP_BLKSTART(_ui32PDumpFlags) do \ |
| { PDUMP_LOCK(_ui32PDumpFlags);\ |
| _ui32PDumpFlags |= PDUMP_FLAGS_PDUMP_LOCK_HELD;\ |
| MSC_SUPPRESS_4127\ |
| } while (0) |
| |
| #define PDUMP_BLKEND(_ui32PDumpFlags) do \ |
| { _ui32PDumpFlags &= ~PDUMP_FLAGS_PDUMP_LOCK_HELD;\ |
| PDUMP_UNLOCK(_ui32PDumpFlags);\ |
| MSC_SUPPRESS_4127\ |
| } while (0) |
| |
| #define PDUMPIF(_msg,_ui32PDumpFlags) do \ |
| {PDUMP_BLKSTART(_ui32PDumpFlags);\ |
| PDumpIfKM(_msg,_ui32PDumpFlags);\ |
| MSC_SUPPRESS_4127\ |
| } while (0) |
| |
| #define PDUMPELSE PDumpElseKM |
| |
| #define PDUMPFI(_msg,_ui32PDumpFlags) do \ |
| { PDumpFiKM(_msg,_ui32PDumpFlags);\ |
| PDUMP_BLKEND(_ui32PDumpFlags);\ |
| MSC_SUPPRESS_4127\ |
| } while (0) |
| |
| #else |
| /* |
| We should be clearer about which functions can be called |
| across the bridge as this looks rather unbalanced |
| */ |
| |
| /*! Macro used to record a panic in the PDump script stream */ |
| #define PDUMP_PANIC(_id, _msg) ((void)0) |
| |
| /*! Macro used to record a driver error in the PDump script stream to invalidate the capture */ |
| #define PDUMP_ERROR(_err, _msg) ((void)0) |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpInitCommon) |
| #endif |
| static INLINE PVRSRV_ERROR |
| PDumpInitCommon(void) |
| { |
| return PVRSRV_OK; |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpConnectionNotify) |
| #endif |
| static INLINE void |
| PDumpConnectionNotify(void) |
| { |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpDisconnectionNotify) |
| #endif |
| static INLINE void |
| PDumpDisconnectionNotify(void) |
| { |
| } |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpLock) |
| #endif |
| static INLINE void |
| PDumpLock(void) |
| { |
| } |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpUnlock) |
| #endif |
| static INLINE void |
| PDumpUnlock(void) |
| { |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpStopInitPhase) |
| #endif |
| static INLINE void |
| PDumpStopInitPhase(void) |
| { |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpSetFrameKM) |
| #endif |
| static INLINE PVRSRV_ERROR |
| PDumpSetFrameKM(CONNECTION_DATA *psConnection, |
| PVRSRV_DEVICE_NODE *psDevNode, |
| IMG_UINT32 ui32Frame) |
| { |
| PVR_UNREFERENCED_PARAMETER(psConnection); |
| PVR_UNREFERENCED_PARAMETER(ui32Frame); |
| return PVRSRV_OK; |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpGetFrameKM) |
| #endif |
| static INLINE PVRSRV_ERROR |
| PDumpGetFrameKM(CONNECTION_DATA *psConnection, |
| PVRSRV_DEVICE_NODE *psDeviceNode, |
| IMG_UINT32* pui32Frame) |
| { |
| PVR_UNREFERENCED_PARAMETER(psConnection); |
| PVR_UNREFERENCED_PARAMETER(pui32Frame); |
| return PVRSRV_OK; |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpCommentKM) |
| #endif |
| static INLINE PVRSRV_ERROR |
| PDumpCommentKM(IMG_CHAR *pszComment, IMG_UINT32 ui32Flags) |
| { |
| PVR_UNREFERENCED_PARAMETER(pszComment); |
| PVR_UNREFERENCED_PARAMETER(ui32Flags); |
| return PVRSRV_OK; |
| } |
| |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpSetDefaultCaptureParamsKM) |
| #endif |
| static INLINE PVRSRV_ERROR |
| PDumpSetDefaultCaptureParamsKM(IMG_UINT32 ui32Mode, |
| IMG_UINT32 ui32Start, |
| IMG_UINT32 ui32End, |
| IMG_UINT32 ui32Interval, |
| IMG_UINT32 ui32MaxParamFileSize) |
| { |
| PVR_UNREFERENCED_PARAMETER(ui32Mode); |
| PVR_UNREFERENCED_PARAMETER(ui32Start); |
| PVR_UNREFERENCED_PARAMETER(ui32End); |
| PVR_UNREFERENCED_PARAMETER(ui32Interval); |
| PVR_UNREFERENCED_PARAMETER(ui32MaxParamFileSize); |
| |
| return PVRSRV_OK; |
| } |
| |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpPanic) |
| #endif |
| static INLINE PVRSRV_ERROR |
| PDumpPanic(IMG_UINT32 ui32PanicNo, |
| IMG_CHAR* pszPanicMsg, |
| const IMG_CHAR* pszPPFunc, |
| IMG_UINT32 ui32PPline) |
| { |
| PVR_UNREFERENCED_PARAMETER(ui32PanicNo); |
| PVR_UNREFERENCED_PARAMETER(pszPanicMsg); |
| PVR_UNREFERENCED_PARAMETER(pszPPFunc); |
| PVR_UNREFERENCED_PARAMETER(ui32PPline); |
| return PVRSRV_OK; |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpCaptureError) |
| #endif |
| static INLINE PVRSRV_ERROR |
| PDumpCaptureError(PVRSRV_ERROR ui32ErrorNo, |
| IMG_CHAR* pszErrorMsg, |
| const IMG_CHAR* pszPPFunc, |
| IMG_UINT32 ui32PPline) |
| { |
| PVR_UNREFERENCED_PARAMETER(ui32ErrorNo); |
| PVR_UNREFERENCED_PARAMETER(pszErrorMsg); |
| PVR_UNREFERENCED_PARAMETER(pszPPFunc); |
| PVR_UNREFERENCED_PARAMETER(ui32PPline); |
| return PVRSRV_OK; |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpIsLastCaptureFrameKM) |
| #endif |
| static INLINE PVRSRV_ERROR |
| PDumpIsLastCaptureFrameKM(IMG_BOOL *pbIsLastCaptureFrame) |
| { |
| *pbIsLastCaptureFrame = IMG_FALSE; |
| return PVRSRV_OK; |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpGetStateKM) |
| #endif |
| static INLINE PVRSRV_ERROR |
| PDumpGetStateKM(IMG_UINT64 *ui64State) |
| { |
| *ui64State = 0; |
| return PVRSRV_OK; |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpIsCaptureFrameKM) |
| #endif |
| static INLINE PVRSRV_ERROR |
| PDumpIsCaptureFrameKM(IMG_BOOL *bIsCapturing) |
| { |
| *bIsCapturing = IMG_FALSE; |
| return PVRSRV_OK; |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpGetCurrentBlockKM) |
| #endif |
| static INLINE PVRSRV_ERROR |
| PDumpGetCurrentBlockKM(IMG_UINT32 *pui32BlockNum) |
| { |
| *pui32BlockNum = PDUMP_BLOCKNUM_INVALID; |
| return PVRSRV_OK; |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpForceCaptureStopKM) |
| #endif |
| static INLINE PVRSRV_ERROR |
| PDumpForceCaptureStopKM(void) |
| { |
| return PVRSRV_OK; |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpBitmapKM) |
| #endif |
| static INLINE PVRSRV_ERROR |
| PDumpBitmapKM(PVRSRV_DEVICE_NODE *psDeviceNode, |
| IMG_CHAR *pszFileName, |
| IMG_UINT32 ui32FileOffset, |
| IMG_UINT32 ui32Width, |
| IMG_UINT32 ui32Height, |
| IMG_UINT32 ui32StrideInBytes, |
| IMG_DEV_VIRTADDR sDevBaseAddr, |
| IMG_UINT32 ui32MMUContextID, |
| IMG_UINT32 ui32Size, |
| PDUMP_PIXEL_FORMAT ePixelFormat, |
| IMG_UINT32 ui32AddrMode, |
| IMG_UINT32 ui32PDumpFlags) |
| { |
| PVR_UNREFERENCED_PARAMETER(psDeviceNode); |
| PVR_UNREFERENCED_PARAMETER(pszFileName); |
| PVR_UNREFERENCED_PARAMETER(ui32FileOffset); |
| PVR_UNREFERENCED_PARAMETER(ui32Width); |
| PVR_UNREFERENCED_PARAMETER(ui32Height); |
| PVR_UNREFERENCED_PARAMETER(ui32StrideInBytes); |
| PVR_UNREFERENCED_PARAMETER(sDevBaseAddr); |
| PVR_UNREFERENCED_PARAMETER(ui32MMUContextID); |
| PVR_UNREFERENCED_PARAMETER(ui32Size); |
| PVR_UNREFERENCED_PARAMETER(ePixelFormat); |
| PVR_UNREFERENCED_PARAMETER(ui32AddrMode); |
| PVR_UNREFERENCED_PARAMETER(ui32PDumpFlags); |
| return PVRSRV_OK; |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpImageDescriptor) |
| #endif |
| static INLINE PVRSRV_ERROR |
| PDumpImageDescriptor(PVRSRV_DEVICE_NODE *psDeviceNode, |
| IMG_UINT32 ui32MMUContextID, |
| IMG_CHAR *pszSABFileName, |
| IMG_DEV_VIRTADDR sData, |
| IMG_UINT32 ui32DataSize, |
| IMG_UINT32 ui32LogicalWidth, |
| IMG_UINT32 ui32LogicalHeight, |
| IMG_UINT32 ui32PhysicalWidth, |
| IMG_UINT32 ui32PhysicalHeight, |
| PDUMP_PIXEL_FORMAT ePixFmt, |
| IMG_MEMLAYOUT eMemLayout, |
| IMG_FB_COMPRESSION eFBCompression, |
| const IMG_UINT32 *paui32FBCClearColour, |
| PDUMP_FBC_SWIZZLE eFBCSwizzle, |
| IMG_DEV_VIRTADDR sHeader, |
| IMG_UINT32 ui32HeaderSize, |
| IMG_UINT32 ui32PDumpFlags) |
| { |
| PVR_UNREFERENCED_PARAMETER(psDeviceNode); |
| PVR_UNREFERENCED_PARAMETER(ui32MMUContextID); |
| PVR_UNREFERENCED_PARAMETER(pszSABFileName); |
| PVR_UNREFERENCED_PARAMETER(sData); |
| PVR_UNREFERENCED_PARAMETER(ui32DataSize); |
| PVR_UNREFERENCED_PARAMETER(ui32LogicalWidth); |
| PVR_UNREFERENCED_PARAMETER(ui32LogicalHeight); |
| PVR_UNREFERENCED_PARAMETER(ui32PhysicalWidth); |
| PVR_UNREFERENCED_PARAMETER(ui32PhysicalHeight); |
| PVR_UNREFERENCED_PARAMETER(ePixFmt); |
| PVR_UNREFERENCED_PARAMETER(eMemLayout); |
| PVR_UNREFERENCED_PARAMETER(eFBCompression); |
| PVR_UNREFERENCED_PARAMETER(paui32FBCClearColour); |
| PVR_UNREFERENCED_PARAMETER(eFBCSwizzle); |
| PVR_UNREFERENCED_PARAMETER(sHeader); |
| PVR_UNREFERENCED_PARAMETER(ui32HeaderSize); |
| PVR_UNREFERENCED_PARAMETER(ui32PDumpFlags); |
| return PVRSRV_OK; |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpDataDescriptor) |
| #endif |
| static INLINE PVRSRV_ERROR |
| PDumpDataDescriptor(PVRSRV_DEVICE_NODE *psDeviceNode, |
| IMG_UINT32 ui32MMUContextID, |
| IMG_CHAR *pszSABFileName, |
| IMG_DEV_VIRTADDR sData, |
| IMG_UINT32 ui32DataSize, |
| IMG_UINT32 ui32ElementType, |
| IMG_UINT32 ui32ElementCount, |
| IMG_UINT32 ui32PDumpFlags) |
| { |
| PVR_UNREFERENCED_PARAMETER(psDeviceNode); |
| PVR_UNREFERENCED_PARAMETER(ui32MMUContextID); |
| PVR_UNREFERENCED_PARAMETER(pszSABFileName); |
| PVR_UNREFERENCED_PARAMETER(sData); |
| PVR_UNREFERENCED_PARAMETER(ui32DataSize); |
| PVR_UNREFERENCED_PARAMETER(ui32ElementType); |
| PVR_UNREFERENCED_PARAMETER(ui32ElementCount); |
| PVR_UNREFERENCED_PARAMETER(ui32PDumpFlags); |
| return PVRSRV_OK; |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpRegisterConnection) |
| #endif |
| static INLINE PVRSRV_ERROR |
| PDumpRegisterConnection(void *hSyncPrivData, |
| PFN_PDUMP_SYNCBLOCKS pfnPDumpSyncBlocks, |
| PDUMP_CONNECTION_DATA **ppsPDumpConnectionData) |
| { |
| PVR_UNREFERENCED_PARAMETER(hSyncPrivData); |
| PVR_UNREFERENCED_PARAMETER(pfnPDumpSyncBlocks); |
| PVR_UNREFERENCED_PARAMETER(ppsPDumpConnectionData); |
| |
| return PVRSRV_OK; |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpUnregisterConnection) |
| #endif |
| static INLINE |
| void PDumpUnregisterConnection(PDUMP_CONNECTION_DATA *psPDumpConnectionData) |
| { |
| PVR_UNREFERENCED_PARAMETER(psPDumpConnectionData); |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpRegisterTransitionCallback) |
| #endif |
| static INLINE |
| PVRSRV_ERROR PDumpRegisterTransitionCallback(PDUMP_CONNECTION_DATA *psPDumpConnectionData, |
| PFN_PDUMP_TRANSITION pfnCallback, |
| void *hPrivData, |
| void *pvDevice, |
| void **ppvHandle) |
| { |
| PVR_UNREFERENCED_PARAMETER(psPDumpConnectionData); |
| PVR_UNREFERENCED_PARAMETER(pfnCallback); |
| PVR_UNREFERENCED_PARAMETER(hPrivData); |
| PVR_UNREFERENCED_PARAMETER(pvDevice); |
| PVR_UNREFERENCED_PARAMETER(ppvHandle); |
| |
| return PVRSRV_OK; |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpUnregisterTransitionCallback) |
| #endif |
| static INLINE |
| void PDumpUnregisterTransitionCallback(void *pvHandle) |
| { |
| PVR_UNREFERENCED_PARAMETER(pvHandle); |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PDumpTransition) |
| #endif |
| static INLINE |
| PVRSRV_ERROR PDumpTransition(PDUMP_CONNECTION_DATA *psPDumpConnectionData, PDUMP_TRANSITION_EVENT eEvent, IMG_UINT32 ui32PDumpFlags) |
| { |
| PVR_UNREFERENCED_PARAMETER(psPDumpConnectionData); |
| PVR_UNREFERENCED_PARAMETER(eEvent); |
| PVR_UNREFERENCED_PARAMETER(ui32PDumpFlags); |
| return PVRSRV_OK; |
| } |
| |
| #if defined LINUX || defined GCC_IA32 || defined GCC_ARM || defined __QNXNTO__ || defined(INTEGRITY_OS) |
| #define PDUMPINIT PDumpInitCommon |
| #define PDUMPDEINIT(args...) |
| #define PDUMPREG32(args...) |
| #define PDUMPREG64(args...) |
| #define PDUMPREGREAD32(args...) |
| #define PDUMPREGREAD64(args...) |
| #define PDUMPCOMMENT(args...) |
| #define PDUMPREGPOL(args...) |
| #define PDUMPPDREG(args...) |
| #define PDUMPPDREGWITHFLAGS(args...) |
| #define PDUMPSYNC(args...) |
| #define PDUMPCOPYTOMEM(args...) |
| #define PDUMPWRITE(args...) |
| #define PDUMPREGBASEDCBP(args...) |
| #define PDUMPCOMMENTWITHFLAGS(args...) |
| #define PDUMPENDINITPHASE(args...) |
| #define PDUMPIDLWITHFLAGS(args...) |
| #define PDUMPIDL(args...) |
| #define PDUMPPOWCMDSTART(args...) |
| #define PDUMPPOWCMDEND(args...) |
| #define PDUMP_LOCK(args...) |
| #define PDUMP_UNLOCK(args...) |
| |
| #else |
| #error Compiler not specified |
| #endif |
| #endif |
| |
| |
| #endif /* PDUMP_KM_H */ |
| |
| /****************************************************************************** |
| End of file (pdump_km.h) |
| ******************************************************************************/ |
