| /*************************************************************************/ /*! |
| @File |
| @Title Common Server PDump functions layer |
| @Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved |
| @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. |
| */ /**************************************************************************/ |
| |
| |
| |
| #if defined(PDUMP) |
| #include <stdarg.h> |
| |
| #include "pvrversion.h" |
| #include "allocmem.h" |
| #include "osfunc.h" |
| #include "pvrsrv.h" |
| #include "pvr_debug.h" |
| #include "srvkm.h" |
| #include "pdump_physmem.h" |
| #include "hash.h" |
| #include "connection_server.h" |
| #include "sync_server.h" |
| #include "services_km.h" |
| /* pdump headers */ |
| #include "dbgdrvif_srv5.h" |
| #include "pdump_osfunc.h" |
| #include "pdump_km.h" |
| |
| /* Allow temporary buffer size override */ |
| #if !defined(PDUMP_TEMP_BUFFER_SIZE) |
| #define PDUMP_TEMP_BUFFER_SIZE (64 * 1024U) |
| #endif |
| |
| /* DEBUG */ |
| #if 0 |
| #define PDUMP_DBG(a) PDumpOSDebugPrintf (a) |
| #else |
| #define PDUMP_DBG(a) |
| #endif |
| |
| |
| #define PTR_PLUS(t, p, x) ((t)(((IMG_CHAR *)(p)) + (x))) |
| #define VPTR_PLUS(p, x) PTR_PLUS(void *, p, x) |
| #define VPTR_INC(p, x) ((p) = VPTR_PLUS(p, x)) |
| #define MAX_PDUMP_MMU_CONTEXTS (32) |
| static void *gpvTempBuffer = NULL; |
| |
| #define PRM_FILE_SIZE_MAX 0x7FDFFFFFU /*!< Default maximum file size to split output files, 2GB-2MB as fwrite limits it to 2GB-1 on 32bit systems */ |
| #define FRAME_UNSET 0xFFFFFFFFU /*|< Used to signify no or invalid frame number */ |
| |
| |
| static IMG_BOOL g_PDumpInitialised = IMG_FALSE; |
| static IMG_UINT32 g_ConnectionCount = 0; |
| |
| |
| typedef struct |
| { |
| PDUMP_CHANNEL sCh; /*!< Channel handles */ |
| } PDUMP_SCRIPT; |
| |
| typedef struct |
| { |
| IMG_UINT32 ui32Init; /*|< Count of bytes written to the init phase stream */ |
| IMG_UINT32 ui32Main; /*!< Count of bytes written to the main stream */ |
| IMG_UINT32 ui32Deinit; /*!< Count of bytes written to the deinit stream */ |
| } PDUMP_CHANNEL_WOFFSETS; |
| |
| typedef struct |
| { |
| PDUMP_CHANNEL sCh; /*!< Channel handles */ |
| PDUMP_CHANNEL_WOFFSETS sWOff; /*!< Channel file write offsets */ |
| IMG_UINT32 ui32FileIdx; /*!< File index used when file size limit reached and a new file is started, parameter channel only */ |
| IMG_UINT32 ui32MaxFileSize; /*!< Maximum file size for parameter files */ |
| |
| PDUMP_FILEOFFSET_T uiZeroPageOffset; /*!< Offset of the zero page in the parameter file */ |
| size_t uiZeroPageSize; /*!< Size of the zero page in the parameter file */ |
| IMG_CHAR szZeroPageFilename[PDUMP_PARAM_MAX_FILE_NAME]; /*< PRM file name where the zero page was pdumped */ |
| } PDUMP_PARAMETERS; |
| |
| static PDUMP_SCRIPT g_PDumpScript = { { 0, 0, 0} }; |
| static PDUMP_PARAMETERS g_PDumpParameters = { { 0, 0, 0}, {0, 0, 0}, 0, PRM_FILE_SIZE_MAX}; |
| |
| |
| #if defined(PDUMP_DEBUG_OUTFILES) |
| /* counter increments each time debug write is called */ |
| IMG_UINT32 g_ui32EveryLineCounter = 1U; |
| #endif |
| |
| #if defined(PDUMP_DEBUG) || defined(REFCOUNT_DEBUG) |
| #define PDUMP_REFCOUNT_PRINT(fmt, ...) PVRSRVDebugPrintf(PVR_DBG_WARNING, __FILE__, __LINE__, fmt, __VA_ARGS__) |
| #else |
| #define PDUMP_REFCOUNT_PRINT(fmt, ...) |
| #endif |
| |
| /* Prototype for the test/debug state dump routine used in debugging */ |
| void PDumpCommonDumpState(IMG_BOOL bDumpOSLayerState); |
| #undef PDUMP_TRACE_STATE |
| |
| |
| /*****************************************************************************/ |
| /* PDump Control Module Definitions */ |
| /*****************************************************************************/ |
| |
| typedef struct _PDUMP_CAPTURE_RANGE_ |
| { |
| IMG_UINT32 ui32Start; /*!< Start frame number of range */ |
| IMG_UINT32 ui32End; /*!< Send frame number of range */ |
| IMG_UINT32 ui32Interval; /*!< Frame sample rate interval */ |
| } PDUMP_CAPTURE_RANGE; |
| |
| /* No direct access to members from outside the control module - please */ |
| typedef struct _PDUMP_CTRL_STATE_ |
| { |
| IMG_BOOL bInitPhaseActive; /*!< State of driver initialisation phase */ |
| IMG_UINT32 ui32Flags; /*!< Unused */ |
| |
| IMG_UINT32 ui32DefaultCapMode; /*!< Capture mode of the dump */ |
| PDUMP_CAPTURE_RANGE sCaptureRange; /*|< The capture range for capture mode 'framed' */ |
| IMG_UINT32 ui32CurrentFrame; /*!< Current frame number */ |
| |
| IMG_BOOL bCaptureOn; /*!< Current capture status, is current frame in range */ |
| IMG_BOOL bSuspended; /*!< Suspend flag set on unrecoverable error */ |
| IMG_BOOL bInPowerTransition; /*!< Device power transition state */ |
| POS_LOCK hLock; /*!< Exclusive lock to this structure */ |
| } PDUMP_CTRL_STATE; |
| |
| static PDUMP_CTRL_STATE g_PDumpCtrl = |
| { |
| IMG_TRUE, |
| 0, |
| |
| 0, /*!< Value obtained from OS PDump layer during initialisation */ |
| { |
| FRAME_UNSET, |
| FRAME_UNSET, |
| 1 |
| }, |
| 0, |
| |
| IMG_FALSE, |
| IMG_FALSE, |
| IMG_FALSE, |
| NULL |
| }; |
| |
| static PVRSRV_ERROR PDumpCtrlInit(IMG_UINT32 ui32InitCapMode) |
| { |
| g_PDumpCtrl.ui32DefaultCapMode = ui32InitCapMode; |
| PVR_ASSERT(g_PDumpCtrl.ui32DefaultCapMode != 0); |
| |
| /* Create lock for PDUMP_CTRL_STATE struct, which is shared between pdump client |
| and PDumping app. This lock will help us serialize calls from pdump client |
| and PDumping app */ |
| PVR_LOGR_IF_ERROR(OSLockCreate(&g_PDumpCtrl.hLock, LOCK_TYPE_PASSIVE), "OSLockCreate"); |
| |
| return PVRSRV_OK; |
| } |
| |
| static void PDumpCtrlDeInit(void) |
| { |
| if (g_PDumpCtrl.hLock) |
| { |
| OSLockDestroy(g_PDumpCtrl.hLock); |
| g_PDumpCtrl.hLock = NULL; |
| } |
| } |
| |
| static INLINE void PDumpCtrlLockAcquire(void) |
| { |
| OSLockAcquire(g_PDumpCtrl.hLock); |
| } |
| |
| static INLINE void PDumpCtrlLockRelease(void) |
| { |
| OSLockRelease(g_PDumpCtrl.hLock); |
| } |
| |
| /********************************************************************************************************** |
| NOTE: |
| The following PDumpCtrl*** functions require the PDUMP_CTRL_STATE lock be acquired BEFORE they are |
| called. This is because the PDUMP_CTRL_STATE data is shared between the PDumping App and the PDump |
| client, hence an exclusive access is required. The lock can be acquired and released by using the |
| PDumpCtrlLockAcquire & PDumpCtrlLockRelease functions respectively. |
| **********************************************************************************************************/ |
| |
| static void PDumpCtrlUpdateCaptureStatus(void) |
| { |
| if (g_PDumpCtrl.ui32DefaultCapMode == DEBUG_CAPMODE_FRAMED) |
| { |
| if ((g_PDumpCtrl.ui32CurrentFrame >= g_PDumpCtrl.sCaptureRange.ui32Start) && |
| (g_PDumpCtrl.ui32CurrentFrame <= g_PDumpCtrl.sCaptureRange.ui32End) && |
| (((g_PDumpCtrl.ui32CurrentFrame - g_PDumpCtrl.sCaptureRange.ui32Start) % g_PDumpCtrl.sCaptureRange.ui32Interval) == 0)) |
| { |
| g_PDumpCtrl.bCaptureOn = IMG_TRUE; |
| } |
| else |
| { |
| g_PDumpCtrl.bCaptureOn = IMG_FALSE; |
| } |
| } |
| else if (g_PDumpCtrl.ui32DefaultCapMode == DEBUG_CAPMODE_CONTINUOUS) |
| { |
| g_PDumpCtrl.bCaptureOn = IMG_TRUE; |
| } |
| else |
| { |
| g_PDumpCtrl.bCaptureOn = IMG_FALSE; |
| PVR_DPF((PVR_DBG_ERROR, "PDumpCtrlSetCurrentFrame: Unexpected capture mode (%x)", g_PDumpCtrl.ui32DefaultCapMode)); |
| } |
| |
| } |
| |
| static void PDumpCtrlSetCurrentFrame(IMG_UINT32 ui32Frame) |
| { |
| g_PDumpCtrl.ui32CurrentFrame = ui32Frame; |
| /* Mirror the value into the debug driver */ |
| PDumpOSSetFrame(ui32Frame); |
| |
| PDumpCtrlUpdateCaptureStatus(); |
| |
| #if defined(PDUMP_TRACE_STATE) |
| PDumpCommonDumpState(IMG_FALSE); |
| #endif |
| } |
| |
| static void PDumpCtrlSetDefaultCaptureParams(IMG_UINT32 ui32Mode, IMG_UINT32 ui32Start, IMG_UINT32 ui32End, IMG_UINT32 ui32Interval) |
| { |
| PVR_ASSERT(ui32Interval > 0); |
| PVR_ASSERT(ui32End >= ui32Start); |
| PVR_ASSERT((ui32Mode == DEBUG_CAPMODE_FRAMED) || (ui32Mode == DEBUG_CAPMODE_CONTINUOUS)); |
| |
| /* Set the capture range to that supplied by the PDump client tool |
| */ |
| g_PDumpCtrl.ui32DefaultCapMode = ui32Mode; |
| g_PDumpCtrl.sCaptureRange.ui32Start = ui32Start; |
| g_PDumpCtrl.sCaptureRange.ui32End = ui32End; |
| g_PDumpCtrl.sCaptureRange.ui32Interval = ui32Interval; |
| |
| /* Reset the current frame on reset of the capture range, the helps to |
| * avoid inter-pdump start frame issues when the driver is not reloaded. |
| * No need to call PDumpCtrlUpdateCaptureStatus() direct as the set |
| * current frame call will. |
| */ |
| PDumpCtrlSetCurrentFrame(0); |
| } |
| |
| static INLINE IMG_BOOL PDumpCtrlCapModIsFramed(void) |
| { |
| return g_PDumpCtrl.ui32DefaultCapMode == DEBUG_CAPMODE_FRAMED; |
| } |
| |
| static INLINE IMG_BOOL PDumpCtrlCapModIsContinuous(void) |
| { |
| return g_PDumpCtrl.ui32DefaultCapMode == DEBUG_CAPMODE_CONTINUOUS; |
| } |
| |
| static IMG_UINT32 PDumpCtrlGetCurrentFrame(void) |
| { |
| return g_PDumpCtrl.ui32CurrentFrame; |
| } |
| |
| static INLINE IMG_BOOL PDumpCtrlCaptureOn(void) |
| { |
| return !g_PDumpCtrl.bSuspended && g_PDumpCtrl.bCaptureOn; |
| } |
| |
| static INLINE IMG_BOOL PDumpCtrlCaptureRangePast(void) |
| { |
| return (g_PDumpCtrl.ui32CurrentFrame > g_PDumpCtrl.sCaptureRange.ui32End); |
| } |
| |
| /* Used to imply if the PDump client is connected or not. */ |
| static INLINE IMG_BOOL PDumpCtrlCaptureRangeUnset(void) |
| { |
| return ((g_PDumpCtrl.sCaptureRange.ui32Start == FRAME_UNSET) && |
| (g_PDumpCtrl.sCaptureRange.ui32End == FRAME_UNSET)); |
| } |
| |
| static IMG_BOOL PDumpCtrlIsLastCaptureFrame(void) |
| { |
| if (g_PDumpCtrl.ui32DefaultCapMode == DEBUG_CAPMODE_FRAMED) |
| { |
| /* Is the next capture frame within the range end limit? */ |
| if ((g_PDumpCtrl.ui32CurrentFrame + g_PDumpCtrl.sCaptureRange.ui32Interval) > g_PDumpCtrl.sCaptureRange.ui32End) |
| { |
| return IMG_TRUE; |
| } |
| } |
| else |
| { |
| PVR_DPF((PVR_DBG_ERROR, "PDumpCtrIsLastCaptureFrame: Unexpected capture mode (%x)", g_PDumpCtrl.ui32DefaultCapMode)); |
| } |
| |
| /* Return false for continuous capture mode or when in framed mode */ |
| return IMG_FALSE; |
| } |
| |
| static INLINE IMG_BOOL PDumpCtrlInitPhaseComplete(void) |
| { |
| return !g_PDumpCtrl.bInitPhaseActive; |
| } |
| |
| static INLINE void PDumpCtrlSetInitPhaseComplete(IMG_BOOL bIsComplete) |
| { |
| if (bIsComplete) |
| { |
| g_PDumpCtrl.bInitPhaseActive = IMG_FALSE; |
| PDUMP_HEREA(102); |
| } |
| else |
| { |
| g_PDumpCtrl.bInitPhaseActive = IMG_TRUE; |
| PDUMP_HEREA(103); |
| } |
| } |
| |
| static INLINE void PDumpCtrlSuspend(void) |
| { |
| PDUMP_HEREA(104); |
| g_PDumpCtrl.bSuspended = IMG_TRUE; |
| } |
| |
| static INLINE void PDumpCtrlResume(void) |
| { |
| PDUMP_HEREA(105); |
| g_PDumpCtrl.bSuspended = IMG_FALSE; |
| } |
| |
| static INLINE IMG_BOOL PDumpCtrlIsDumpSuspended(void) |
| { |
| return g_PDumpCtrl.bSuspended; |
| } |
| |
| static INLINE void PDumpCtrlPowerTransitionStart(void) |
| { |
| g_PDumpCtrl.bInPowerTransition = IMG_TRUE; |
| } |
| |
| static INLINE void PDumpCtrlPowerTransitionEnd(void) |
| { |
| g_PDumpCtrl.bInPowerTransition = IMG_FALSE; |
| } |
| |
| static INLINE IMG_BOOL PDumpCtrlInPowerTransition(void) |
| { |
| return g_PDumpCtrl.bInPowerTransition; |
| } |
| |
| static PVRSRV_ERROR PDumpCtrlIsCaptureFrame(IMG_BOOL *bIsCapturing) |
| { |
| *bIsCapturing = PDumpCtrlCaptureOn(); |
| return PVRSRV_OK; |
| } |
| |
| /******************************************************************************** |
| End of PDumpCtrl*** functions |
| *********************************************************************************/ |
| |
| /* |
| Wrapper functions which need to be exposed in pdump_km.h for use in other |
| pdump_*** modules safely. These functions call the specific PDumpCtrl layer |
| function after acquiring the PDUMP_CTRL_STATE lock, hence making the calls |
| from other modules hassle free by avoiding the acquire/release CtrlLock |
| calls. |
| */ |
| |
| void PDumpPowerTransitionStart(void) |
| { |
| PDumpCtrlLockAcquire(); |
| PDumpCtrlPowerTransitionStart(); |
| PDumpCtrlLockRelease(); |
| } |
| |
| void PDumpPowerTransitionEnd(void) |
| { |
| PDumpCtrlLockAcquire(); |
| PDumpCtrlPowerTransitionEnd(); |
| PDumpCtrlLockRelease(); |
| } |
| |
| IMG_BOOL PDumpInPowerTransition(void) |
| { |
| IMG_BOOL bPDumpInPowerTransition = IMG_FALSE; |
| |
| PDumpCtrlLockAcquire(); |
| bPDumpInPowerTransition = PDumpCtrlInPowerTransition(); |
| PDumpCtrlLockRelease(); |
| |
| return bPDumpInPowerTransition; |
| } |
| |
| IMG_BOOL PDumpIsDumpSuspended(void) |
| { |
| IMG_BOOL bPDumpIsDumpSuspended; |
| |
| PDumpCtrlLockAcquire(); |
| bPDumpIsDumpSuspended = PDumpCtrlIsDumpSuspended(); |
| PDumpCtrlLockRelease(); |
| |
| return bPDumpIsDumpSuspended; |
| } |
| |
| /*****************************************************************************/ |
| /* PDump Common Write Layer just above PDump OS Layer */ |
| /*****************************************************************************/ |
| |
| |
| /* |
| Checks in this method were seeded from the original PDumpWriteILock() |
| and DBGDrivWriteCM() and have grown since to ensure PDump output |
| matches legacy output. |
| Note: the order of the checks in this method is important as some |
| writes have multiple pdump flags set! |
| */ |
| static IMG_BOOL PDumpWriteAllowed(IMG_UINT32 ui32Flags) |
| { |
| /* Lock down the PDUMP_CTRL_STATE struct before calling the following |
| PDumpCtrl*** functions. This is to avoid updates to the Control data |
| while we are reading from it */ |
| PDumpCtrlLockAcquire(); |
| |
| /* No writes if in framed mode and range pasted */ |
| if (PDumpCtrlCaptureRangePast()) |
| { |
| PDUMP_HERE(10); |
| goto unlockAndReturnFalse; |
| } |
| |
| /* No writes while writing is suspended */ |
| if (PDumpCtrlIsDumpSuspended()) |
| { |
| PDUMP_HERE(11); |
| goto unlockAndReturnFalse; |
| } |
| |
| /* Prevent PDumping during a power transition */ |
| if (PDumpCtrlInPowerTransition()) |
| { /* except when it's flagged */ |
| if (ui32Flags & PDUMP_FLAGS_POWER) |
| { |
| PDUMP_HERE(20); |
| goto unlockAndReturnTrue; |
| } |
| PDUMP_HERE(16); |
| goto unlockAndReturnFalse; |
| } |
| |
| /* Always allow dumping in init phase and when persistent flagged */ |
| if (ui32Flags & PDUMP_FLAGS_PERSISTENT) |
| { |
| PDUMP_HERE(12); |
| goto unlockAndReturnTrue; |
| } |
| if (!PDumpCtrlInitPhaseComplete()) |
| { |
| PDUMP_HERE(15); |
| goto unlockAndReturnTrue; |
| } |
| |
| /* The following checks are made when the driver has completed initialisation */ |
| |
| /* If PDump client connected allow continuous flagged writes */ |
| if (PDUMP_IS_CONTINUOUS(ui32Flags)) |
| { |
| if (PDumpCtrlCaptureRangeUnset()) /* Is client connected? */ |
| { |
| PDUMP_HERE(13); |
| goto unlockAndReturnFalse; |
| } |
| PDUMP_HERE(14); |
| goto unlockAndReturnTrue; |
| } |
| |
| /* No last/deinit statements allowed when not in initialisation phase */ |
| if (PDUMP_IS_CONTINUOUS(ui32Flags)) |
| { |
| if (PDumpCtrlInitPhaseComplete()) |
| { |
| PDUMP_HERE(17); |
| PVR_DPF((PVR_DBG_ERROR, "PDumpWriteAllowed: DEINIT flag used at the wrong time outside of initialisation!")); |
| goto unlockAndReturnFalse; |
| } |
| } |
| |
| /* |
| If no flags are provided then it is FRAMED output and the frame |
| range must be checked matching expected behaviour. |
| */ |
| if (PDumpCtrlCapModIsFramed() && !PDumpCtrlCaptureOn()) |
| { |
| PDUMP_HERE(18); |
| goto unlockAndReturnFalse; |
| } |
| |
| PDUMP_HERE(19); |
| |
| unlockAndReturnTrue: |
| /* Allow the write to take place */ |
| PDumpCtrlLockRelease(); |
| return IMG_TRUE; |
| |
| unlockAndReturnFalse: |
| PDumpCtrlLockRelease(); |
| return IMG_FALSE; |
| } |
| |
| #undef PDUMP_DEBUG_SCRIPT_LINES |
| |
| #if defined(PDUMP_DEBUG_SCRIPT_LINES) |
| #define PDUMPOSDEBUGDRIVERWRITE(a,b,c,d) _PDumpOSDebugDriverWrite(a,b,c,d) |
| static IMG_UINT32 _PDumpOSDebugDriverWrite( IMG_HANDLE psStream, |
| IMG_UINT8 *pui8Data, |
| IMG_UINT32 ui32BCount, |
| IMG_UINT32 ui32Flags) |
| { |
| IMG_CHAR tmp1[80]; |
| IMG_CHAR* streamName = "unkn"; |
| |
| if (g_PDumpScript.sCh.hDeinit == psStream) |
| streamName = "dein"; |
| else if (g_PDumpScript.sCh.hInit == psStream) |
| streamName = "init"; |
| else if (g_PDumpScript.sCh.hMain == psStream) |
| streamName = "main"; |
| |
| (void) PDumpOSSprintf(tmp1, 80, "-- %s, %x\n", streamName, ui32Flags); |
| (void) PDumpOSDebugDriverWrite(psStream, tmp1, OSStringLength(tmp1)); |
| |
| return PDumpOSDebugDriverWrite(psStream, pui8Data, ui32BCount); |
| } |
| #else |
| #define PDUMPOSDEBUGDRIVERWRITE(a,b,c,d) PDumpOSDebugDriverWrite(a,b,c) |
| #endif |
| |
| |
| /**************************************************************************/ /*! |
| @Function PDumpWriteToBuffer |
| @Description Write the supplied data to the PDump stream buffer and attempt |
| to handle any buffer full conditions to ensure all the data |
| requested to be written, is. |
| |
| @Input psStream The address of the PDump stream buffer to write to |
| @Input pui8Data Pointer to the data to be written |
| @Input ui32BCount Number of bytes to write |
| @Input ui32Flags PDump statement flags. |
| |
| @Return IMG_UINT32 Actual number of bytes written, may be less than |
| ui32BCount when buffer full condition could not |
| be avoided. |
| */ /***************************************************************************/ |
| static IMG_UINT32 PDumpWriteToBuffer(IMG_HANDLE psStream, IMG_UINT8 *pui8Data, |
| IMG_UINT32 ui32BCount, IMG_UINT32 ui32Flags) |
| { |
| IMG_UINT32 ui32BytesWritten = 0; |
| IMG_UINT32 ui32Off = 0; |
| |
| while (ui32BCount > 0) |
| { |
| ui32BytesWritten = PDUMPOSDEBUGDRIVERWRITE(psStream, &pui8Data[ui32Off], ui32BCount, ui32Flags); |
| |
| if (ui32BytesWritten == 0) |
| { |
| PVR_DPF((PVR_DBG_MESSAGE, "PDumpWriteToBuffer: Zero bytes written - release execution")); |
| PDumpOSReleaseExecution(); |
| } |
| |
| if (ui32BytesWritten != 0xFFFFFFFFU) |
| { |
| if (ui32BCount != ui32BytesWritten) |
| { |
| PVR_DPF((PVR_DBG_MESSAGE, "PDumpWriteToBuffer: partial write of %d bytes of %d bytes", ui32BytesWritten, ui32BCount)); |
| } |
| ui32Off += ui32BytesWritten; |
| ui32BCount -= ui32BytesWritten; |
| } |
| else |
| { |
| PVR_DPF((PVR_DBG_ERROR, "PDumpWriteToBuffer: Unrecoverable error received from the debug driver")); |
| if( PDumpOSGetCtrlState(psStream, DBG_GET_STATE_FLAG_IS_READONLY) ) |
| { |
| /* Fatal -suspend PDump to prevent flooding kernel log buffer */ |
| PVR_LOG(("PDump suspended, debug driver out of memory")); |
| /* |
| Acquire the control lock before updating "suspended" state. This may not be required |
| because "this" is the context which checks the "suspended" state in PDumpWriteAllowed |
| before calling this function. So, this update is mainly for other contexts. |
| Also, all the other contexts which will/wish-to read the "suspended" state ought to be |
| waiting on the bridge lock first and then the PDUMP_OSLOCK (to pdump into script or |
| parameter buffer). However, this acquire may be useful incase the PDump call is being |
| made from a direct bridge |
| */ |
| PDumpCtrlLockAcquire(); |
| PDumpCtrlSuspend(); |
| PDumpCtrlLockRelease(); |
| } |
| return 0; |
| } |
| } |
| |
| /* reset buffer counters */ |
| ui32BCount = ui32Off; ui32Off = 0; ui32BytesWritten = 0; |
| |
| return ui32BCount; |
| } |
| |
| |
| /**************************************************************************/ /*! |
| @Function PDumpWriteToChannel |
| @Description Write the supplied data to the PDump channel specified obeying |
| flags to write to the necessary channel buffers. |
| |
| @Input psChannel The address of the script or parameter channel object |
| @Input/Output psWOff The address of the channel write offsets object to |
| update on successful writing |
| @Input pui8Data Pointer to the data to be written |
| @Input ui32Size Number of bytes to write |
| @Input ui32Flags PDump statement flags, they may be clear (no flags) |
| which implies framed data, continuous flagged, |
| persistent flagged, or continuous AND persistent |
| flagged and they determine how the data is output. |
| On the first test app run after driver load, the |
| Display Controller dumps a resource that is both |
| continuous and persistent and this needs writing to |
| both the init (persistent) and main (continuous) |
| channel buffers to ensure the data is dumped in |
| subsequent test runs without reloading the driver. |
| In subsequent runs the PDump client 'freezes' the |
| init buffer so that only one dump of persistent data |
| for the "extended init phase" is captured to the |
| init buffer. |
| |
| @Return IMG_BOOL True when the data has been consumed, false otherwise |
| */ /***************************************************************************/ |
| static IMG_BOOL PDumpWriteToChannel(PDUMP_CHANNEL* psChannel, PDUMP_CHANNEL_WOFFSETS* psWOff, |
| IMG_UINT8* pui8Data, IMG_UINT32 ui32Size, IMG_UINT32 ui32Flags) |
| { |
| IMG_UINT32 ui32BytesWritten = 0; |
| |
| PDUMP_HERE(210); |
| |
| /* Dump data to deinit buffer when flagged as deinit */ |
| if (ui32Flags & PDUMP_FLAGS_DEINIT) |
| { |
| PDUMP_HERE(211); |
| ui32BytesWritten = PDumpWriteToBuffer(psChannel->hDeinit, pui8Data, ui32Size, ui32Flags); |
| if (ui32BytesWritten != ui32Size) |
| { |
| PVR_DPF((PVR_DBG_ERROR, "PDumpWriteToChannel: DEINIT Written length (%d) does not match data length (%d), PDump incomplete!", ui32BytesWritten, ui32Size)); |
| PDUMP_HERE(212); |
| return IMG_FALSE; |
| } |
| |
| if (psWOff) |
| { |
| psWOff->ui32Deinit += ui32Size; |
| } |
| |
| } |
| else |
| { |
| IMG_BOOL bDumpedToInitAlready = IMG_FALSE; |
| IMG_HANDLE* phStream = NULL; |
| IMG_UINT32* pui32Offset = NULL; |
| |
| /* Always append persistent data to init phase so it's available on |
| * subsequent app runs, but also to the main stream if client connected */ |
| if (ui32Flags & PDUMP_FLAGS_PERSISTENT) |
| { |
| PDUMP_HERE(213); |
| ui32BytesWritten = PDumpWriteToBuffer( psChannel->hInit, pui8Data, ui32Size, ui32Flags); |
| if (ui32BytesWritten != ui32Size) |
| { |
| PVR_DPF((PVR_DBG_ERROR, "PDumpWriteToChannel: PERSIST Written length (%d) does not match data length (%d), PDump incomplete!", ui32BytesWritten, ui32Size)); |
| PDUMP_HERE(214); |
| return IMG_FALSE; |
| } |
| |
| bDumpedToInitAlready = IMG_TRUE; |
| if (psWOff) |
| { |
| psWOff->ui32Init += ui32Size; |
| } |
| |
| /* Don't write continuous data if client not connected */ |
| PDumpCtrlLockAcquire(); |
| if (PDUMP_IS_CONTINUOUS(ui32Flags) && PDumpCtrlCaptureRangeUnset()) |
| { |
| PDumpCtrlLockRelease(); |
| return IMG_TRUE; |
| } |
| PDumpCtrlLockRelease(); |
| } |
| |
| /* Prepare to write the data to the main stream for |
| * persistent, continuous or framed data. Override and use init |
| * stream if driver still in init phase and we have not written |
| * to it yet.*/ |
| PDumpCtrlLockAcquire(); |
| if (!PDumpCtrlInitPhaseComplete() && !bDumpedToInitAlready) |
| { |
| PDUMP_HERE(215); |
| phStream = &psChannel->hInit; |
| if (psWOff) |
| { |
| pui32Offset = &psWOff->ui32Init; |
| } |
| } |
| else |
| { |
| PDUMP_HERE(216); |
| phStream = &psChannel->hMain; |
| if (psWOff) |
| { |
| pui32Offset = &psWOff->ui32Main; |
| } |
| } |
| PDumpCtrlLockRelease(); |
| |
| /* Write the data to the stream */ |
| ui32BytesWritten = PDumpWriteToBuffer(*phStream, pui8Data, ui32Size, ui32Flags); |
| if (ui32BytesWritten != ui32Size) |
| { |
| PVR_DPF((PVR_DBG_ERROR, "PDumpWriteToChannel: MAIN Written length (%d) does not match data length (%d), PDump incomplete!", ui32BytesWritten, ui32Size)); |
| PDUMP_HERE(217); |
| return IMG_FALSE; |
| } |
| |
| if (pui32Offset) |
| { |
| *pui32Offset += ui32BytesWritten; |
| } |
| } |
| |
| return IMG_TRUE; |
| } |
| |
| #if defined(PDUMP_DEBUG_OUTFILES) |
| |
| static IMG_UINT32 _GenerateChecksum(void *pvData, size_t uiSize) |
| { |
| IMG_UINT32 ui32Sum = 0; |
| IMG_UINT32 *pui32Data = pvData; |
| IMG_UINT8 *pui8Data = pvData; |
| IMG_UINT32 i; |
| IMG_UINT32 ui32LeftOver; |
| |
| for(i = 0; i < uiSize / sizeof(IMG_UINT32); i++) |
| { |
| ui32Sum += pui32Data[i]; |
| } |
| |
| ui32LeftOver = uiSize % sizeof(IMG_UINT32); |
| |
| while(ui32LeftOver) |
| { |
| ui32Sum += pui8Data[uiSize - ui32LeftOver]; |
| ui32LeftOver--; |
| } |
| |
| return ui32Sum; |
| } |
| |
| #endif |
| |
| PVRSRV_ERROR PDumpWriteParameter(IMG_UINT8 *pui8Data, IMG_UINT32 ui32Size, IMG_UINT32 ui32Flags, |
| IMG_UINT32* pui32FileOffset, IMG_CHAR* aszFilenameStr) |
| { |
| PVRSRV_ERROR eError = PVRSRV_OK; |
| IMG_BOOL bPDumpCtrlInitPhaseComplete = IMG_FALSE; |
| |
| PVR_ASSERT(pui8Data && (ui32Size!=0)); |
| PVR_ASSERT(pui32FileOffset && aszFilenameStr); |
| |
| PDUMP_HERE(1); |
| |
| if (!PDumpWriteAllowed(ui32Flags)) |
| { |
| /* Abort write for the above reason but indicate what happened to |
| * caller to avoid disrupting the driver, caller should treat it as OK |
| * but skip any related PDump writes to the script file. */ |
| return PVRSRV_ERROR_PDUMP_NOT_ALLOWED; |
| } |
| |
| PDUMP_HERE(2); |
| |
| PDumpCtrlLockAcquire(); |
| bPDumpCtrlInitPhaseComplete = PDumpCtrlInitPhaseComplete(); |
| PDumpCtrlLockRelease(); |
| |
| if (!bPDumpCtrlInitPhaseComplete || (ui32Flags & PDUMP_FLAGS_PERSISTENT)) |
| { |
| PDUMP_HERE(3); |
| |
| /* Init phase stream not expected to get above the file size max */ |
| PVR_ASSERT(g_PDumpParameters.sWOff.ui32Init < g_PDumpParameters.ui32MaxFileSize); |
| |
| /* Return the file write offset at which the parameter data was dumped */ |
| *pui32FileOffset = g_PDumpParameters.sWOff.ui32Init; |
| } |
| else |
| { |
| PDUMP_HERE(4); |
| |
| /* Do we need to signal the PDump client that a split is required? */ |
| if (g_PDumpParameters.sWOff.ui32Main + ui32Size > g_PDumpParameters.ui32MaxFileSize) |
| { |
| PDUMP_HERE(5); |
| PDumpOSSetSplitMarker(g_PDumpParameters.sCh.hMain, g_PDumpParameters.sWOff.ui32Main); |
| g_PDumpParameters.ui32FileIdx++; |
| g_PDumpParameters.sWOff.ui32Main = 0; |
| } |
| |
| /* Return the file write offset at which the parameter data was dumped */ |
| *pui32FileOffset = g_PDumpParameters.sWOff.ui32Main; |
| } |
| |
| /* Create the parameter file name, based on index, to be used in the script */ |
| if (g_PDumpParameters.ui32FileIdx == 0) |
| { |
| eError = PDumpOSSprintf(aszFilenameStr, PDUMP_PARAM_MAX_FILE_NAME, PDUMP_PARAM_0_FILE_NAME); |
| } |
| else |
| { |
| PDUMP_HERE(6); |
| eError = PDumpOSSprintf(aszFilenameStr, PDUMP_PARAM_MAX_FILE_NAME, PDUMP_PARAM_N_FILE_NAME, g_PDumpParameters.ui32FileIdx); |
| } |
| PVR_LOGG_IF_ERROR(eError, "PDumpOSSprintf", errExit); |
| |
| /* Write the parameter data to the parameter channel */ |
| eError = PVRSRV_ERROR_PDUMP_BUFFER_FULL; |
| if (!PDumpWriteToChannel(&g_PDumpParameters.sCh, &g_PDumpParameters.sWOff, pui8Data, ui32Size, ui32Flags)) |
| { |
| PDUMP_HERE(7); |
| PVR_LOGG_IF_ERROR(eError, "PDumpWrite", errExit); |
| } |
| #if defined(PDUMP_DEBUG_OUTFILES) |
| else |
| { |
| IMG_UINT32 ui32Checksum; |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| ui32Checksum = _GenerateChecksum(pui8Data, ui32Size); |
| |
| /* CHK CHKSUM SIZE PRMOFFSET PRMFILE */ |
| eError = PDumpOSBufprintf(hScript, ui32MaxLen, "-- CHK 0x%08X 0x%08X 0x%08X %s", |
| ui32Checksum, |
| ui32Size, |
| *pui32FileOffset, |
| aszFilenameStr); |
| if(eError != PVRSRV_OK) |
| { |
| goto errExit; |
| } |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| } |
| #endif |
| |
| return PVRSRV_OK; |
| |
| errExit: |
| return eError; |
| } |
| |
| |
| IMG_BOOL PDumpWriteScript(IMG_HANDLE hString, IMG_UINT32 ui32Flags) |
| { |
| PVR_ASSERT(hString); |
| |
| PDUMP_HERE(201); |
| |
| if (!PDumpWriteAllowed(ui32Flags)) |
| { |
| /* Abort write for the above reasons but indicated it was OK to |
| * caller to avoid disrupting the driver */ |
| return IMG_TRUE; |
| } |
| |
| return PDumpWriteToChannel(&g_PDumpScript.sCh, NULL, (IMG_UINT8*) hString, (IMG_UINT32) OSStringLength((IMG_CHAR*) hString), ui32Flags); |
| } |
| |
| |
| /*****************************************************************************/ |
| |
| |
| |
| |
| |
| |
| struct _PDUMP_CONNECTION_DATA_ { |
| IMG_UINT32 ui32RefCount; |
| POS_LOCK hLock; |
| DLLIST_NODE sListHead; |
| IMG_BOOL bLastInto; |
| IMG_UINT32 ui32LastSetFrameNumber; |
| IMG_BOOL bWasInCaptureRange; |
| IMG_BOOL bIsInCaptureRange; |
| IMG_BOOL bLastTransitionFailed; |
| SYNC_CONNECTION_DATA *psSyncConnectionData; |
| }; |
| |
| static PDUMP_CONNECTION_DATA * _PDumpConnectionAcquire(PDUMP_CONNECTION_DATA *psPDumpConnectionData) |
| { |
| IMG_UINT32 ui32RefCount; |
| |
| OSLockAcquire(psPDumpConnectionData->hLock); |
| ui32RefCount = ++psPDumpConnectionData->ui32RefCount; |
| OSLockRelease(psPDumpConnectionData->hLock); |
| |
| PDUMP_REFCOUNT_PRINT("%s: PDump connection %p, refcount = %d", |
| __FUNCTION__, psPDumpConnectionData, ui32RefCount); |
| |
| return psPDumpConnectionData; |
| } |
| |
| static void _PDumpConnectionRelease(PDUMP_CONNECTION_DATA *psPDumpConnectionData) |
| { |
| IMG_UINT32 ui32RefCount; |
| |
| OSLockAcquire(psPDumpConnectionData->hLock); |
| ui32RefCount = --psPDumpConnectionData->ui32RefCount; |
| OSLockRelease(psPDumpConnectionData->hLock); |
| |
| if (ui32RefCount == 0) |
| { |
| OSLockDestroy(psPDumpConnectionData->hLock); |
| PVR_ASSERT(dllist_is_empty(&psPDumpConnectionData->sListHead)); |
| OSFreeMem(psPDumpConnectionData); |
| } |
| |
| PDUMP_REFCOUNT_PRINT("%s: PDump connection %p, refcount = %d", |
| __FUNCTION__, psPDumpConnectionData, ui32RefCount); |
| } |
| |
| /************************************************************************** |
| * Function Name : GetTempBuffer |
| * Inputs : None |
| * Outputs : None |
| * Returns : Temporary buffer address, or NULL |
| * Description : Get temporary buffer address. |
| **************************************************************************/ |
| static void *GetTempBuffer(void) |
| { |
| /* |
| * Allocate the temporary buffer, if it hasn't been allocated already. |
| * Return the address of the temporary buffer, or NULL if it |
| * couldn't be allocated. |
| * It is expected that the buffer will be allocated once, at driver |
| * load time, and left in place until the driver unloads. |
| */ |
| |
| if (gpvTempBuffer == NULL) |
| { |
| gpvTempBuffer = OSAllocMem(PDUMP_TEMP_BUFFER_SIZE); |
| if (gpvTempBuffer == NULL) |
| { |
| PVR_DPF((PVR_DBG_ERROR, "GetTempBuffer: OSAllocMem failed")); |
| } |
| } |
| |
| return gpvTempBuffer; |
| } |
| |
| static void FreeTempBuffer(void) |
| { |
| |
| if (gpvTempBuffer != NULL) |
| { |
| OSFreeMem(gpvTempBuffer); |
| gpvTempBuffer = NULL; |
| } |
| } |
| |
| /************************************************************************** |
| * Function Name : PDumpParameterChannelZeroedPageBlock |
| * Inputs : None |
| * Outputs : None |
| * Returns : PVRSRV_ERROR |
| * Description : Set up the zero page block in the parameter stream |
| **************************************************************************/ |
| static PVRSRV_ERROR PDumpParameterChannelZeroedPageBlock(void) |
| { |
| IMG_UINT8 aui8Zero[32] = { 0 }; |
| size_t uiBytesToWrite; |
| PVRSRV_ERROR eError; |
| |
| g_PDumpParameters.uiZeroPageSize = OSGetPageSize(); |
| |
| /* ensure the zero page size of a multiple of the zero source on the stack */ |
| PVR_ASSERT(g_PDumpParameters.uiZeroPageSize % sizeof(aui8Zero) == 0); |
| |
| /* the first write gets the parameter file name and stream offset, |
| * then subsequent writes do not need to know this as the data is |
| * contiguous in the stream |
| */ |
| PDUMP_LOCK(); |
| eError = PDumpWriteParameter(aui8Zero, |
| sizeof(aui8Zero), |
| 0, |
| &g_PDumpParameters.uiZeroPageOffset, |
| g_PDumpParameters.szZeroPageFilename); |
| |
| if(eError != PVRSRV_OK) |
| { |
| /* Also treat PVRSRV_ERROR_PDUMP_NOT_ALLOWED as an error in this case |
| * as it should never happen since all writes during driver Init are allowed. |
| */ |
| goto err_write; |
| } |
| |
| uiBytesToWrite = g_PDumpParameters.uiZeroPageSize - sizeof(aui8Zero); |
| |
| while(uiBytesToWrite) |
| { |
| IMG_BOOL bOK; |
| |
| bOK = PDumpWriteToChannel(&g_PDumpParameters.sCh, &g_PDumpParameters.sWOff, |
| aui8Zero, |
| sizeof(aui8Zero), 0); |
| |
| if(!bOK) |
| { |
| eError = PVRSRV_ERROR_PDUMP_BUFFER_FULL; |
| goto err_write; |
| } |
| |
| uiBytesToWrite -= sizeof(aui8Zero); |
| } |
| |
| err_write: |
| PDUMP_UNLOCK(); |
| |
| if(eError != PVRSRV_OK) |
| { |
| PVR_DPF((PVR_DBG_ERROR, "Failed to initialise parameter stream zero block")); |
| } |
| |
| return eError; |
| } |
| |
| /************************************************************************** |
| * Function Name : PDumpGetParameterZeroPageInfo |
| * Inputs : None |
| * Outputs : puiZeroPageOffset: will be set to the offset of the zero page |
| * : puiZeroPageSize: will be set to the size of the zero page |
| * : ppszZeroPageFilename: will be set to a pointer to the PRM file name |
| * : containing the zero page |
| * Returns : None |
| * Description : Get information about the zero page |
| **************************************************************************/ |
| void PDumpGetParameterZeroPageInfo(PDUMP_FILEOFFSET_T *puiZeroPageOffset, |
| size_t *puiZeroPageSize, |
| const IMG_CHAR **ppszZeroPageFilename) |
| { |
| *puiZeroPageOffset = g_PDumpParameters.uiZeroPageOffset; |
| *puiZeroPageSize = g_PDumpParameters.uiZeroPageSize; |
| *ppszZeroPageFilename = g_PDumpParameters.szZeroPageFilename; |
| } |
| |
| PVRSRV_ERROR PDumpInitCommon(void) |
| { |
| PVRSRV_ERROR eError; |
| IMG_UINT32 ui32InitCapMode = 0; |
| IMG_CHAR* pszEnvComment = NULL; |
| |
| PDUMP_HEREA(2010); |
| |
| /* Allocate temporary buffer for copying from user space */ |
| (void) GetTempBuffer(); |
| |
| /* create the global PDump lock */ |
| eError = PDumpCreateLockKM(); |
| PVR_LOGG_IF_ERROR(eError, "PDumpCreateLockKM", errExit); |
| |
| /* Call environment specific PDump initialisation */ |
| eError = PDumpOSInit(&g_PDumpParameters.sCh, &g_PDumpScript.sCh, &ui32InitCapMode, &pszEnvComment); |
| PVR_LOGG_IF_ERROR(eError, "PDumpOSInit", errExitLock); |
| |
| /* Initialise PDump control module in common layer */ |
| eError = PDumpCtrlInit(ui32InitCapMode); |
| PVR_LOGG_IF_ERROR(eError, "PDumpCtrlInit", errExitOSDeInit); |
| |
| /* Test PDump initialised and ready by logging driver details */ |
| eError = PDumpCommentWithFlags(PDUMP_FLAGS_CONTINUOUS, "Driver Product Version: %s - %s (%s)", PVRVERSION_STRING, PVR_BUILD_DIR, PVR_BUILD_TYPE); |
| PVR_LOGG_IF_ERROR(eError, "PDumpCommentWithFlags", errExitCtrl); |
| if (pszEnvComment != NULL) |
| { |
| eError = PDumpCommentWithFlags(PDUMP_FLAGS_CONTINUOUS, "%s", pszEnvComment); |
| PVR_LOGG_IF_ERROR(eError, "PDumpCommentWithFlags", errExitCtrl); |
| } |
| eError = PDumpCommentWithFlags(PDUMP_FLAGS_CONTINUOUS, "Start of Init Phase"); |
| PVR_LOGG_IF_ERROR(eError, "PDumpCommentWithFlags", errExitCtrl); |
| |
| eError = PDumpParameterChannelZeroedPageBlock(); |
| PVR_LOGG_IF_ERROR(eError, "PDumpParameterChannelZeroedPageBlock", errExitCtrl); |
| |
| g_PDumpInitialised = IMG_TRUE; |
| |
| PDUMP_HEREA(2011); |
| |
| return PVRSRV_OK; |
| |
| errExitCtrl: |
| PDumpCtrlDeInit(); |
| errExitOSDeInit: |
| PDUMP_HEREA(2018); |
| PDumpOSDeInit(&g_PDumpParameters.sCh, &g_PDumpScript.sCh); |
| errExitLock: |
| PDUMP_HEREA(2019); |
| PDumpDestroyLockKM(); |
| errExit: |
| return eError; |
| } |
| |
| void PDumpDeInitCommon(void) |
| { |
| PDUMP_HEREA(2020); |
| |
| g_PDumpInitialised = IMG_FALSE; |
| |
| /* Free temporary buffer */ |
| FreeTempBuffer(); |
| |
| /* DeInit the PDUMP_CTRL_STATE data */ |
| PDumpCtrlDeInit(); |
| |
| /* Call environment specific PDump Deinitialisation */ |
| PDumpOSDeInit(&g_PDumpParameters.sCh, &g_PDumpScript.sCh); |
| |
| /* take down the global PDump lock */ |
| PDumpDestroyLockKM(); |
| } |
| |
| IMG_BOOL PDumpReady(void) |
| { |
| return g_PDumpInitialised; |
| } |
| |
| void PDumpStopInitPhase(IMG_BOOL bPDumpClient, IMG_BOOL bInitClient) |
| { |
| /* Check with the OS we a running on */ |
| if (PDumpOSAllowInitPhaseToComplete(bPDumpClient, bInitClient)) |
| { |
| if (bInitClient) |
| { |
| /* We only ouptut this once for bInitClient init phase ending OSs */ |
| PDUMPCOMMENT("Stop Init Phase"); |
| } |
| PDumpCtrlLockAcquire(); |
| PDumpCtrlSetInitPhaseComplete(IMG_TRUE); |
| PDumpCtrlLockRelease(); |
| } |
| } |
| |
| PVRSRV_ERROR PDumpIsLastCaptureFrameKM(IMG_BOOL *pbIsLastCaptureFrame) |
| { |
| PDumpCtrlLockAcquire(); |
| *pbIsLastCaptureFrame = PDumpCtrlIsLastCaptureFrame(); |
| PDumpCtrlLockRelease(); |
| |
| return PVRSRV_OK; |
| } |
| |
| |
| |
| typedef struct _PDUMP_Transition_DATA_ { |
| PFN_PDUMP_TRANSITION pfnCallback; |
| void *hPrivData; |
| PDUMP_CONNECTION_DATA *psPDumpConnectionData; |
| DLLIST_NODE sNode; |
| } PDUMP_Transition_DATA; |
| |
| PVRSRV_ERROR PDumpRegisterTransitionCallback(PDUMP_CONNECTION_DATA *psPDumpConnectionData, |
| PFN_PDUMP_TRANSITION pfnCallback, |
| void *hPrivData, |
| void **ppvHandle) |
| { |
| PDUMP_Transition_DATA *psData; |
| PVRSRV_ERROR eError; |
| |
| psData = OSAllocMem(sizeof(*psData)); |
| if (psData == NULL) |
| { |
| eError = PVRSRV_ERROR_OUT_OF_MEMORY; |
| goto fail_alloc; |
| } |
| |
| /* Setup the callback and add it to the list for this process */ |
| psData->pfnCallback = pfnCallback; |
| psData->hPrivData = hPrivData; |
| dllist_add_to_head(&psPDumpConnectionData->sListHead, &psData->sNode); |
| |
| /* Take a reference on the connection so it doesn't get freed too early */ |
| psData->psPDumpConnectionData =_PDumpConnectionAcquire(psPDumpConnectionData); |
| *ppvHandle = psData; |
| |
| return PVRSRV_OK; |
| |
| fail_alloc: |
| PVR_ASSERT(eError != PVRSRV_OK); |
| return eError; |
| } |
| |
| void PDumpUnregisterTransitionCallback(void *pvHandle) |
| { |
| PDUMP_Transition_DATA *psData = pvHandle; |
| |
| dllist_remove_node(&psData->sNode); |
| _PDumpConnectionRelease(psData->psPDumpConnectionData); |
| OSFreeMem(psData); |
| } |
| |
| PVRSRV_ERROR PDumpTransition(PDUMP_CONNECTION_DATA *psPDumpConnectionData, IMG_BOOL bInto, IMG_UINT32 ui32PDumpFlags) |
| { |
| DLLIST_NODE *psNode, *psNext; |
| PVRSRV_ERROR eError; |
| |
| /* Only call the callbacks if we've really done a Transition */ |
| if (bInto != psPDumpConnectionData->bLastInto) |
| { |
| /* We're Transitioning either into or out of capture range */ |
| dllist_foreach_node(&psPDumpConnectionData->sListHead, psNode, psNext) |
| { |
| PDUMP_Transition_DATA *psData = |
| IMG_CONTAINER_OF(psNode, PDUMP_Transition_DATA, sNode); |
| |
| eError = psData->pfnCallback(psData->hPrivData, bInto, ui32PDumpFlags); |
| |
| if (eError != PVRSRV_OK) |
| { |
| return eError; |
| } |
| } |
| |
| if (bInto) |
| { |
| SyncConnectionPDumpSyncBlocks(psPDumpConnectionData->psSyncConnectionData); |
| } |
| psPDumpConnectionData->bLastInto = bInto; |
| } |
| return PVRSRV_OK; |
| } |
| |
| PVRSRV_ERROR PDumpIsCaptureFrameKM(IMG_BOOL *bIsCapturing) |
| { |
| PDumpCtrlLockAcquire(); |
| PDumpCtrlIsCaptureFrame(bIsCapturing); |
| PDumpCtrlLockRelease(); |
| |
| return PVRSRV_OK; |
| } |
| |
| static PVRSRV_ERROR _PDumpSetFrameKM(CONNECTION_DATA *psConnection, |
| IMG_UINT32 ui32Frame) |
| { |
| PDUMP_CONNECTION_DATA *psPDumpConnectionData = psConnection->psPDumpConnectionData; |
| IMG_BOOL bWasInCaptureRange = IMG_FALSE; |
| IMG_BOOL bIsInCaptureRange = IMG_FALSE; |
| PVRSRV_ERROR eError; |
| |
| /* |
| Note: |
| As we can't test to see if the new frame will be in capture range |
| before we set the frame number and we don't want to roll back the |
| frame number if we fail then we have to save the "transient" data |
| which decides if we're entering or exiting capture range along |
| with a failure boolean so we know what's required on a retry |
| */ |
| if (psPDumpConnectionData->ui32LastSetFrameNumber != ui32Frame) |
| { |
| (void) PDumpCommentWithFlags(PDUMP_FLAGS_CONTINUOUS, "Set pdump frame %u", ui32Frame); |
| |
| /* |
| The boolean values below decide if the PDump transition |
| should trigger because of the current context setting the |
| frame number, hence the functions below should execute |
| atomically and do not give a chance to some other context |
| to transition |
| */ |
| PDumpCtrlLockAcquire(); |
| |
| PDumpCtrlIsCaptureFrame(&bWasInCaptureRange); |
| PDumpCtrlSetCurrentFrame(ui32Frame); |
| PDumpCtrlIsCaptureFrame(&bIsInCaptureRange); |
| |
| PDumpCtrlLockRelease(); |
| |
| psPDumpConnectionData->ui32LastSetFrameNumber = ui32Frame; |
| |
| /* Save the Transition data incase we fail the Transition */ |
| psPDumpConnectionData->bWasInCaptureRange = bWasInCaptureRange; |
| psPDumpConnectionData->bIsInCaptureRange = bIsInCaptureRange; |
| } |
| else if (psPDumpConnectionData->bLastTransitionFailed) |
| { |
| /* Load the Transition data so we can try again */ |
| bWasInCaptureRange = psPDumpConnectionData->bWasInCaptureRange; |
| bIsInCaptureRange = psPDumpConnectionData->bIsInCaptureRange; |
| } |
| else |
| { |
| /* New frame is the same as the last frame set and the last |
| * transition succeeded, no need to perform another transition. |
| */ |
| return PVRSRV_OK; |
| } |
| |
| if (!bWasInCaptureRange && bIsInCaptureRange) |
| { |
| eError = PDumpTransition(psPDumpConnectionData, IMG_TRUE, PDUMP_FLAGS_NONE); |
| if (eError != PVRSRV_OK) |
| { |
| goto fail_Transition; |
| } |
| } |
| else if (bWasInCaptureRange && !bIsInCaptureRange) |
| { |
| eError = PDumpTransition(psPDumpConnectionData, IMG_FALSE, PDUMP_FLAGS_NONE); |
| if (eError != PVRSRV_OK) |
| { |
| goto fail_Transition; |
| } |
| } |
| else |
| { |
| /* Here both previous and current frames are in or out of range. |
| * There is no transition in this case. |
| */ |
| } |
| |
| psPDumpConnectionData->bLastTransitionFailed = IMG_FALSE; |
| return PVRSRV_OK; |
| |
| fail_Transition: |
| psPDumpConnectionData->bLastTransitionFailed = IMG_TRUE; |
| return eError; |
| } |
| |
| PVRSRV_ERROR PDumpSetFrameKM(CONNECTION_DATA *psConnection, |
| PVRSRV_DEVICE_NODE * psDeviceNode, |
| IMG_UINT32 ui32Frame) |
| { |
| PVRSRV_ERROR eError = PVRSRV_OK; |
| |
| PVR_UNREFERENCED_PARAMETER(psDeviceNode); |
| |
| #if defined(PDUMP_TRACE_STATE) |
| PVR_DPF((PVR_DBG_WARNING, "PDumpSetFrameKM: ui32Frame( %d )", ui32Frame)); |
| #endif |
| |
| #if defined(PDUMP_DEBUG_OUTFILES) |
| (void) PDumpCommentWithFlags(PDUMP_FLAGS_CONTINUOUS, "Set pdump frame %u (pre)", ui32Frame); |
| #endif |
| |
| eError = _PDumpSetFrameKM(psConnection, ui32Frame); |
| if ((eError != PVRSRV_OK) && (eError != PVRSRV_ERROR_RETRY)) |
| { |
| PVR_LOG_ERROR(eError, "_PDumpSetFrameKM"); |
| } |
| |
| #if defined(PDUMP_DEBUG_OUTFILES) |
| (void) PDumpCommentWithFlags(PDUMP_FLAGS_CONTINUOUS, "Set pdump frame %u (post)", ui32Frame); |
| #endif |
| |
| return eError; |
| } |
| |
| PVRSRV_ERROR PDumpGetFrameKM(CONNECTION_DATA *psConnection, |
| PVRSRV_DEVICE_NODE * psDeviceNode, |
| IMG_UINT32* pui32Frame) |
| { |
| PVRSRV_ERROR eError = PVRSRV_OK; |
| |
| PVR_UNREFERENCED_PARAMETER(psConnection); |
| |
| /* |
| It may be safe to avoid acquiring this lock here as all the other calls |
| which read/modify current frame will wait on the PDump Control bridge |
| lock first. Also, in no way as of now, does the PDumping app modify the |
| current frame through a call which acquires the global bridge lock. |
| Still, as a legacy we acquire and then read. |
| */ |
| PDumpCtrlLockAcquire(); |
| |
| *pui32Frame = PDumpCtrlGetCurrentFrame(); |
| |
| PDumpCtrlLockRelease(); |
| return eError; |
| } |
| |
| PVRSRV_ERROR PDumpSetDefaultCaptureParamsKM(IMG_UINT32 ui32Mode, |
| IMG_UINT32 ui32Start, |
| IMG_UINT32 ui32End, |
| IMG_UINT32 ui32Interval, |
| IMG_UINT32 ui32MaxParamFileSize) |
| { |
| /* |
| Acquire PDUMP_CTRL_STATE struct lock before modifications as a |
| PDumping app may be reading the state data for some checks |
| */ |
| PDumpCtrlLockAcquire(); |
| PDumpCtrlSetDefaultCaptureParams(ui32Mode, ui32Start, ui32End, ui32Interval); |
| PDumpCtrlLockRelease(); |
| |
| if (ui32MaxParamFileSize == 0) |
| { |
| g_PDumpParameters.ui32MaxFileSize = PRM_FILE_SIZE_MAX; |
| } |
| else |
| { |
| g_PDumpParameters.ui32MaxFileSize = ui32MaxParamFileSize; |
| } |
| return PVRSRV_OK; |
| } |
| |
| |
| /************************************************************************** |
| * Function Name : PDumpReg32 |
| * Inputs : pszPDumpDevName, Register offset, and value to write |
| * Outputs : None |
| * Returns : PVRSRV_ERROR |
| * Description : Create a PDUMP string, which represents a register write |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpReg32(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32Reg, |
| IMG_UINT32 ui32Data, |
| IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING() |
| PDUMP_DBG(("PDumpReg32")); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW :%s:0x%08X 0x%08X", pszPDumpRegName, ui32Reg, ui32Data); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| |
| /************************************************************************** |
| * Function Name : PDumpReg64 |
| * Inputs : pszPDumpDevName, Register offset, and value to write |
| * Outputs : None |
| * Returns : PVRSRV_ERROR |
| * Description : Create a PDUMP string, which represents a register write |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpReg64(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32Reg, |
| IMG_UINT64 ui64Data, |
| IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING() |
| PDUMP_DBG(("PDumpRegKM")); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW64 :%s:0x%08X 0x%010llX", pszPDumpRegName, ui32Reg, ui64Data); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| /************************************************************************** |
| * Function Name : PDumpRegLabelToReg64 |
| * Returns : PVRSRV_ERROR |
| * Description : Create a PDUMP string, which represents a register write from a register label |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpRegLabelToReg64(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32RegDst, |
| IMG_UINT32 ui32RegSrc, |
| IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING() |
| PDUMP_DBG(("PDumpRegLabelToReg64")); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW64 :%s:0x%08X :%s:0x%08X", pszPDumpRegName, ui32RegDst, pszPDumpRegName, ui32RegSrc); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| |
| } |
| |
| /************************************************************************** |
| * Function Name : PDumpRegLabelToMem32 |
| * Returns : PVRSRV_ERROR |
| * Description : Create a PDUMP string, which represents a memory write from a register label |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpRegLabelToMem32(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32Reg, |
| PMR *psPMR, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffset, |
| IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr; |
| IMG_CHAR aszMemspaceName[PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH]; |
| IMG_CHAR aszSymbolicName[PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH]; |
| IMG_DEVMEM_OFFSET_T uiPDumpSymbolicOffset; |
| IMG_DEVMEM_OFFSET_T uiNextSymName; |
| |
| PDUMP_GET_SCRIPT_STRING() |
| PDUMP_DBG(("PDumpRegLabelToMem32")); |
| |
| eErr = PMR_PDumpSymbolicAddr(psPMR, |
| uiLogicalOffset, |
| PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH, |
| aszMemspaceName, |
| PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH, |
| aszSymbolicName, |
| &uiPDumpSymbolicOffset, |
| &uiNextSymName); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| return eErr; |
| } |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW :%s:%s:0x%llX :%s:0x%08X",aszMemspaceName, aszSymbolicName, |
| uiPDumpSymbolicOffset, pszPDumpRegName, ui32Reg); |
| |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| /************************************************************************** |
| * Function Name : PDumpRegLabelToMem64 |
| * Returns : PVRSRV_ERROR |
| * Description : Create a PDUMP string, which represents a memory write from a register label |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpRegLabelToMem64(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32Reg, |
| PMR *psPMR, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffset, |
| IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr; |
| IMG_CHAR aszMemspaceName[PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH]; |
| IMG_CHAR aszSymbolicName[PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH]; |
| IMG_DEVMEM_OFFSET_T uiPDumpSymbolicOffset; |
| IMG_DEVMEM_OFFSET_T uiNextSymName; |
| |
| PDUMP_GET_SCRIPT_STRING() |
| PDUMP_DBG(("PDumpRegLabelToMem64")); |
| |
| eErr = PMR_PDumpSymbolicAddr(psPMR, |
| uiLogicalOffset, |
| PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH, |
| aszMemspaceName, |
| PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH, |
| aszSymbolicName, |
| &uiPDumpSymbolicOffset, |
| &uiNextSymName); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| return eErr; |
| } |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW64 :%s:%s:0x%llX :%s:0x%08X",aszMemspaceName, aszSymbolicName, |
| uiPDumpSymbolicOffset, pszPDumpRegName, ui32Reg); |
| |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| |
| /************************************************************************** |
| * Function Name : PDumpMemLabelToInternalVar |
| * Returns : PVRSRV_ERROR |
| * Description : Create a PDUMP string, which represents an internal var write using a memory label |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpMemLabelToInternalVar(IMG_CHAR *pszInternalVar, |
| PMR *psPMR, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffset, |
| IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr; |
| IMG_CHAR aszMemspaceName[PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH]; |
| IMG_CHAR aszSymbolicName[PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH]; |
| IMG_DEVMEM_OFFSET_T uiPDumpSymbolicOffset; |
| IMG_DEVMEM_OFFSET_T uiNextSymName; |
| |
| PDUMP_GET_SCRIPT_STRING() |
| PDUMP_DBG(("PDumpMemLabelToInternalVar")); |
| |
| eErr = PMR_PDumpSymbolicAddr(psPMR, |
| uiLogicalOffset, |
| PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH, |
| aszMemspaceName, |
| PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH, |
| aszSymbolicName, |
| &uiPDumpSymbolicOffset, |
| &uiNextSymName); |
| |
| |
| if (eErr != PVRSRV_OK) |
| { |
| return eErr; |
| } |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW %s :%s:%s:0x%llX", pszInternalVar, |
| aszMemspaceName, aszSymbolicName, uiPDumpSymbolicOffset); |
| |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function PDumpWriteRegANDValueOp |
| |
| @Description |
| |
| Emits the PDump commands for the logical OR operation |
| Var <- Var OR Value |
| |
| @Return PVRSRV_ERROR |
| |
| ******************************************************************************/ |
| PVRSRV_ERROR PDumpWriteVarORValueOp (const IMG_CHAR *pszInternalVariable, |
| const IMG_UINT64 ui64Value, |
| const IMG_UINT32 ui32PDumpFlags) |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "OR %s %s 0x%llX", |
| pszInternalVariable, |
| pszInternalVariable, |
| ui64Value); |
| |
| if(eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript( hScript, ui32PDumpFlags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| |
| /******************************************************************************************************* |
| * Function Name : PDumpRegLabelToInternalVar |
| * Outputs : None |
| * Returns : PVRSRV_ERROR |
| * Description : Create a PDUMP string, which writes a register label into an internal variable |
| ********************************************************************************************************/ |
| PVRSRV_ERROR PDumpRegLabelToInternalVar(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32Reg, |
| IMG_CHAR *pszInternalVar, |
| IMG_UINT32 ui32Flags) |
| |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING() |
| PDUMP_DBG(("PDumpRegLabelToInternalVar")); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW %s :%s:0x%08X", pszInternalVar, pszPDumpRegName, ui32Reg); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| |
| } |
| |
| /******************************************************************************************************* |
| * Function Name : PDumpInternalVarToReg32 |
| * Outputs : None |
| * Returns : PVRSRV_ERROR |
| * Description : Create a PDUMP string, which represents a register write from an internal variable |
| ********************************************************************************************************/ |
| PVRSRV_ERROR PDumpInternalVarToReg32(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32Reg, |
| IMG_CHAR *pszInternalVar, |
| IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING() |
| PDUMP_DBG(("PDumpInternalVarToReg32")); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW :%s:0x%08X %s", pszPDumpRegName, ui32Reg, pszInternalVar); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| /******************************************************************************************************* |
| * Function Name : PDumpInternalVarToReg64 |
| * Outputs : None |
| * Returns : PVRSRV_ERROR |
| * Description : Create a PDUMP string, which represents a register write from an internal variable |
| ********************************************************************************************************/ |
| PVRSRV_ERROR PDumpInternalVarToReg64(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32Reg, |
| IMG_CHAR *pszInternalVar, |
| IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING() |
| PDUMP_DBG(("PDumpInternalVarToReg64")); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW64 :%s:0x%08X %s", pszPDumpRegName, ui32Reg, pszInternalVar); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| |
| |
| /******************************************************************************************************* |
| * Function Name : PDumpMemLabelToMem32 |
| * Outputs : None |
| * Returns : PVRSRV_ERROR |
| * Description : Create a PDUMP string, which represents a memory write from a memory label |
| ********************************************************************************************************/ |
| PVRSRV_ERROR PDumpMemLabelToMem32(PMR *psPMRSource, |
| PMR *psPMRDest, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffsetSource, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffsetDest, |
| IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr; |
| IMG_CHAR aszMemspaceNameSource[PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH]; |
| IMG_CHAR aszSymbolicNameSource[PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH]; |
| IMG_CHAR aszMemspaceNameDest[PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH]; |
| IMG_CHAR aszSymbolicNameDest[PHYSMEM_PDUMP_MEMSPNAME_SYMB_ADDR_MAX_LENGTH]; |
| IMG_DEVMEM_OFFSET_T uiPDumpSymbolicOffsetSource; |
| IMG_DEVMEM_OFFSET_T uiPDumpSymbolicOffsetDest; |
| IMG_DEVMEM_OFFSET_T uiNextSymNameSource; |
| IMG_DEVMEM_OFFSET_T uiNextSymNameDest; |
| |
| |
| PDUMP_GET_SCRIPT_STRING() |
| PDUMP_DBG(("PDumpMemLabelToMem32")); |
| |
| eErr = PMR_PDumpSymbolicAddr(psPMRSource, |
| uiLogicalOffsetSource, |
| PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH, |
| aszMemspaceNameSource, |
| PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH, |
| aszSymbolicNameSource, |
| &uiPDumpSymbolicOffsetSource, |
| &uiNextSymNameSource); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| return eErr; |
| } |
| |
| eErr = PMR_PDumpSymbolicAddr(psPMRDest, |
| uiLogicalOffsetDest, |
| PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH, |
| aszMemspaceNameDest, |
| PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH, |
| aszSymbolicNameDest, |
| &uiPDumpSymbolicOffsetDest, |
| &uiNextSymNameDest); |
| |
| |
| if (eErr != PVRSRV_OK) |
| { |
| return eErr; |
| } |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW :%s:%s:0x%llX :%s:%s:0x%llX",aszMemspaceNameDest, aszSymbolicNameDest, |
| uiPDumpSymbolicOffsetDest, aszMemspaceNameSource, aszSymbolicNameSource, |
| uiPDumpSymbolicOffsetSource); |
| |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| /******************************************************************************************************* |
| * Function Name : PDumpMemLabelToMem64 |
| * Outputs : None |
| * Returns : PVRSRV_ERROR |
| * Description : Create a PDUMP string, which represents a memory write from a memory label |
| ********************************************************************************************************/ |
| PVRSRV_ERROR PDumpMemLabelToMem64(PMR *psPMRSource, |
| PMR *psPMRDest, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffsetSource, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffsetDest, |
| IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr; |
| IMG_CHAR aszMemspaceNameSource[PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH]; |
| IMG_CHAR aszSymbolicNameSource[PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH]; |
| IMG_CHAR aszMemspaceNameDest[PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH]; |
| IMG_CHAR aszSymbolicNameDest[PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH]; |
| IMG_DEVMEM_OFFSET_T uiPDumpSymbolicOffsetSource; |
| IMG_DEVMEM_OFFSET_T uiPDumpSymbolicOffsetDest; |
| IMG_DEVMEM_OFFSET_T uiNextSymNameSource; |
| IMG_DEVMEM_OFFSET_T uiNextSymNameDest; |
| |
| |
| PDUMP_GET_SCRIPT_STRING() |
| PDUMP_DBG(("PDumpMemLabelToMem64")); |
| |
| eErr = PMR_PDumpSymbolicAddr(psPMRSource, |
| uiLogicalOffsetSource, |
| PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH, |
| aszMemspaceNameSource, |
| PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH, |
| aszSymbolicNameSource, |
| &uiPDumpSymbolicOffsetSource, |
| &uiNextSymNameSource); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| return eErr; |
| } |
| |
| eErr = PMR_PDumpSymbolicAddr(psPMRDest, |
| uiLogicalOffsetDest, |
| PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH, |
| aszMemspaceNameDest, |
| PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH, |
| aszSymbolicNameDest, |
| &uiPDumpSymbolicOffsetDest, |
| &uiNextSymNameDest); |
| |
| |
| if (eErr != PVRSRV_OK) |
| { |
| return eErr; |
| } |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW64 :%s:%s:0x%llX :%s:%s:0x%llX",aszMemspaceNameDest, aszSymbolicNameDest, |
| uiPDumpSymbolicOffsetDest, aszMemspaceNameSource, aszSymbolicNameSource, |
| uiPDumpSymbolicOffsetSource); |
| |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function PDumpWriteVarSHRValueOp |
| |
| @Description |
| |
| Emits the PDump commands for the logical SHR operation |
| Var <- Var SHR Value |
| |
| @Return PVRSRV_ERROR |
| |
| ******************************************************************************/ |
| PVRSRV_ERROR PDumpWriteVarSHRValueOp (const IMG_CHAR *pszInternalVariable, |
| const IMG_UINT64 ui64Value, |
| const IMG_UINT32 ui32PDumpFlags) |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "SHR %s %s 0x%llX", |
| pszInternalVariable, |
| pszInternalVariable, |
| ui64Value); |
| |
| if(eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript( hScript, ui32PDumpFlags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function PDumpWriteRegANDValueOp |
| |
| @Description |
| |
| Emits the PDump commands for the logical AND operation |
| Var <- Var AND Value |
| |
| @Return PVRSRV_ERROR |
| |
| ******************************************************************************/ |
| PVRSRV_ERROR PDumpWriteVarANDValueOp (const IMG_CHAR *pszInternalVariable, |
| const IMG_UINT64 ui64Value, |
| const IMG_UINT32 ui32PDumpFlags) |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "AND %s %s 0x%llX", |
| pszInternalVariable, |
| pszInternalVariable, |
| ui64Value); |
| |
| if(eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript( hScript, ui32PDumpFlags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| |
| /************************************************************************** |
| * Function Name : PDumpSAW |
| * Inputs : pszDevSpaceName -- device space from which to output |
| * ui32Offset -- offset value from register base |
| * ui32NumSaveBytes -- number of bytes to output |
| * pszOutfileName -- name of file to output to |
| * ui32OutfileOffsetByte -- offset into output file to write |
| * uiPDumpFlags -- flags to pass to PDumpOSWriteScript |
| * Outputs : None |
| * Returns : PVRSRV_ERROR |
| * Description : Dumps the contents of a register bank into a file |
| * NB: ui32NumSaveBytes must be divisible by 4 |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpSAW(IMG_CHAR *pszDevSpaceName, |
| IMG_UINT32 ui32HPOffsetBytes, |
| IMG_UINT32 ui32NumSaveBytes, |
| IMG_CHAR *pszOutfileName, |
| IMG_UINT32 ui32OutfileOffsetByte, |
| PDUMP_FLAGS_T uiPDumpFlags) |
| { |
| PVRSRV_ERROR eError; |
| |
| PDUMP_GET_SCRIPT_STRING() |
| |
| PVR_DPF((PVR_DBG_ERROR, "PDumpSAW\n")); |
| |
| PDUMP_LOCK(); |
| eError = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "SAW :%s:0x%x 0x%x 0x%x %s\n", |
| pszDevSpaceName, |
| ui32HPOffsetBytes, |
| ui32NumSaveBytes / (IMG_UINT32)sizeof(IMG_UINT32), |
| ui32OutfileOffsetByte, |
| pszOutfileName); |
| |
| if(eError != PVRSRV_OK) |
| { |
| PVR_DPF((PVR_DBG_ERROR, "PDumpSAW PDumpOSBufprintf failed: eError=%u\n", eError)); |
| PDUMP_UNLOCK(); |
| return eError; |
| } |
| |
| if(! PDumpWriteScript(hScript, uiPDumpFlags)) |
| { |
| PVR_DPF((PVR_DBG_ERROR, "PDumpSAW PDumpWriteScript failed!\n")); |
| } |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| |
| } |
| |
| |
| /************************************************************************** |
| * Function Name : PDumpRegPolKM |
| * Inputs : Description of what this register read is trying to do |
| * pszPDumpDevName |
| * Register offset |
| * expected value |
| * mask for that value |
| * Outputs : None |
| * Returns : None |
| * Description : Create a PDUMP string which represents a register read |
| * with the expected value |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpRegPolKM(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32RegAddr, |
| IMG_UINT32 ui32RegValue, |
| IMG_UINT32 ui32Mask, |
| IMG_UINT32 ui32Flags, |
| PDUMP_POLL_OPERATOR eOperator) |
| { |
| /* Timings correct for linux and XP */ |
| /* Timings should be passed in */ |
| #define POLL_DELAY 1000U |
| #define POLL_COUNT_LONG (2000000000U / POLL_DELAY) |
| #define POLL_COUNT_SHORT (1000000U / POLL_DELAY) |
| |
| PVRSRV_ERROR eErr; |
| IMG_UINT32 ui32PollCount; |
| |
| PDUMP_GET_SCRIPT_STRING(); |
| PDUMP_DBG(("PDumpRegPolKM")); |
| |
| ui32PollCount = POLL_COUNT_LONG; |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "POL :%s:0x%08X 0x%08X 0x%08X %d %u %d", |
| pszPDumpRegName, ui32RegAddr, ui32RegValue, |
| ui32Mask, eOperator, ui32PollCount, POLL_DELAY); |
| if(eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| PDUMP_UNLOCK(); |
| return PVRSRV_OK; |
| } |
| |
| /* Never call direct, needs caller to hold OS Lock. |
| * Use PDumpCommentWithFlags() from within the server. |
| * Clients call this via the bridge and PDumpCommentKM(). |
| */ |
| static PVRSRV_ERROR _PDumpWriteComment(IMG_CHAR *pszComment, IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr; |
| #if defined(PDUMP_DEBUG_OUTFILES) |
| IMG_CHAR pszTemp[256]; |
| #endif |
| PDUMP_GET_SCRIPT_STRING(); |
| PDUMP_DBG(("PDumpCommentKM")); |
| |
| if((pszComment == NULL) || (PDumpOSBuflen(pszComment, ui32MaxLen) == 0)) |
| { |
| /* PDumpOSVerifyLineEnding silently fails if pszComment is too short to |
| actually hold the line endings that it's trying to enforce, so |
| short circuit it and force safety */ |
| pszComment = "\n"; |
| } |
| else |
| { |
| /* Put line ending sequence at the end if it isn't already there */ |
| PDumpOSVerifyLineEnding(pszComment, ui32MaxLen); |
| } |
| |
| #if defined(PDUMP_DEBUG_OUTFILES) |
| /* Prefix comment with PID and line number */ |
| eErr = PDumpOSSprintf(pszTemp, 256, "%u %u:%lu %s: %s", |
| g_ui32EveryLineCounter, |
| OSGetCurrentClientProcessIDKM(), |
| (unsigned long)OSGetCurrentClientThreadIDKM(), |
| OSGetCurrentClientProcessNameKM(), |
| pszComment); |
| |
| /* Append the comment to the script stream */ |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- %s", |
| pszTemp); |
| #else |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- %s", |
| pszComment); |
| #endif |
| if( (eErr != PVRSRV_OK) && |
| (eErr != PVRSRV_ERROR_PDUMP_BUF_OVERFLOW)) |
| { |
| PVR_LOGG_IF_ERROR(eErr, "PDumpOSBufprintf", ErrUnlock); |
| } |
| |
| if (!PDumpWriteScript(hScript, ui32Flags)) |
| { |
| if(PDUMP_IS_CONTINUOUS(ui32Flags)) |
| { |
| eErr = PVRSRV_ERROR_PDUMP_BUFFER_FULL; |
| PVR_LOGG_IF_ERROR(eErr, "PDumpWriteScript", ErrUnlock); |
| } |
| else |
| { |
| eErr = PVRSRV_ERROR_CMD_NOT_PROCESSED; |
| PVR_LOGG_IF_ERROR(eErr, "PDumpWriteScript", ErrUnlock); |
| } |
| } |
| |
| ErrUnlock: |
| return eErr; |
| } |
| |
| /************************************************************************** |
| * Function Name : PDumpCommentKM |
| * Inputs : pszComment, ui32Flags |
| * Outputs : None |
| * Returns : None |
| * Description : Dumps a pre-formatted comment, primarily called from the |
| * : bridge. |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpCommentKM(IMG_CHAR *pszComment, IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr = PVRSRV_OK; |
| |
| PDUMP_LOCK(); |
| |
| eErr = _PDumpWriteComment(pszComment, ui32Flags); |
| |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| /************************************************************************** |
| * Function Name : PDumpCommentWithFlags |
| * Inputs : psPDev - PDev for PDump device |
| * : pszFormat - format string for comment |
| * : ... - args for format string |
| * Outputs : None |
| * Returns : None |
| * Description : PDumps a comments |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpCommentWithFlags(IMG_UINT32 ui32Flags, IMG_CHAR * pszFormat, ...) |
| { |
| PVRSRV_ERROR eErr = PVRSRV_OK; |
| va_list args; |
| |
| va_start(args, pszFormat); |
| PDumpCommentWithFlagsVA(ui32Flags, pszFormat, args); |
| va_end(args); |
| |
| return eErr; |
| } |
| |
| /************************************************************************** |
| * Function Name : PDumpCommentWithFlagsVA |
| * Inputs : psPDev - PDev for PDump device |
| * : pszFormat - format string for comment |
| * : args - pre-started va_list args for format string |
| * Outputs : None |
| * Returns : None |
| * Description : PDumps a comments |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpCommentWithFlagsVA(IMG_UINT32 ui32Flags, const IMG_CHAR * pszFormat, va_list args) |
| { |
| PVRSRV_ERROR eErr = PVRSRV_OK; |
| PDUMP_GET_MSG_STRING(); |
| |
| PDUMP_LOCK(); |
| |
| /* Construct the string */ |
| eErr = PDumpOSVSprintf(pszMsg, ui32MaxLen, pszFormat, args); |
| |
| if(eErr != PVRSRV_OK) |
| { |
| goto Unlock; |
| } |
| |
| eErr = _PDumpWriteComment(pszMsg, ui32Flags); |
| |
| Unlock: |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| /*************************************************************************/ /*! |
| * Function Name : PDumpPanic |
| * Inputs : ui32PanicNo - Unique number for panic condition |
| * : pszPanicMsg - Panic reason message limited to ~90 chars |
| * : pszPPFunc - Function name string where panic occurred |
| * : ui32PPline - Source line number where panic occurred |
| * Outputs : None |
| * Returns : PVRSRV_ERROR |
| * Description : PDumps a panic assertion. Used when the host driver |
| * : detects a condition that will lead to an invalid PDump |
| * : script that cannot be played back off-line. |
| */ /*************************************************************************/ |
| PVRSRV_ERROR PDumpPanic(IMG_UINT32 ui32PanicNo, |
| IMG_CHAR* pszPanicMsg, |
| const IMG_CHAR* pszPPFunc, |
| IMG_UINT32 ui32PPline) |
| { |
| PVRSRV_ERROR eError = PVRSRV_OK; |
| PDUMP_FLAGS_T uiPDumpFlags = PDUMP_FLAGS_CONTINUOUS; |
| IMG_CHAR pszConsoleMsg[] = |
| "COM ***************************************************************************\n" |
| "COM Script invalid and not compatible with off-line playback. Check test \n" |
| "COM parameters and driver configuration, stop imminent.\n" |
| "COM ***************************************************************************\n"; |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| /* Log the panic condition to the live kern.log in both REL and DEB mode |
| * to aid user PDump trouble shooting. */ |
| PVR_LOG(("PDUMP PANIC %08x: %s", ui32PanicNo, pszPanicMsg)); |
| PVR_DPF((PVR_DBG_MESSAGE, "PDUMP PANIC start %s:%d", pszPPFunc, ui32PPline)); |
| |
| /* Check the supplied panic reason string is within length limits */ |
| PVR_ASSERT(OSStringLength(pszPanicMsg)+sizeof("PANIC ") < PVRSRV_PDUMP_MAX_COMMENT_SIZE-1); |
| |
| /* Obtain lock to keep the multi-line |
| * panic statement together in a single atomic write */ |
| PDUMP_LOCK(); |
| |
| |
| /* Write -- Panic start (Function:line) */ |
| eError = PDumpOSBufprintf(hScript, ui32MaxLen, "-- Panic start (%s:%d)", pszPPFunc, ui32PPline); |
| PVR_LOGG_IF_ERROR(eError, "PDumpOSBufprintf", e1); |
| (void)PDumpWriteScript(hScript, uiPDumpFlags); |
| |
| /* Write COM <message> x4 */ |
| eError = PDumpOSBufprintf(hScript, ui32MaxLen, pszConsoleMsg); |
| PVR_LOGG_IF_ERROR(eError, "PDumpOSBufprintf", e1); |
| (void)PDumpWriteScript(hScript, uiPDumpFlags); |
| |
| /* Write PANIC no msg command */ |
| eError = PDumpOSBufprintf(hScript, ui32MaxLen, "PANIC %08x %s", ui32PanicNo, pszPanicMsg); |
| PVR_LOGG_IF_ERROR(eError, "PDumpOSBufprintf", e1); |
| (void)PDumpWriteScript(hScript, uiPDumpFlags); |
| |
| /* Write -- Panic end */ |
| eError = PDumpOSBufprintf(hScript, ui32MaxLen, "-- Panic end"); |
| PVR_LOGG_IF_ERROR(eError, "PDumpOSBufprintf", e1); |
| (void)PDumpWriteScript(hScript, uiPDumpFlags); |
| |
| e1: |
| PDUMP_UNLOCK(); |
| |
| return eError; |
| } |
| |
| /*************************************************************************/ /*! |
| * Function Name : PDumpCaptureError |
| * Inputs : ui32ErrorNo - Unique number for panic condition |
| * : pszErrorMsg - Panic reason message limited to ~90 chars |
| * : pszPPFunc - Function name string where panic occurred |
| * : ui32PPline - Source line number where panic occurred |
| * Outputs : None |
| * Returns : PVRSRV_ERROR |
| * Description : PDumps an error string to the script file to interrupt |
| * : play back to inform user of a fatal issue that occurred |
| * : during PDump capture. |
| */ /*************************************************************************/ |
| PVRSRV_ERROR PDumpCaptureError(PVRSRV_ERROR ui32ErrorNo, |
| IMG_CHAR* pszErrorMsg, |
| const IMG_CHAR* pszPPFunc, |
| IMG_UINT32 ui32PPline) |
| { |
| IMG_CHAR* pszFormatStr = "DRIVER_ERROR: %3d: %s"; |
| PDUMP_FLAGS_T uiPDumpFlags = PDUMP_FLAGS_CONTINUOUS; |
| |
| /* Need to return an error using this macro */ |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| /* Check the supplied panic reason string is within length limits */ |
| PVR_ASSERT(OSStringLength(pszErrorMsg)+sizeof(pszFormatStr) < PVRSRV_PDUMP_MAX_COMMENT_SIZE-1); |
| |
| /* Obtain lock to keep the multi-line |
| * panic statement together in a single atomic write */ |
| PDUMP_LOCK(); |
| |
| /* Write driver error message to the script file */ |
| (void) PDumpOSBufprintf(hScript, ui32MaxLen, pszFormatStr, ui32ErrorNo, pszErrorMsg); |
| (void) PDumpWriteScript(hScript, uiPDumpFlags); |
| |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function PDumpBitmapKM |
| |
| @Description |
| |
| Dumps a bitmap from device memory to a file |
| |
| @Input psDevId |
| @Input pszFileName |
| @Input ui32FileOffset |
| @Input ui32Width |
| @Input ui32Height |
| @Input ui32StrideInBytes |
| @Input sDevBaseAddr |
| @Input ui32Size |
| @Input ePixelFormat |
| @Input eMemFormat |
| @Input ui32PDumpFlags |
| |
| @Return PVRSRV_ERROR : |
| |
| ******************************************************************************/ |
| 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) |
| { |
| PVRSRV_DEVICE_IDENTIFIER *psDevId = &psDeviceNode->sDevId; |
| PVRSRV_ERROR eErr=0; |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| PDumpCommentWithFlags(ui32PDumpFlags, "Dump bitmap of render."); |
| |
| switch (ePixelFormat) |
| { |
| case PVRSRV_PDUMP_PIXEL_FORMAT_YUV8: |
| { |
| PDumpCommentWithFlags(ui32PDumpFlags, "YUV data. Switching from SII to SAB. Width=0x%08X Height=0x%08X Stride=0x%08X", |
| ui32Width, ui32Height, ui32StrideInBytes); |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "SAB :%s:v%x:0x%010llX 0x%08X 0x%08X %s.bin\n", |
| psDevId->pszPDumpDevName, |
| ui32MMUContextID, |
| sDevBaseAddr.uiAddr, |
| ui32Size, |
| ui32FileOffset, |
| pszFileName); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript( hScript, ui32PDumpFlags); |
| PDUMP_UNLOCK(); |
| break; |
| } |
| case PVRSRV_PDUMP_PIXEL_FORMAT_420PL12YUV8: // YUV420 2 planes |
| { |
| const IMG_UINT32 ui32Plane0Size = ui32StrideInBytes*ui32Height; |
| const IMG_UINT32 ui32Plane1Size = ui32Plane0Size>>1; // YUV420 |
| const IMG_UINT32 ui32Plane1FileOffset = ui32FileOffset + ui32Plane0Size; |
| const IMG_UINT32 ui32Plane1MemOffset = ui32Plane0Size; |
| |
| PDumpCommentWithFlags(ui32PDumpFlags, "YUV420 2-plane. Width=0x%08X Height=0x%08X Stride=0x%08X", |
| ui32Width, ui32Height, ui32StrideInBytes); |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "SII %s %s.bin :%s:v%x:0x%010llX 0x%08X 0x%08X :%s:v%x:0x%010llX 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X", |
| pszFileName, |
| pszFileName, |
| |
| // Plane 0 (Y) |
| psDevId->pszPDumpDevName, // memsp |
| ui32MMUContextID, // Context id |
| sDevBaseAddr.uiAddr, // virtaddr |
| ui32Plane0Size, // size |
| ui32FileOffset, // fileoffset |
| |
| // Plane 1 (UV) |
| psDevId->pszPDumpDevName, // memsp |
| ui32MMUContextID, // Context id |
| sDevBaseAddr.uiAddr+ui32Plane1MemOffset, // virtaddr |
| ui32Plane1Size, // size |
| ui32Plane1FileOffset, // fileoffset |
| |
| ePixelFormat, |
| ui32Width, |
| ui32Height, |
| ui32StrideInBytes, |
| ui32AddrMode); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript( hScript, ui32PDumpFlags); |
| PDUMP_UNLOCK(); |
| break; |
| } |
| |
| case PVRSRV_PDUMP_PIXEL_FORMAT_YUV_YV12: // YUV420 3 planes |
| { |
| const IMG_UINT32 ui32Plane0Size = ui32StrideInBytes*ui32Height; |
| const IMG_UINT32 ui32Plane1Size = ui32Plane0Size>>2; // YUV420 |
| const IMG_UINT32 ui32Plane2Size = ui32Plane1Size; |
| const IMG_UINT32 ui32Plane1FileOffset = ui32FileOffset + ui32Plane0Size; |
| const IMG_UINT32 ui32Plane2FileOffset = ui32Plane1FileOffset + ui32Plane1Size; |
| const IMG_UINT32 ui32Plane1MemOffset = ui32Plane0Size; |
| const IMG_UINT32 ui32Plane2MemOffset = ui32Plane0Size+ui32Plane1Size; |
| |
| PDumpCommentWithFlags(ui32PDumpFlags, "YUV420 3-plane. Width=0x%08X Height=0x%08X Stride=0x%08X", |
| ui32Width, ui32Height, ui32StrideInBytes); |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "SII %s %s.bin :%s:v%x:0x%010llX 0x%08X 0x%08X :%s:v%x:0x%010llX 0x%08X 0x%08X :%s:v%x:0x%010llX 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X", |
| pszFileName, |
| pszFileName, |
| |
| // Plane 0 (Y) |
| psDevId->pszPDumpDevName, // memsp |
| ui32MMUContextID, // MMU context id |
| sDevBaseAddr.uiAddr, // virtaddr |
| ui32Plane0Size, // size |
| ui32FileOffset, // fileoffset |
| |
| // Plane 1 (U) |
| psDevId->pszPDumpDevName, // memsp |
| ui32MMUContextID, // MMU context id |
| sDevBaseAddr.uiAddr+ui32Plane1MemOffset, // virtaddr |
| ui32Plane1Size, // size |
| ui32Plane1FileOffset, // fileoffset |
| |
| // Plane 2 (V) |
| psDevId->pszPDumpDevName, // memsp |
| ui32MMUContextID, // MMU context id |
| sDevBaseAddr.uiAddr+ui32Plane2MemOffset, // virtaddr |
| ui32Plane2Size, // size |
| ui32Plane2FileOffset, // fileoffset |
| |
| ePixelFormat, |
| ui32Width, |
| ui32Height, |
| ui32StrideInBytes, |
| ui32AddrMode); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript( hScript, ui32PDumpFlags); |
| PDUMP_UNLOCK(); |
| break; |
| } |
| |
| case PVRSRV_PDUMP_PIXEL_FORMAT_YUV_YV32: // YV32 - 4 contiguous planes in the order VUYA, stride can be > width. |
| { |
| const IMG_UINT32 ui32PlaneSize = ui32StrideInBytes*ui32Height; // All 4 planes are the same size |
| const IMG_UINT32 ui32Plane0FileOffset = ui32FileOffset + (ui32PlaneSize<<1); // SII plane 0 is Y, which is YV32 plane 2 |
| const IMG_UINT32 ui32Plane1FileOffset = ui32FileOffset + ui32PlaneSize; // SII plane 1 is U, which is YV32 plane 1 |
| const IMG_UINT32 ui32Plane2FileOffset = ui32FileOffset; // SII plane 2 is V, which is YV32 plane 0 |
| const IMG_UINT32 ui32Plane3FileOffset = ui32Plane0FileOffset + ui32PlaneSize; // SII plane 3 is A, which is YV32 plane 3 |
| const IMG_UINT32 ui32Plane0MemOffset = ui32PlaneSize<<1; |
| const IMG_UINT32 ui32Plane1MemOffset = ui32PlaneSize; |
| const IMG_UINT32 ui32Plane2MemOffset = 0; |
| const IMG_UINT32 ui32Plane3MemOffset = ui32Plane0MemOffset + ui32PlaneSize; |
| |
| PDumpCommentWithFlags(ui32PDumpFlags, "YV32 4 planes. Width=0x%08X Height=0x%08X Stride=0x%08X", |
| ui32Width, ui32Height, ui32StrideInBytes); |
| |
| PDumpCommentWithFlags(ui32PDumpFlags, "YV32 plane size is 0x%08X", ui32PlaneSize); |
| |
| PDumpCommentWithFlags(ui32PDumpFlags, "YV32 Plane 0 Mem Offset=0x%08X", ui32Plane0MemOffset); |
| PDumpCommentWithFlags(ui32PDumpFlags, "YV32 Plane 1 Mem Offset=0x%08X", ui32Plane1MemOffset); |
| PDumpCommentWithFlags(ui32PDumpFlags, "YV32 Plane 2 Mem Offset=0x%08X", ui32Plane2MemOffset); |
| PDumpCommentWithFlags(ui32PDumpFlags, "YV32 Plane 3 Mem Offset=0x%08X", ui32Plane3MemOffset); |
| |
| /* |
| SII <imageset> <filename> :<memsp1>:v<id1>:<virtaddr1> <size1> <fileoffset1> Y |
| :<memsp2>:v<id2>:<virtaddr2> <size2> <fileoffset2> U |
| :<memsp3>:v<id3>:<virtaddr3> <size3> <fileoffset3> V |
| :<memsp4>:v<id4>:<virtaddr4> <size4> <fileoffset4> A |
| <pixfmt> <width> <height> <stride> <addrmode> |
| */ |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "SII %s %s.bin :%s:v%x:0x%010llX 0x%08X 0x%08X :%s:v%x:0x%010llX 0x%08X 0x%08X :%s:v%x:0x%010llX 0x%08X 0x%08X :%s:v%x:0x%010llX 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X", |
| pszFileName, |
| pszFileName, |
| |
| // Plane 0 (V) |
| psDevId->pszPDumpDevName, // memsp |
| ui32MMUContextID, // MMU context id |
| sDevBaseAddr.uiAddr+ui32Plane0MemOffset, // virtaddr |
| ui32PlaneSize, // size |
| ui32Plane0FileOffset, // fileoffset |
| |
| // Plane 1 (U) |
| psDevId->pszPDumpDevName, // memsp |
| ui32MMUContextID, // MMU context id |
| sDevBaseAddr.uiAddr+ui32Plane1MemOffset, // virtaddr |
| ui32PlaneSize, // size |
| ui32Plane1FileOffset, // fileoffset |
| |
| // Plane 2 (Y) |
| psDevId->pszPDumpDevName, // memsp |
| ui32MMUContextID, // MMU context id |
| sDevBaseAddr.uiAddr+ui32Plane2MemOffset, // virtaddr |
| ui32PlaneSize, // size |
| ui32Plane2FileOffset, // fileoffset |
| |
| // Plane 3 (A) |
| psDevId->pszPDumpDevName, // memsp |
| ui32MMUContextID, // MMU context id |
| sDevBaseAddr.uiAddr+ui32Plane3MemOffset, // virtaddr |
| ui32PlaneSize, // size |
| ui32Plane3FileOffset, // fileoffset |
| |
| ePixelFormat, |
| ui32Width, |
| ui32Height, |
| ui32StrideInBytes, |
| ui32AddrMode); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript( hScript, ui32PDumpFlags); |
| PDUMP_UNLOCK(); |
| break; |
| } |
| |
| default: // Single plane formats |
| { |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "SII %s %s.bin :%s:v%x:0x%010llX 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X", |
| pszFileName, |
| pszFileName, |
| psDevId->pszPDumpDevName, |
| ui32MMUContextID, |
| sDevBaseAddr.uiAddr, |
| ui32Size, |
| ui32FileOffset, |
| ePixelFormat, |
| ui32Width, |
| ui32Height, |
| ui32StrideInBytes, |
| ui32AddrMode); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript( hScript, ui32PDumpFlags); |
| PDUMP_UNLOCK(); |
| break; |
| } |
| } |
| |
| return PVRSRV_OK; |
| } |
| |
| /*! |
| ****************************************************************************** |
| |
| @Function PDumpReadRegKM |
| |
| @Description |
| |
| Dumps a read from a device register to a file |
| |
| @Input psConnection : connection info |
| @Input pszFileName |
| @Input ui32FileOffset |
| @Input ui32Address |
| @Input ui32Size |
| @Input ui32PDumpFlags |
| |
| @Return PVRSRV_ERROR : |
| |
| ******************************************************************************/ |
| PVRSRV_ERROR PDumpReadRegKM ( IMG_CHAR *pszPDumpRegName, |
| IMG_CHAR *pszFileName, |
| IMG_UINT32 ui32FileOffset, |
| IMG_UINT32 ui32Address, |
| IMG_UINT32 ui32Size, |
| IMG_UINT32 ui32PDumpFlags) |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| PVR_UNREFERENCED_PARAMETER(ui32Size); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "SAB :%s:0x%08X 0x%08X %s", |
| pszPDumpRegName, |
| ui32Address, |
| ui32FileOffset, |
| pszFileName); |
| if(eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript( hScript, ui32PDumpFlags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| /***************************************************************************** |
| @name PDumpRegRead32 |
| @brief Dump 32-bit register read to script |
| @param pszPDumpDevName - pdump device name |
| @param ui32RegOffset - register offset |
| @param ui32Flags - pdump flags |
| @return Error |
| *****************************************************************************/ |
| PVRSRV_ERROR PDumpRegRead32(IMG_CHAR *pszPDumpRegName, |
| const IMG_UINT32 ui32RegOffset, |
| IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "RDW :%s:0x%X", |
| pszPDumpRegName, |
| ui32RegOffset); |
| if(eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| PDumpWriteScript(hScript, ui32Flags); |
| PDUMP_UNLOCK(); |
| return PVRSRV_OK; |
| } |
| |
| /***************************************************************************** |
| @name PDumpRegRead64 |
| @brief Dump 64-bit register read to script |
| @param pszPDumpDevName - pdump device name |
| @param ui32RegOffset - register offset |
| @param ui32Flags - pdump flags |
| @return Error |
| *****************************************************************************/ |
| PVRSRV_ERROR PDumpRegRead64(IMG_CHAR *pszPDumpRegName, |
| const IMG_UINT32 ui32RegOffset, |
| IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "RDW64 :%s:0x%X", |
| pszPDumpRegName, |
| ui32RegOffset); |
| if(eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| PDumpWriteScript(hScript, ui32Flags); |
| PDUMP_UNLOCK(); |
| return PVRSRV_OK; |
| } |
| |
| |
| /***************************************************************************** |
| FUNCTION : PDumpWriteShiftedMaskedValue |
| |
| PURPOSE : Emits the PDump commands for writing a masked shifted address |
| into another location |
| |
| PARAMETERS : PDump symbolic name and offset of target word |
| PDump symbolic name and offset of source address |
| right shift amount |
| left shift amount |
| mask |
| |
| RETURNS : None |
| *****************************************************************************/ |
| 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) |
| { |
| PVRSRV_ERROR eError; |
| |
| /* Suffix of WRW command in PDump (i.e. WRW or WRW64) */ |
| const IMG_CHAR *pszWrwSuffix; |
| |
| /* Internal PDump register used for interim calculation */ |
| const IMG_CHAR *pszPDumpIntRegSpace; |
| IMG_UINT32 uiPDumpIntRegNum; |
| |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| if ((uiWordSize != 4) && (uiWordSize != 8)) |
| { |
| return PVRSRV_ERROR_NOT_SUPPORTED; |
| } |
| |
| pszWrwSuffix = (uiWordSize == 8) ? "64" : ""; |
| |
| /* Should really "Acquire" a pdump register here */ |
| pszPDumpIntRegSpace = pszDestRegspaceName; |
| uiPDumpIntRegNum = 1; |
| |
| PDUMP_LOCK(); |
| eError = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| /* Should this be "MOV" instead? */ |
| "WRW :%s:$%d :%s:%s:" IMG_DEVMEM_OFFSET_FMTSPEC "\n", |
| /* dest */ |
| pszPDumpIntRegSpace, |
| uiPDumpIntRegNum, |
| /* src */ |
| pszRefRegspaceName, |
| pszRefSymbolicName, |
| uiRefOffset); |
| if (eError != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| |
| PDumpWriteScript(hScript, uiPDumpFlags); |
| |
| if (uiSHRAmount > 0) |
| { |
| eError = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "SHR :%s:$%d :%s:$%d 0x%X\n", |
| /* dest */ |
| pszPDumpIntRegSpace, |
| uiPDumpIntRegNum, |
| /* src A */ |
| pszPDumpIntRegSpace, |
| uiPDumpIntRegNum, |
| /* src B */ |
| uiSHRAmount); |
| if (eError != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, uiPDumpFlags); |
| } |
| |
| if (uiSHLAmount > 0) |
| { |
| eError = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "SHL :%s:$%d :%s:$%d 0x%X\n", |
| /* dest */ |
| pszPDumpIntRegSpace, |
| uiPDumpIntRegNum, |
| /* src A */ |
| pszPDumpIntRegSpace, |
| uiPDumpIntRegNum, |
| /* src B */ |
| uiSHLAmount); |
| if (eError != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, uiPDumpFlags); |
| } |
| |
| if (uiMask != (1ULL << (8*uiWordSize))-1) |
| { |
| eError = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "AND :%s:$%d :%s:$%d 0x%X\n", |
| /* dest */ |
| pszPDumpIntRegSpace, |
| uiPDumpIntRegNum, |
| /* src A */ |
| pszPDumpIntRegSpace, |
| uiPDumpIntRegNum, |
| /* src B */ |
| uiMask); |
| if (eError != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, uiPDumpFlags); |
| } |
| |
| eError = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "WRW%s :%s:%s:" IMG_DEVMEM_OFFSET_FMTSPEC " :%s:$%d\n", |
| pszWrwSuffix, |
| /* dest */ |
| pszDestRegspaceName, |
| pszDestSymbolicName, |
| uiDestOffset, |
| /* src */ |
| pszPDumpIntRegSpace, |
| uiPDumpIntRegNum); |
| if(eError != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, uiPDumpFlags); |
| |
| ErrUnlock: |
| PDUMP_UNLOCK(); |
| return eError; |
| } |
| |
| |
| 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) |
| { |
| const IMG_CHAR *pszWrwSuffix = ""; |
| PVRSRV_ERROR eError = PVRSRV_OK; |
| |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| if (ui32WordSize == 8) |
| { |
| pszWrwSuffix = "64"; |
| } |
| |
| PDUMP_LOCK(); |
| |
| if (ui32AlignShift != ui32Shift) |
| { |
| /* Write physical address into a variable */ |
| eError = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "WRW%s :%s:$1 %s:" IMG_DEVMEM_OFFSET_FMTSPEC "\n", |
| pszWrwSuffix, |
| /* dest */ |
| pszPDumpDevName, |
| /* src */ |
| pszRefSymbolicName, |
| uiRefOffset); |
| if (eError != PVRSRV_OK) |
| { |
| goto symbAddress_error; |
| } |
| PDumpWriteScript(hScript, uiPDumpFlags); |
| |
| /* apply address alignment */ |
| eError = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "SHR :%s:$1 :%s:$1 0x%X", |
| /* dest */ |
| pszPDumpDevName, |
| /* src A */ |
| pszPDumpDevName, |
| /* src B */ |
| ui32AlignShift); |
| if (eError != PVRSRV_OK) |
| { |
| goto symbAddress_error; |
| } |
| PDumpWriteScript(hScript, uiPDumpFlags); |
| |
| /* apply address shift */ |
| eError = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "SHL :%s:$1 :%s:$1 0x%X", |
| /* dest */ |
| pszPDumpDevName, |
| /* src A */ |
| pszPDumpDevName, |
| /* src B */ |
| ui32Shift); |
| if (eError != PVRSRV_OK) |
| { |
| goto symbAddress_error; |
| } |
| PDumpWriteScript(hScript, uiPDumpFlags); |
| |
| |
| /* write result to register */ |
| eError = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "WRW%s :%s:0x%08X :%s:$1", |
| pszWrwSuffix, |
| pszDestSpaceName, |
| (IMG_UINT32)uiDestOffset, |
| pszPDumpDevName); |
| if (eError != PVRSRV_OK) |
| { |
| goto symbAddress_error; |
| } |
| PDumpWriteScript(hScript, uiPDumpFlags); |
| } |
| else |
| { |
| eError = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "WRW%s :%s:" IMG_DEVMEM_OFFSET_FMTSPEC " %s:" IMG_DEVMEM_OFFSET_FMTSPEC "\n", |
| pszWrwSuffix, |
| /* dest */ |
| pszDestSpaceName, |
| uiDestOffset, |
| /* src */ |
| pszRefSymbolicName, |
| uiRefOffset); |
| if (eError != PVRSRV_OK) |
| { |
| goto symbAddress_error; |
| } |
| PDumpWriteScript(hScript, uiPDumpFlags); |
| } |
| |
| symbAddress_error: |
| |
| PDUMP_UNLOCK(); |
| |
| return eError; |
| } |
| |
| /************************************************************************** |
| * Function Name : PDumpIDLWithFlags |
| * Inputs : Idle time in clocks |
| * Outputs : None |
| * Returns : Error |
| * Description : Dump IDL command to script |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpIDLWithFlags(IMG_UINT32 ui32Clocks, IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING(); |
| PDUMP_DBG(("PDumpIDLWithFlags")); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "IDL %u", ui32Clocks); |
| if(eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| PDumpWriteScript(hScript, ui32Flags); |
| PDUMP_UNLOCK(); |
| return PVRSRV_OK; |
| } |
| |
| |
| /************************************************************************** |
| * Function Name : PDumpIDL |
| * Inputs : Idle time in clocks |
| * Outputs : None |
| * Returns : Error |
| * Description : Dump IDL command to script |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpIDL(IMG_UINT32 ui32Clocks) |
| { |
| return PDumpIDLWithFlags(ui32Clocks, PDUMP_FLAGS_CONTINUOUS); |
| } |
| |
| /***************************************************************************** |
| FUNCTION : PDumpRegBasedCBP |
| |
| PURPOSE : Dump CBP command to script |
| |
| PARAMETERS : |
| |
| RETURNS : None |
| *****************************************************************************/ |
| PVRSRV_ERROR PDumpRegBasedCBP(IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 ui32RegOffset, |
| IMG_UINT32 ui32WPosVal, |
| IMG_UINT32 ui32PacketSize, |
| IMG_UINT32 ui32BufferSize, |
| IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "CBP :%s:0x%08X 0x%08X 0x%08X 0x%08X", |
| pszPDumpRegName, |
| ui32RegOffset, |
| ui32WPosVal, |
| ui32PacketSize, |
| ui32BufferSize); |
| if(eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| PDumpWriteScript(hScript, ui32Flags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| 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) |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| PDUMP_LOCK(); |
| if(bEnable) |
| { |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, |
| "TRG :%s:v%u %u 0x%08llX 0x%08llX %u", |
| pszMemSpace, ui32MMUCtxID, ui32RegionID, |
| ui64VAddr, ui64LenBytes, ui32XStride); |
| } |
| else |
| { |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, |
| "TRG :%s:v%u %u", |
| pszMemSpace, ui32MMUCtxID, ui32RegionID); |
| |
| } |
| if(eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| /************************************************************************** |
| * Function Name : PDumpConnectionNotify |
| * Description : Called by the srvcore to tell PDump core that the |
| * PDump capture and control client has connected |
| **************************************************************************/ |
| void PDumpConnectionNotify(void) |
| { |
| PVRSRV_DATA *psPVRSRVData = PVRSRVGetPVRSRVData(); |
| PVRSRV_DEVICE_NODE *psThis; |
| |
| /* Give PDump control a chance to end the init phase, depends on OS */ |
| if (!PDumpCtrlInitPhaseComplete()) |
| { |
| PDumpStopInitPhase(IMG_TRUE, IMG_FALSE); |
| } |
| |
| g_ConnectionCount++; |
| PVR_LOG(("PDump has connected (%u)", g_ConnectionCount)); |
| |
| /* Reset the parameter file attributes */ |
| g_PDumpParameters.sWOff.ui32Main = g_PDumpParameters.sWOff.ui32Init; |
| g_PDumpParameters.ui32FileIdx = 0; |
| |
| /* Loop over all known devices */ |
| psThis = psPVRSRVData->psDeviceNodeList; |
| while (psThis) |
| { |
| if (psThis->pfnPDumpInitDevice) |
| { |
| /* Reset pdump according to connected device */ |
| psThis->pfnPDumpInitDevice(psThis); |
| } |
| psThis = psThis->psNext; |
| } |
| } |
| |
| /************************************************************************** |
| * Function Name : PDumpDisconnectionNotify |
| * Description : Called by the connection_server to tell PDump core that |
| * the PDump capture and control client has disconnected |
| **************************************************************************/ |
| void PDumpDisconnectionNotify(void) |
| { |
| PVRSRV_ERROR eErr; |
| |
| if (PDumpCtrlCaptureOn()) |
| { |
| PVR_LOG(("PDump killed, output files may be invalid or incomplete!")); |
| |
| /* Disable capture in server, in case PDump client was killed and did |
| * not get a chance to reset the capture parameters. |
| */ |
| eErr = PDumpSetDefaultCaptureParamsKM( DEBUG_CAPMODE_FRAMED, |
| FRAME_UNSET, FRAME_UNSET, 1, 0); |
| PVR_LOG_IF_ERROR(eErr, "PVRSRVPDumpSetDefaultCaptureParams"); |
| } |
| else |
| { |
| PVR_LOG(("PDump disconnected")); |
| } |
| } |
| |
| /************************************************************************** |
| * Function Name : PDumpIfKM |
| * Inputs : pszPDumpCond - string for condition |
| * Outputs : None |
| * Returns : None |
| * Description : Create a PDUMP string which represents IF command |
| with condition. |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpIfKM(IMG_CHAR *pszPDumpCond) |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING() |
| PDUMP_DBG(("PDumpIfKM")); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "IF %s\n", pszPDumpCond); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript(hScript, PDUMP_FLAGS_CONTINUOUS); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| /************************************************************************** |
| * Function Name : PDumpElseKM |
| * Inputs : pszPDumpCond - string for condition |
| * Outputs : None |
| * Returns : None |
| * Description : Create a PDUMP string which represents ELSE command |
| with condition. |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpElseKM(IMG_CHAR *pszPDumpCond) |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING() |
| PDUMP_DBG(("PDumpElseKM")); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "ELSE %s\n", pszPDumpCond); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript(hScript, PDUMP_FLAGS_CONTINUOUS); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| /************************************************************************** |
| * Function Name : PDumpFiKM |
| * Inputs : pszPDumpCond - string for condition |
| * Outputs : None |
| * Returns : None |
| * Description : Create a PDUMP string which represents FI command |
| with condition. |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpFiKM(IMG_CHAR *pszPDumpCond) |
| { |
| PVRSRV_ERROR eErr; |
| PDUMP_GET_SCRIPT_STRING() |
| PDUMP_DBG(("PDumpFiKM")); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "FI %s\n", pszPDumpCond); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| PDumpWriteScript(hScript, PDUMP_FLAGS_CONTINUOUS); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| PVRSRV_ERROR PDumpCreateLockKM(void) |
| { |
| return PDumpOSCreateLock(); |
| } |
| |
| void PDumpDestroyLockKM(void) |
| { |
| PDumpOSDestroyLock(); |
| } |
| |
| void PDumpLock(void) |
| { |
| PDumpOSLock(); |
| } |
| |
| void PDumpUnlock(void) |
| { |
| PDumpOSUnlock(); |
| } |
| |
| #if defined(PVR_TESTING_UTILS) |
| extern void PDumpOSDumpState(void); |
| |
| #if !defined(LINUX) |
| void PDumpOSDumpState(IMG_BOOL bDumpOSLayerState) |
| { |
| PVR_UNREFERENCED_PARAMETER(bDumpOSLayerState); |
| } |
| #endif |
| |
| void PDumpCommonDumpState(IMG_BOOL bDumpOSLayerState) |
| { |
| PVR_LOG(("--- PDUMP COMMON: g_PDumpInitialised( %d )", |
| g_PDumpInitialised) ); |
| PVR_LOG(("--- PDUMP COMMON: g_PDumpScript.sCh.hInit( %p ) g_PDumpScript.sCh.hMain( %p ) g_PDumpScript.sCh.hDeinit( %p )", |
| g_PDumpScript.sCh.hInit, g_PDumpScript.sCh.hMain, g_PDumpScript.sCh.hDeinit) ); |
| PVR_LOG(("--- PDUMP COMMON: g_PDumpParameters.sCh.hInit( %p ) g_PDumpParameters.sCh.hMain( %p ) g_PDumpParameters.sCh.hDeinit( %p )", |
| g_PDumpParameters.sCh.hInit, g_PDumpParameters.sCh.hMain, g_PDumpParameters.sCh.hDeinit) ); |
| PVR_LOG(("--- PDUMP COMMON: g_PDumpParameters.sWOff.ui32Init( %d ) g_PDumpParameters.sWOff.ui32Main( %d ) g_PDumpParameters.sWOff.ui32Deinit( %d )", |
| g_PDumpParameters.sWOff.ui32Init, g_PDumpParameters.sWOff.ui32Main, g_PDumpParameters.sWOff.ui32Deinit) ); |
| PVR_LOG(("--- PDUMP COMMON: g_PDumpParameters.ui32FileIdx( %d )", |
| g_PDumpParameters.ui32FileIdx) ); |
| |
| PVR_LOG(("--- PDUMP COMMON: g_PDumpCtrl( %p ) bInitPhaseActive( %d ) ui32Flags( %x )", |
| &g_PDumpCtrl, g_PDumpCtrl.bInitPhaseActive, g_PDumpCtrl.ui32Flags) ); |
| PVR_LOG(("--- PDUMP COMMON: ui32DefaultCapMode( %d ) ui32CurrentFrame( %d )", |
| g_PDumpCtrl.ui32DefaultCapMode, g_PDumpCtrl.ui32CurrentFrame) ); |
| PVR_LOG(("--- PDUMP COMMON: sCaptureRange.ui32Start( %x ) sCaptureRange.ui32End( %x ) sCaptureRange.ui32Interval( %u )", |
| g_PDumpCtrl.sCaptureRange.ui32Start, g_PDumpCtrl.sCaptureRange.ui32End, g_PDumpCtrl.sCaptureRange.ui32Interval) ); |
| PVR_LOG(("--- PDUMP COMMON: bCaptureOn( %d ) bSuspended( %d ) bInPowerTransition( %d )", |
| g_PDumpCtrl.bCaptureOn, g_PDumpCtrl.bSuspended, g_PDumpCtrl.bInPowerTransition) ); |
| |
| if (bDumpOSLayerState) |
| { |
| PDumpOSDumpState(); |
| } |
| } |
| #endif |
| |
| |
| PVRSRV_ERROR PDumpRegisterConnection(SYNC_CONNECTION_DATA *psSyncConnectionData, |
| PDUMP_CONNECTION_DATA **ppsPDumpConnectionData) |
| { |
| PDUMP_CONNECTION_DATA *psPDumpConnectionData; |
| PVRSRV_ERROR eError; |
| |
| PVR_ASSERT(ppsPDumpConnectionData != NULL); |
| |
| psPDumpConnectionData = OSAllocMem(sizeof(*psPDumpConnectionData)); |
| if (psPDumpConnectionData == NULL) |
| { |
| eError = PVRSRV_ERROR_OUT_OF_MEMORY; |
| goto fail_alloc; |
| } |
| |
| eError = OSLockCreate(&psPDumpConnectionData->hLock, LOCK_TYPE_PASSIVE); |
| if (eError != PVRSRV_OK) |
| { |
| goto fail_lockcreate; |
| } |
| |
| dllist_init(&psPDumpConnectionData->sListHead); |
| psPDumpConnectionData->ui32RefCount = 1; |
| psPDumpConnectionData->bLastInto = IMG_FALSE; |
| psPDumpConnectionData->ui32LastSetFrameNumber = FRAME_UNSET; |
| psPDumpConnectionData->bLastTransitionFailed = IMG_FALSE; |
| |
| /* |
| * Although we don't take a ref count here, handle base destruction |
| * will ensure that any resource that might trigger us to do a |
| * Transition will have been freed before the sync blocks which |
| * are keeping the sync connection data alive. |
| */ |
| psPDumpConnectionData->psSyncConnectionData = psSyncConnectionData; |
| *ppsPDumpConnectionData = psPDumpConnectionData; |
| |
| return PVRSRV_OK; |
| |
| fail_lockcreate: |
| OSFreeMem(psPDumpConnectionData); |
| fail_alloc: |
| PVR_ASSERT(eError != PVRSRV_OK); |
| return eError; |
| } |
| |
| void PDumpUnregisterConnection(PDUMP_CONNECTION_DATA *psPDumpConnectionData) |
| { |
| _PDumpConnectionRelease(psPDumpConnectionData); |
| } |
| |
| |
| |
| #else /* defined(PDUMP) */ |
| /* disable warning about empty module */ |
| #ifdef _WIN32 |
| #pragma warning (disable:4206) |
| #endif |
| #endif /* defined(PDUMP) */ |
| /***************************************************************************** |
| End of file (pdump_common.c) |
| *****************************************************************************/ |
