| /*************************************************************************/ /*! |
| @File |
| @Title MMU PDump functions |
| @Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved |
| @Description Common PDump (MMU specific) functions |
| @License Dual MIT/GPLv2 |
| |
| The contents of this file are subject to the MIT license as set out below. |
| |
| Permission is hereby granted, free of charge, to any person obtaining a copy |
| of this software and associated documentation files (the "Software"), to deal |
| in the Software without restriction, including without limitation the rights |
| to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| copies of the Software, and to permit persons to whom the Software is |
| furnished to do so, subject to the following conditions: |
| |
| The above copyright notice and this permission notice shall be included in |
| all copies or substantial portions of the Software. |
| |
| Alternatively, the contents of this file may be used under the terms of |
| the GNU General Public License Version 2 ("GPL") in which case the provisions |
| of GPL are applicable instead of those above. |
| |
| If you wish to allow use of your version of this file only under the terms of |
| GPL, and not to allow others to use your version of this file under the terms |
| of the MIT license, indicate your decision by deleting the provisions above |
| and replace them with the notice and other provisions required by GPL as set |
| out in the file called "GPL-COPYING" included in this distribution. If you do |
| not delete the provisions above, a recipient may use your version of this file |
| under the terms of either the MIT license or GPL. |
| |
| This License is also included in this distribution in the file called |
| "MIT-COPYING". |
| |
| EXCEPT AS OTHERWISE STATED IN A NEGOTIATED AGREEMENT: (A) THE SOFTWARE IS |
| PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING |
| BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR |
| PURPOSE AND NONINFRINGEMENT; AND (B) IN NO EVENT SHALL THE AUTHORS OR |
| COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER |
| IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ /***************************************************************************/ |
| |
| #if defined (PDUMP) |
| |
| #include "img_types.h" |
| #include "pdump_mmu.h" |
| #include "pdump_osfunc.h" |
| #include "pdump_km.h" |
| #include "pdump_physmem.h" |
| #include "osfunc.h" |
| #include "pvr_debug.h" |
| #include "pvrsrv_error.h" |
| |
| #define MAX_PDUMP_MMU_CONTEXTS (10) |
| static IMG_UINT32 guiPDumpMMUContextAvailabilityMask = (1<<MAX_PDUMP_MMU_CONTEXTS)-1; |
| |
| |
| #define MMUPX_FMT(X) ((X<3) ? ((X<2) ? "MMUPT_\0" : "MMUPD_\0") : "MMUPC_\0") |
| #define MIPSMMUPX_FMT(X) ((X<3) ? ((X<2) ? "MIPSMMUPT_\0" : "MIPSMMUPD_\0") : "MIPSMMUPC_\0") |
| |
| |
| /* Array used to look-up debug strings from MMU_LEVEL */ |
| static IMG_CHAR ai8MMULevelStringLookup[MMU_LEVEL_LAST][15] = |
| { |
| "MMU_LEVEL_0", |
| "PAGE_TABLE", |
| "PAGE_DIRECTORY", |
| "PAGE_CATALOGUE", |
| }; |
| |
| static PVRSRV_ERROR |
| _ContiguousPDumpBytes(const IMG_CHAR *pszSymbolicName, |
| IMG_UINT32 ui32SymAddrOffset, |
| IMG_BOOL bFlush, |
| IMG_UINT32 uiNumBytes, |
| void *pvBytes, |
| IMG_UINT32 ui32Flags) |
| { |
| static const IMG_CHAR *pvBeyondLastPointer; |
| static const IMG_CHAR *pvBasePointer; |
| static IMG_UINT32 ui32BeyondLastOffset; |
| static IMG_UINT32 ui32BaseOffset; |
| static IMG_UINT32 uiAccumulatedBytes = 0; |
| IMG_UINT32 ui32ParamOutPos; |
| PVRSRV_ERROR eErr = PVRSRV_OK; |
| |
| PDUMP_GET_SCRIPT_AND_FILE_STRING(); |
| PVR_UNREFERENCED_PARAMETER(ui32MaxLenFileName); |
| |
| /* Caller has PDUMP_LOCK */ |
| |
| if (!bFlush && uiAccumulatedBytes > 0) |
| { |
| /* do some tests for contiguity. If it fails, we flush anyway */ |
| |
| if (pvBeyondLastPointer != pvBytes || |
| ui32SymAddrOffset != ui32BeyondLastOffset |
| /* NB: ought to check that symbolic name agrees too, but |
| we know this always to be the case in the current use-case */ |
| ) |
| { |
| bFlush = IMG_TRUE; |
| } |
| } |
| |
| /* Flush if necessary */ |
| if (bFlush && uiAccumulatedBytes > 0) |
| { |
| eErr = PDumpWriteParameter((IMG_UINT8 *)(uintptr_t)pvBasePointer, |
| uiAccumulatedBytes, ui32Flags, |
| &ui32ParamOutPos, pszFileName); |
| if (eErr == PVRSRV_OK) |
| { |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLenScript, |
| "LDB %s:0x%X 0x%X 0x%X %s", |
| /* dest */ |
| pszSymbolicName, |
| ui32BaseOffset, |
| /* size */ |
| uiAccumulatedBytes, |
| /* file offset */ |
| ui32ParamOutPos, |
| /* filename */ |
| pszFileName); |
| PVR_LOGG_IF_ERROR(eErr, "PDumpOSBufprintf", ErrOut); |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| } |
| else if (eErr != PVRSRV_ERROR_PDUMP_NOT_ALLOWED) |
| { |
| PVR_LOGG_IF_ERROR(eErr, "PDumpWriteParameter", ErrOut); |
| } |
| else |
| { |
| /* else Write to parameter file prevented under the flags and |
| * current state of the driver so skip write to script and error IF. |
| */ |
| eErr = PVRSRV_OK; |
| } |
| |
| uiAccumulatedBytes = 0; |
| } |
| |
| |
| /* Initialise offsets and pointers if necessary */ |
| if (uiAccumulatedBytes == 0) |
| { |
| ui32BaseOffset = ui32BeyondLastOffset = ui32SymAddrOffset; |
| pvBeyondLastPointer = pvBasePointer = (const IMG_CHAR *)pvBytes; |
| } |
| |
| /* Accumulate some bytes */ |
| ui32BeyondLastOffset += uiNumBytes; |
| pvBeyondLastPointer += uiNumBytes; |
| uiAccumulatedBytes += uiNumBytes; |
| |
| ErrOut: |
| return eErr; |
| } |
| |
| |
| /************************************************************************** |
| * Function Name : PDumpMMUMalloc |
| * Inputs : |
| * Outputs : |
| * Returns : PVRSRV_ERROR |
| * Description : |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpMMUMalloc(const IMG_CHAR *pszPDumpDevName, |
| MMU_LEVEL eMMULevel, |
| IMG_DEV_PHYADDR *psDevPAddr, |
| IMG_UINT32 ui32Size, |
| IMG_UINT32 ui32Align, |
| PDUMP_MMU_TYPE eMMUType) |
| { |
| PVRSRV_ERROR eErr = PVRSRV_OK; |
| IMG_UINT32 ui32Flags = PDUMP_FLAGS_CONTINUOUS; |
| IMG_UINT64 ui64SymbolicAddr; |
| IMG_CHAR *pszMMUPX; |
| |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| if (eMMULevel >= MMU_LEVEL_LAST) |
| { |
| eErr = PVRSRV_ERROR_INVALID_PARAMS; |
| goto ErrOut; |
| } |
| |
| PDUMP_LOCK(); |
| |
| /* |
| Write a comment to the PDump2 script streams indicating the memory allocation |
| */ |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "-- MALLOC :%s:%s Size=0x%08X Alignment=0x%08X DevPAddr=0x%08llX", |
| pszPDumpDevName, |
| ai8MMULevelStringLookup[eMMULevel], |
| ui32Size, |
| ui32Align, |
| psDevPAddr->uiAddr); |
| if(eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| /* |
| construct the symbolic address |
| */ |
| ui64SymbolicAddr = (IMG_UINT64)psDevPAddr->uiAddr; |
| |
| /* |
| Write to the MMU script stream indicating the memory allocation |
| */ |
| if (eMMUType == PDUMP_MMU_TYPE_MIPS_MICROAPTIV) |
| { |
| pszMMUPX = MIPSMMUPX_FMT(eMMULevel); |
| } |
| else |
| { |
| pszMMUPX = MMUPX_FMT(eMMULevel); |
| } |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "MALLOC :%s:%s%016llX 0x%X 0x%X", |
| pszPDumpDevName, |
| pszMMUPX, |
| ui64SymbolicAddr, |
| ui32Size, |
| ui32Align |
| /* don't need this sDevPAddr.uiAddr*/); |
| if(eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| ErrUnlock: |
| PDUMP_UNLOCK(); |
| ErrOut: |
| return eErr; |
| } |
| |
| |
| /************************************************************************** |
| * Function Name : PDumpMMUFree |
| * Inputs : |
| * Outputs : |
| * Returns : PVRSRV_ERROR |
| * Description : |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpMMUFree(const IMG_CHAR *pszPDumpDevName, |
| MMU_LEVEL eMMULevel, |
| IMG_DEV_PHYADDR *psDevPAddr, |
| PDUMP_MMU_TYPE eMMUType) |
| { |
| PVRSRV_ERROR eErr = PVRSRV_OK; |
| IMG_UINT64 ui64SymbolicAddr; |
| IMG_UINT32 ui32Flags = PDUMP_FLAGS_CONTINUOUS; |
| IMG_CHAR *pszMMUPX; |
| |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| if (eMMULevel >= MMU_LEVEL_LAST) |
| { |
| eErr = PVRSRV_ERROR_INVALID_PARAMS; |
| goto ErrOut; |
| } |
| |
| PDUMP_LOCK(); |
| /* |
| Write a comment to the PDUMP2 script streams indicating the memory free |
| */ |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- FREE :%s:%s", |
| pszPDumpDevName, ai8MMULevelStringLookup[eMMULevel]); |
| if(eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| /* |
| construct the symbolic address |
| */ |
| ui64SymbolicAddr = (IMG_UINT64)psDevPAddr->uiAddr; |
| |
| /* |
| Write to the MMU script stream indicating the memory free |
| */ |
| if (eMMUType == PDUMP_MMU_TYPE_MIPS_MICROAPTIV) |
| { |
| pszMMUPX = MIPSMMUPX_FMT(eMMULevel); |
| } |
| else |
| { |
| pszMMUPX = MMUPX_FMT(eMMULevel); |
| } |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "FREE :%s:%s%016llX", |
| pszPDumpDevName, |
| pszMMUPX, |
| ui64SymbolicAddr); |
| if(eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| ErrUnlock: |
| PDUMP_UNLOCK(); |
| ErrOut: |
| return eErr; |
| } |
| |
| |
| /************************************************************************** |
| * Function Name : PDumpMMUMalloc2 |
| * Inputs : |
| * Outputs : |
| * Returns : PVRSRV_ERROR |
| * Description : |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpMMUMalloc2(const IMG_CHAR *pszPDumpDevName, |
| const IMG_CHAR *pszTableType,/* PAGE_CATALOGUE, PAGE_DIRECTORY, PAGE_TABLE */ |
| const IMG_CHAR *pszSymbolicAddr, |
| IMG_UINT32 ui32Size, |
| IMG_UINT32 ui32Align) |
| { |
| PVRSRV_ERROR eErr = PVRSRV_OK; |
| IMG_UINT32 ui32Flags = PDUMP_FLAGS_CONTINUOUS; |
| |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| PDUMP_LOCK(); |
| /* |
| Write a comment to the PDump2 script streams indicating the memory allocation |
| */ |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "-- MALLOC :%s:%s Size=0x%08X Alignment=0x%08X\n", |
| pszPDumpDevName, |
| pszTableType, |
| ui32Size, |
| ui32Align); |
| if(eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| /* |
| Write to the MMU script stream indicating the memory allocation |
| */ |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "MALLOC :%s:%s 0x%X 0x%X\n", |
| pszPDumpDevName, |
| pszSymbolicAddr, |
| ui32Size, |
| ui32Align |
| /* don't need this sDevPAddr.uiAddr*/); |
| if(eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| ErrUnlock: |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| |
| /************************************************************************** |
| * Function Name : PDumpMMUFree2 |
| * Inputs : |
| * Outputs : |
| * Returns : PVRSRV_ERROR |
| * Description : |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpMMUFree2(const IMG_CHAR *pszPDumpDevName, |
| const IMG_CHAR *pszTableType,/* PAGE_CATALOGUE, PAGE_DIRECTORY, PAGE_TABLE */ |
| const IMG_CHAR *pszSymbolicAddr) |
| { |
| PVRSRV_ERROR eErr = PVRSRV_OK; |
| IMG_UINT32 ui32Flags = PDUMP_FLAGS_CONTINUOUS; |
| |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| PDUMP_LOCK(); |
| /* |
| Write a comment to the PDUMP2 script streams indicating the memory free |
| */ |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- FREE :%s:%s\n", |
| pszPDumpDevName, pszTableType); |
| if(eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| /* |
| Write to the MMU script stream indicating the memory free |
| */ |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "FREE :%s:%s\n", |
| pszPDumpDevName, |
| pszSymbolicAddr); |
| if(eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| ErrUnlock: |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| /******************************************************************************************************* |
| * Function Name : PDumpPTBaseObjectToMem64 |
| * Outputs : None |
| * Returns : PVRSRV_ERROR |
| * Description : Create a PDUMP string, which represents a memory write from the baseobject |
| * for MIPS MMU device type |
| ********************************************************************************************************/ |
| PVRSRV_ERROR PDumpPTBaseObjectToMem64(const IMG_CHAR *pszPDumpDevName, |
| PMR *psPMRDest, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffsetSource, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffsetDest, |
| IMG_UINT32 ui32Flags, |
| MMU_LEVEL eMMULevel, |
| IMG_UINT64 ui64PxSymAddr) |
| { |
| |
| IMG_CHAR aszMemspaceNameDest[PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH]; |
| IMG_CHAR aszSymbolicNameDest[PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH]; |
| IMG_DEVMEM_OFFSET_T uiPDumpSymbolicOffsetDest; |
| IMG_DEVMEM_OFFSET_T uiNextSymNameDest; |
| PVRSRV_ERROR eErr = PVRSRV_OK; |
| |
| |
| PDUMP_GET_SCRIPT_STRING() |
| |
| 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%016llX:0x%llX",aszMemspaceNameDest, aszSymbolicNameDest, |
| uiPDumpSymbolicOffsetDest, pszPDumpDevName, MIPSMMUPX_FMT(eMMULevel), ui64PxSymAddr, |
| (IMG_UINT64)0); |
| |
| |
| if (eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| PDUMP_UNLOCK(); |
| |
| return PVRSRV_OK; |
| } |
| |
| |
| |
| /************************************************************************** |
| * Function Name : PDumpMMUDumpPxEntries |
| * Inputs : |
| * Outputs : |
| * Returns : PVRSRV_ERROR |
| * Description : |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpMMUDumpPxEntries(MMU_LEVEL eMMULevel, |
| const IMG_CHAR *pszPDumpDevName, |
| void *pvPxMem, |
| IMG_DEV_PHYADDR sPxDevPAddr, |
| IMG_UINT32 uiFirstEntry, |
| IMG_UINT32 uiNumEntries, |
| const IMG_CHAR *pszMemspaceName, |
| const IMG_CHAR *pszSymbolicAddr, |
| IMG_UINT64 uiSymbolicAddrOffset, |
| IMG_UINT32 uiBytesPerEntry, |
| IMG_UINT32 uiLog2Align, |
| IMG_UINT32 uiAddrShift, |
| IMG_UINT64 uiAddrMask, |
| IMG_UINT64 uiPxEProtMask, |
| IMG_UINT64 uiDataValidEnable, |
| IMG_UINT32 ui32Flags, |
| PDUMP_MMU_TYPE eMMUType) |
| { |
| PVRSRV_ERROR eErr = PVRSRV_OK; |
| IMG_UINT64 ui64PxSymAddr; |
| IMG_UINT64 ui64PxEValueSymAddr; |
| IMG_UINT32 ui32SymAddrOffset = 0; |
| IMG_UINT32 *pui32PxMem; |
| IMG_UINT64 *pui64PxMem; |
| IMG_BOOL bPxEValid; |
| IMG_UINT32 uiPxEIdx; |
| IMG_INT32 iShiftAmount; |
| IMG_CHAR *pszWrwSuffix = 0; |
| void *pvRawBytes = 0; |
| IMG_CHAR aszPxSymbolicAddr[PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH]; |
| IMG_UINT64 ui64PxE64; |
| IMG_UINT64 ui64Protflags64; |
| IMG_CHAR *pszMMUPX; |
| |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| if (!PDumpReady()) |
| { |
| eErr = PVRSRV_ERROR_PDUMP_NOT_AVAILABLE; |
| goto ErrOut; |
| } |
| |
| |
| if (PDumpIsDumpSuspended()) |
| { |
| eErr = PVRSRV_OK; |
| goto ErrOut; |
| } |
| |
| if (pvPxMem == NULL) |
| { |
| eErr = PVRSRV_ERROR_INVALID_PARAMS; |
| goto ErrOut; |
| } |
| |
| |
| /* |
| create the symbolic address of the Px |
| */ |
| ui64PxSymAddr = sPxDevPAddr.uiAddr; |
| |
| if (eMMUType == PDUMP_MMU_TYPE_MIPS_MICROAPTIV) |
| { |
| pszMMUPX = MIPSMMUPX_FMT(eMMULevel); |
| } |
| else |
| { |
| pszMMUPX = MMUPX_FMT(eMMULevel); |
| } |
| OSSNPrintf(aszPxSymbolicAddr, |
| PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH, |
| ":%s:%s%016llX", |
| pszPDumpDevName, |
| pszMMUPX, |
| ui64PxSymAddr); |
| |
| PDUMP_LOCK(); |
| |
| /* |
| traverse PxEs, dumping entries |
| */ |
| for(uiPxEIdx = uiFirstEntry; |
| uiPxEIdx < uiFirstEntry + uiNumEntries; |
| uiPxEIdx++) |
| { |
| /* Calc the symbolic address offset of the PxE location |
| This is what we have to add to the table address to get to a certain entry */ |
| ui32SymAddrOffset = (uiPxEIdx*uiBytesPerEntry); |
| |
| /* Calc the symbolic address of the PxE value and HW protflags */ |
| /* just read it here */ |
| switch(uiBytesPerEntry) |
| { |
| case 4: |
| { |
| pui32PxMem = pvPxMem; |
| ui64PxE64 = pui32PxMem[uiPxEIdx]; |
| pszWrwSuffix = ""; |
| pvRawBytes = &pui32PxMem[uiPxEIdx]; |
| break; |
| } |
| case 8: |
| { |
| pui64PxMem = pvPxMem; |
| ui64PxE64 = pui64PxMem[uiPxEIdx]; |
| pszWrwSuffix = "64"; |
| pvRawBytes = &pui64PxMem[uiPxEIdx]; |
| break; |
| } |
| default: |
| { |
| PVR_DPF((PVR_DBG_ERROR, "PDumpMMUPxEntries: error")); |
| ui64PxE64 = 0; |
| //!!error |
| break; |
| } |
| } |
| |
| ui64PxEValueSymAddr = (ui64PxE64 & uiAddrMask) >> uiAddrShift << uiLog2Align; |
| ui64Protflags64 = ui64PxE64 & uiPxEProtMask; |
| bPxEValid = (ui64Protflags64 & uiDataValidEnable) ? IMG_TRUE : IMG_FALSE; |
| if(bPxEValid) |
| { |
| _ContiguousPDumpBytes(aszPxSymbolicAddr, ui32SymAddrOffset, IMG_TRUE, |
| 0, 0, |
| ui32Flags | PDUMP_FLAGS_CONTINUOUS); |
| |
| iShiftAmount = (IMG_INT32)(uiLog2Align - uiAddrShift); |
| |
| /* First put the symbolic representation of the actual |
| address of the entry into a pdump internal register */ |
| /* MOV seemed cleaner here, since (a) it's 64-bit; (b) the |
| target is not memory. However, MOV cannot do the |
| "reference" of the symbolic address. Apparently WRW is |
| correct. */ |
| |
| if (pszSymbolicAddr == NULL) |
| { |
| pszSymbolicAddr = "none"; |
| } |
| |
| if (eMMULevel == MMU_LEVEL_1) |
| { |
| if (iShiftAmount == 0) |
| { |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "WRW%s :%s:%s%016llX:0x%08X :%s:%s:0x%llx | 0x%llX\n", |
| pszWrwSuffix, |
| /* dest */ |
| pszPDumpDevName, |
| pszMMUPX, |
| ui64PxSymAddr, |
| ui32SymAddrOffset, |
| /* src */ |
| pszMemspaceName, |
| pszSymbolicAddr, |
| uiSymbolicAddrOffset, |
| /* ORing prot flags */ |
| ui64Protflags64); |
| } |
| else |
| { |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "WRW :%s:$1 :%s:%s:0x%llx\n", |
| /* dest */ |
| pszPDumpDevName, |
| /* src */ |
| pszMemspaceName, |
| pszSymbolicAddr, |
| uiSymbolicAddrOffset); |
| } |
| } |
| else |
| { |
| if (eMMUType == PDUMP_MMU_TYPE_MIPS_MICROAPTIV) |
| { |
| pszMMUPX = MIPSMMUPX_FMT(eMMULevel - 1); |
| } |
| else |
| { |
| pszMMUPX = MMUPX_FMT(eMMULevel - 1); |
| } |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "WRW :%s:$1 :%s:%s%016llX:0x0", |
| /* dest */ |
| pszPDumpDevName, |
| /* src */ |
| pszPDumpDevName, |
| pszMMUPX, |
| ui64PxEValueSymAddr); |
| if (eMMUType == PDUMP_MMU_TYPE_MIPS_MICROAPTIV) |
| { |
| pszMMUPX = MIPSMMUPX_FMT(eMMULevel); |
| } |
| else |
| { |
| pszMMUPX = MMUPX_FMT(eMMULevel); |
| } |
| } |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS); |
| |
| /* Now shift it to the right place, if necessary: */ |
| /* Now shift that value down, by the "Align shift" |
| amount, to get it into units (ought to assert that |
| we get an integer - i.e. we don't shift any bits |
| off the bottom, don't know how to do PDUMP |
| assertions yet) and then back up by the right |
| amount to get it into the position of the field. |
| This is optimised into a single shift right by the |
| difference between the two. */ |
| if (iShiftAmount > 0) |
| { |
| /* Page X Address is specified in units larger |
| than the position in the PxE would suggest. */ |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "SHR :%s:$1 :%s:$1 0x%X", |
| /* dest */ |
| pszPDumpDevName, |
| /* src A */ |
| pszPDumpDevName, |
| /* src B */ |
| iShiftAmount); |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS); |
| } |
| else if (iShiftAmount < 0) |
| { |
| /* Page X Address is specified in units smaller |
| than the position in the PxE would suggest. */ |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "SHL :%s:$1 :%s:$1 0x%X", |
| /* dest */ |
| pszPDumpDevName, |
| /* src A */ |
| pszPDumpDevName, |
| /* src B */ |
| -iShiftAmount); |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS); |
| } |
| |
| if (eMMULevel == MMU_LEVEL_1) |
| { |
| if( iShiftAmount != 0) |
| { |
| /* Now we can "or" in the protection flags */ |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "OR :%s:$1 :%s:$1 0x%llX", |
| /* dest */ |
| pszPDumpDevName, |
| /* src A */ |
| pszPDumpDevName, |
| /* src B */ |
| ui64Protflags64); |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS); |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "WRW%s :%s:%s%016llX:0x%08X :%s:$1 ", |
| pszWrwSuffix, |
| /* dest */ |
| pszPDumpDevName, |
| pszMMUPX, |
| ui64PxSymAddr, |
| ui32SymAddrOffset, |
| /* src */ |
| pszPDumpDevName); |
| if(eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS); |
| |
| } |
| } |
| else |
| { |
| /* Now we can "or" in the protection flags */ |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "OR :%s:$1 :%s:$1 0x%llX", |
| /* dest */ |
| pszPDumpDevName, |
| /* src A */ |
| pszPDumpDevName, |
| /* src B */ |
| ui64Protflags64); |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS); |
| |
| /* Finally, we write the register into the actual PxE */ |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "WRW%s :%s:%s%016llX:0x%08X :%s:$1", |
| pszWrwSuffix, |
| /* dest */ |
| pszPDumpDevName, |
| pszMMUPX, |
| ui64PxSymAddr, |
| ui32SymAddrOffset, |
| /* src */ |
| pszPDumpDevName); |
| if(eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS); |
| } |
| } |
| else |
| { |
| /* If the entry was "invalid", simply write the actual |
| value found to the memory location */ |
| eErr = _ContiguousPDumpBytes(aszPxSymbolicAddr, ui32SymAddrOffset, IMG_FALSE, |
| uiBytesPerEntry, pvRawBytes, |
| ui32Flags | PDUMP_FLAGS_CONTINUOUS); |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| } |
| } |
| |
| /* flush out any partly accumulated stuff for LDB */ |
| _ContiguousPDumpBytes(aszPxSymbolicAddr, ui32SymAddrOffset, IMG_TRUE, |
| 0, 0, |
| ui32Flags | PDUMP_FLAGS_CONTINUOUS); |
| |
| ErrUnlock: |
| PDUMP_UNLOCK(); |
| ErrOut: |
| return eErr; |
| } |
| |
| |
| /************************************************************************** |
| * Function Name : _PdumpAllocMMUContext |
| * Inputs : pui32MMUContextID |
| * Outputs : None |
| * Returns : PVRSRV_ERROR |
| * Description : pdump util to allocate MMU contexts |
| **************************************************************************/ |
| static PVRSRV_ERROR _PdumpAllocMMUContext(IMG_UINT32 *pui32MMUContextID) |
| { |
| IMG_UINT32 i; |
| |
| /* there are MAX_PDUMP_MMU_CONTEXTS contexts available, find one */ |
| for(i=0; i<MAX_PDUMP_MMU_CONTEXTS; i++) |
| { |
| if((guiPDumpMMUContextAvailabilityMask & (1U << i))) |
| { |
| /* mark in use */ |
| guiPDumpMMUContextAvailabilityMask &= ~(1U << i); |
| *pui32MMUContextID = i; |
| return PVRSRV_OK; |
| } |
| } |
| |
| PVR_DPF((PVR_DBG_ERROR, "_PdumpAllocMMUContext: no free MMU context ids")); |
| |
| return PVRSRV_ERROR_MMU_CONTEXT_NOT_FOUND; |
| } |
| |
| |
| /************************************************************************** |
| * Function Name : _PdumpFreeMMUContext |
| * Inputs : ui32MMUContextID |
| * Outputs : None |
| * Returns : PVRSRV_ERROR |
| * Description : pdump util to free MMU contexts |
| **************************************************************************/ |
| static PVRSRV_ERROR _PdumpFreeMMUContext(IMG_UINT32 ui32MMUContextID) |
| { |
| if(ui32MMUContextID < MAX_PDUMP_MMU_CONTEXTS) |
| { |
| /* free the id */ |
| PVR_ASSERT (!(guiPDumpMMUContextAvailabilityMask & (1U << ui32MMUContextID))); |
| guiPDumpMMUContextAvailabilityMask |= (1U << ui32MMUContextID); |
| return PVRSRV_OK; |
| } |
| |
| PVR_DPF((PVR_DBG_ERROR, "_PdumpFreeMMUContext: MMU context ids invalid")); |
| |
| return PVRSRV_ERROR_MMU_CONTEXT_NOT_FOUND; |
| } |
| |
| |
| /************************************************************************** |
| * Function Name : PDumpMMUAllocMMUContext |
| * Inputs : |
| * Outputs : None |
| * Returns : PVRSRV_ERROR |
| * Description : Alloc MMU Context |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpMMUAllocMMUContext(const IMG_CHAR *pszPDumpMemSpaceName, |
| IMG_DEV_PHYADDR sPCDevPAddr, |
| PDUMP_MMU_TYPE eMMUType, |
| IMG_UINT32 *pui32MMUContextID) |
| { |
| IMG_UINT64 ui64PCSymAddr; |
| IMG_CHAR *pszMMUPX; |
| |
| IMG_UINT32 ui32MMUContextID; |
| PVRSRV_ERROR eErr = PVRSRV_OK; |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| eErr = _PdumpAllocMMUContext(&ui32MMUContextID); |
| if(eErr != PVRSRV_OK) |
| { |
| PVR_DPF((PVR_DBG_ERROR, "%s: _PdumpAllocMMUContext failed: %d", |
| __func__, eErr)); |
| PVR_DBG_BREAK; |
| goto ErrOut; |
| } |
| |
| /* |
| create the symbolic address of the PC |
| */ |
| ui64PCSymAddr = sPCDevPAddr.uiAddr; |
| |
| if (eMMUType == PDUMP_MMU_TYPE_MIPS_MICROAPTIV) |
| { |
| pszMMUPX = MIPSMMUPX_FMT(1); |
| /* Giving it a mock value until the Pdump player implements |
| the support for the MIPS microAptiv MMU*/ |
| eMMUType = PDUMP_MMU_TYPE_VARPAGE_40BIT; |
| } |
| else |
| { |
| pszMMUPX = MMUPX_FMT(3); |
| } |
| |
| PDUMP_LOCK(); |
| |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "MMU :%s:v%d %d :%s:%s%016llX", |
| /* mmu context */ |
| pszPDumpMemSpaceName, |
| ui32MMUContextID, |
| /* mmu type */ |
| eMMUType, |
| /* PC base address */ |
| pszPDumpMemSpaceName, |
| pszMMUPX, |
| ui64PCSymAddr); |
| if(eErr != PVRSRV_OK) |
| { |
| PDUMP_UNLOCK(); |
| PVR_DBG_BREAK; |
| goto ErrOut; |
| } |
| |
| PDumpWriteScript(hScript, PDUMP_FLAGS_CONTINUOUS); |
| PDUMP_UNLOCK(); |
| |
| /* return the MMU Context ID */ |
| *pui32MMUContextID = ui32MMUContextID; |
| |
| ErrOut: |
| return eErr; |
| } |
| |
| |
| /************************************************************************** |
| * Function Name : PDumpMMUFreeMMUContext |
| * Inputs : |
| * Outputs : None |
| * Returns : PVRSRV_ERROR |
| * Description : Free MMU Context |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpMMUFreeMMUContext(const IMG_CHAR *pszPDumpMemSpaceName, |
| IMG_UINT32 ui32MMUContextID) |
| { |
| PVRSRV_ERROR eErr = PVRSRV_OK; |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| PDUMP_LOCK(); |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "-- Clear MMU Context for memory space %s", pszPDumpMemSpaceName); |
| if(eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| |
| PDumpWriteScript(hScript, PDUMP_FLAGS_CONTINUOUS); |
| |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "MMU :%s:v%d", |
| pszPDumpMemSpaceName, |
| ui32MMUContextID); |
| if(eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| |
| PDumpWriteScript(hScript, PDUMP_FLAGS_CONTINUOUS); |
| |
| eErr = _PdumpFreeMMUContext(ui32MMUContextID); |
| if(eErr != PVRSRV_OK) |
| { |
| PVR_DPF((PVR_DBG_ERROR, "%s: _PdumpFreeMMUContext failed: %d", |
| __func__, eErr)); |
| goto ErrUnlock; |
| } |
| |
| ErrUnlock: |
| PDUMP_UNLOCK(); |
| return eErr; |
| } |
| |
| |
| /************************************************************************** |
| * Function Name : PDumpMMUActivateCatalog |
| * Inputs : |
| * Outputs : |
| * Returns : PVRSRV_ERROR |
| * Description : |
| **************************************************************************/ |
| PVRSRV_ERROR PDumpMMUActivateCatalog(const IMG_CHAR *pszPDumpRegSpaceName, |
| const IMG_CHAR *pszPDumpRegName, |
| IMG_UINT32 uiRegAddr, |
| const IMG_CHAR *pszPDumpPCSymbolicName) |
| { |
| IMG_UINT32 ui32Flags = PDUMP_FLAGS_CONTINUOUS; |
| PVRSRV_ERROR eErr = PVRSRV_OK; |
| |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| if (!PDumpReady()) |
| { |
| eErr = PVRSRV_ERROR_PDUMP_NOT_AVAILABLE; |
| goto ErrOut; |
| } |
| |
| |
| if (PDumpIsDumpSuspended()) |
| { |
| goto ErrOut; |
| } |
| |
| PDUMP_LOCK(); |
| |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, |
| "-- Write Page Catalogue Address to %s", |
| pszPDumpRegName); |
| if(eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "WRW :%s:0x%04X %s:0", |
| /* dest */ |
| pszPDumpRegSpaceName, |
| uiRegAddr, |
| /* src */ |
| pszPDumpPCSymbolicName); |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS); |
| |
| ErrUnlock: |
| PDUMP_UNLOCK(); |
| ErrOut: |
| return eErr; |
| } |
| |
| |
| PVRSRV_ERROR |
| PDumpMMUSAB(const IMG_CHAR *pszPDumpMemNamespace, |
| IMG_UINT32 uiPDumpMMUCtx, |
| IMG_DEV_VIRTADDR sDevAddrStart, |
| IMG_DEVMEM_SIZE_T uiSize, |
| const IMG_CHAR *pszFilename, |
| IMG_UINT32 uiFileOffset, |
| IMG_UINT32 ui32PDumpFlags) |
| { |
| PVRSRV_ERROR eErr = PVRSRV_OK; |
| |
| // "SAB :%s:v%x:0x%010llX 0x%08X 0x%08X %s.bin", |
| |
| PDUMP_GET_SCRIPT_STRING(); |
| |
| if (!PDumpReady()) |
| { |
| eErr = PVRSRV_ERROR_PDUMP_NOT_AVAILABLE; |
| goto ErrOut; |
| } |
| |
| |
| if (PDumpIsDumpSuspended()) |
| { |
| eErr = PVRSRV_OK; |
| goto ErrOut; |
| } |
| |
| PDUMP_LOCK(); |
| |
| eErr = PDumpOSBufprintf(hScript, |
| ui32MaxLen, |
| "SAB :%s:v%x:" IMG_DEV_VIRTADDR_FMTSPEC " " |
| IMG_DEVMEM_SIZE_FMTSPEC " " |
| "0x%x %s.bin\n", |
| pszPDumpMemNamespace, |
| uiPDumpMMUCtx, |
| sDevAddrStart.uiAddr, |
| uiSize, |
| uiFileOffset, |
| pszFilename); |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| |
| PDumpWriteScript(hScript, ui32PDumpFlags); |
| |
| ErrUnlock: |
| PDUMP_UNLOCK(); |
| ErrOut: |
| return eErr; |
| } |
| |
| /************************************************************************** |
| * Function Name : PdumpWireUpMipsTLB |
| **************************************************************************/ |
| PVRSRV_ERROR PdumpWireUpMipsTLB(PMR *psPMRSource, |
| PMR *psPMRDest, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffsetSource, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffsetDest, |
| IMG_UINT32 ui32AllocationFlags, |
| IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr = PVRSRV_OK; |
| 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() |
| |
| eErr = PMR_PDumpSymbolicAddr(psPMRSource, |
| uiLogicalOffsetSource, |
| PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH, |
| aszMemspaceNameSource, |
| PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH, |
| aszSymbolicNameSource, |
| &uiPDumpSymbolicOffsetSource, |
| &uiNextSymNameSource); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrOut; |
| } |
| |
| eErr = PMR_PDumpSymbolicAddr(psPMRDest, |
| uiLogicalOffsetDest, |
| PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH, |
| aszMemspaceNameDest, |
| PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH, |
| aszSymbolicNameDest, |
| &uiPDumpSymbolicOffsetDest, |
| &uiNextSymNameDest); |
| |
| |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrOut; |
| } |
| |
| PDUMP_LOCK(); |
| |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW :%s:$1 :%s:%s:0x%llX", aszMemspaceNameSource, |
| aszMemspaceNameSource, aszSymbolicNameSource, |
| uiPDumpSymbolicOffsetSource); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "SHR :%s:$1 :%s:$1 0x6", aszMemspaceNameSource, |
| aszMemspaceNameSource); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "AND :%s:$1 :%s:$1 0x03FFFFC0", aszMemspaceNameSource, |
| aszMemspaceNameSource); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "OR :%s:$1 :%s:$1 0x%X", aszMemspaceNameSource, |
| aszMemspaceNameSource, ui32AllocationFlags); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW :%s:%s:0x%llX :%s:$1",aszMemspaceNameDest, aszSymbolicNameDest, |
| uiPDumpSymbolicOffsetDest, aszMemspaceNameSource); |
| |
| |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| ErrUnlock: |
| PDUMP_UNLOCK(); |
| ErrOut: |
| return eErr; |
| } |
| |
| /************************************************************************** |
| * Function Name : PdumpInvalidateMipsTLB |
| **************************************************************************/ |
| PVRSRV_ERROR PdumpInvalidateMipsTLB(PMR *psPMRDest, |
| IMG_DEVMEM_OFFSET_T uiLogicalOffsetDest, |
| IMG_UINT32 ui32MipsTLBValidClearMask, |
| IMG_UINT32 ui32Flags) |
| { |
| PVRSRV_ERROR eErr = PVRSRV_OK; |
| IMG_CHAR aszMemspaceNameDest[PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH]; |
| IMG_CHAR aszSymbolicNameDest[PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH]; |
| IMG_DEVMEM_OFFSET_T uiPDumpSymbolicOffsetDest; |
| IMG_DEVMEM_OFFSET_T uiNextSymNameDest; |
| |
| |
| PDUMP_GET_SCRIPT_STRING() |
| |
| eErr = PMR_PDumpSymbolicAddr(psPMRDest, |
| uiLogicalOffsetDest, |
| PHYSMEM_PDUMP_MEMSPACE_MAX_LENGTH, |
| aszMemspaceNameDest, |
| PHYSMEM_PDUMP_SYMNAME_MAX_LENGTH, |
| aszSymbolicNameDest, |
| &uiPDumpSymbolicOffsetDest, |
| &uiNextSymNameDest); |
| |
| |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrOut; |
| } |
| |
| PDUMP_LOCK(); |
| |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW :%s:$1 :%s:%s:0x%llX", aszMemspaceNameDest, |
| aszMemspaceNameDest, aszSymbolicNameDest, |
| uiPDumpSymbolicOffsetDest); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "AND :%s:$1 :%s:$1 0x%X", aszMemspaceNameDest, |
| aszMemspaceNameDest, ui32MipsTLBValidClearMask); |
| |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| |
| |
| eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW :%s:%s:0x%llX :%s:$1",aszMemspaceNameDest, aszSymbolicNameDest, |
| uiPDumpSymbolicOffsetDest, aszMemspaceNameDest); |
| |
| |
| if (eErr != PVRSRV_OK) |
| { |
| goto ErrUnlock; |
| } |
| PDumpWriteScript(hScript, ui32Flags); |
| |
| |
| ErrUnlock: |
| PDUMP_UNLOCK(); |
| ErrOut: |
| return eErr; |
| } |
| |
| |
| #endif /* #if defined (PDUMP) */ |
| |
