/**************************************************************************
* 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;
PDUMP_GET_SCRIPT_STRING();
ui32Flags |= ( PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;
if (!PDumpOSJTInitialised())
{
return PVRSRV_ERROR_PDUMP_NOT_AVAILABLE;
}
if (PDumpOSIsSuspended())
{
return PVRSRV_OK;
}
eErr = PDumpOSBufprintf(hScript, ui32MaxLen,
"-- Write Page Catalogue Address to %s",
pszPDumpRegName);
if(eErr != PVRSRV_OK)
{
goto ErrOut;
}
PDUMP_LOCK();
PDumpOSWriteString2(hScript, ui32Flags);
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"WRW :%s:0x%04X %s:0",
/* dest */
pszPDumpRegSpaceName,
uiRegAddr,
/* src */
pszPDumpPCSymbolicName);
if (eErr != PVRSRV_OK)
{
goto ErrUnlock;
}
PDumpOSWriteString2(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 eError;
// "SAB :%s:v%x:0x%010llX 0x%08X 0x%08X %s.bin",
PDUMP_GET_SCRIPT_STRING();
ui32PDumpFlags |= ( PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;
if (!PDumpOSJTInitialised())
{
eError = PVRSRV_ERROR_PDUMP_NOT_AVAILABLE;
goto ErrOut;
}
if (PDumpOSIsSuspended())
{
eError = PVRSRV_OK;
goto ErrOut;
}
eError = 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);
PVR_ASSERT(eError == PVRSRV_OK);
PDUMP_LOCK();
PDumpOSWriteString2(hScript, ui32PDumpFlags);
PDUMP_UNLOCK();
ErrOut:
return eError;
}
PVRSRV_ERROR PDumpMem2KM(PVRSRV_DEVICE_TYPE eDeviceType,
IMG_CPU_VIRTADDR pvLinAddr,
u32 ui32Bytes,
u32 ui32Flags,
int bInitialisePages,
void *hUniqueTag1, void *hUniqueTag2)
{
PVRSRV_ERROR eErr;
u32 ui32NumPages;
u32 ui32PageOffset;
u32 ui32BlockBytes;
u8 *pui8LinAddr;
IMG_DEV_PHYADDR sDevPAddr;
IMG_CPU_PHYADDR sCpuPAddr;
u32 ui32Offset;
u32 ui32ParamOutPos;
PDUMP_GET_SCRIPT_AND_FILE_STRING();
if (!pvLinAddr || !PDumpOSJTInitialised()) {
return PVRSRV_ERROR_GENERIC;
}
if (PDumpOSIsSuspended()) {
return PVRSRV_OK;
}
PDumpOSCheckForSplitting(PDumpOSGetStream(PDUMP_STREAM_PARAM2),
ui32Bytes, ui32Flags);
ui32ParamOutPos = PDumpOSGetStreamOffset(PDUMP_STREAM_PARAM2);
if (bInitialisePages) {
if (!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_PARAM2),
pvLinAddr,
ui32Bytes, PDUMP_FLAGS_CONTINUOUS)) {
return PVRSRV_ERROR_GENERIC;
}
if (PDumpOSGetParamFileNum() == 0) {
eErr =
PDumpOSSprintf(pszFileName, ui32MaxLenFileName,
"%%0%%.prm");
} else {
eErr =
PDumpOSSprintf(pszFileName, ui32MaxLenFileName,
"%%0%%%lu.prm",
PDumpOSGetParamFileNum());
}
if (eErr != PVRSRV_OK) {
return eErr;
}
}
ui32PageOffset = (u32) pvLinAddr & (HOST_PAGESIZE() - 1);
ui32NumPages =
(ui32PageOffset + ui32Bytes + HOST_PAGESIZE() -
1) / HOST_PAGESIZE();
pui8LinAddr = (u8 *) pvLinAddr;
while (ui32NumPages) {
ui32NumPages--;
sCpuPAddr = OSMapLinToCPUPhys(pui8LinAddr);
sDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
if (ui32PageOffset + ui32Bytes > HOST_PAGESIZE()) {
ui32BlockBytes = HOST_PAGESIZE() - ui32PageOffset;
} else {
ui32BlockBytes = ui32Bytes;
}
if (bInitialisePages) {
eErr = PDumpOSBufprintf(hScript,
ui32MaxLenScript,
"LDB :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX %s\r\n",
(u32) hUniqueTag1,
sDevPAddr.
uiAddr & ~(SGX_MMU_PAGE_MASK),
sDevPAddr.
uiAddr & (SGX_MMU_PAGE_MASK),
ui32BlockBytes, ui32ParamOutPos,
pszFileName);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
} else {
for (ui32Offset = 0; ui32Offset < ui32BlockBytes;
ui32Offset += sizeof(u32)) {
u32 ui32PTE =
*((u32 *) (pui8LinAddr + ui32Offset));
if ((ui32PTE & SGX_MMU_PDE_ADDR_MASK) != 0) {
#if defined(SGX_FEATURE_36BIT_MMU)
eErr = PDumpOSBufprintf(hScript,
ui32MaxLenScript,
"WRW :SGXMEM:$1 :SGXMEM:PA_%8.8lX%8.8lX:0x0\r\n",
(u32)
hUniqueTag2,
(ui32PTE &
SGX_MMU_PDE_ADDR_MASK)
<<
SGX_MMU_PTE_ADDR_ALIGNSHIFT);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript,
PDUMP_FLAGS_CONTINUOUS);
eErr =
PDumpOSBufprintf(hScript,
ui32MaxLenScript,
"SHR :SGXMEM:$1 :SGXMEM:$1 0x4\r\n");
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript,
PDUMP_FLAGS_CONTINUOUS);
eErr =
PDumpOSBufprintf(hScript,
ui32MaxLenScript,
"OR :SGXMEM:$1 :SGXMEM:$1 0x%8.8lX\r\n",
ui32PTE &
~SGX_MMU_PDE_ADDR_MASK);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript,
PDUMP_FLAGS_CONTINUOUS);
eErr =
PDumpOSBufprintf(hScript,
ui32MaxLenScript,
"WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX :SGXMEM:$1\r\n",
(u32) hUniqueTag1,
(sDevPAddr.uiAddr +
ui32Offset) &
~
(SGX_MMU_PAGE_MASK),
(sDevPAddr.uiAddr +
ui32Offset) &
(SGX_MMU_PAGE_MASK));
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript,
PDUMP_FLAGS_CONTINUOUS);
#else
eErr = PDumpOSBufprintf(hScript,
ui32MaxLenScript,
"WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX\r\n",
(u32)
hUniqueTag1,
(sDevPAddr.
uiAddr +
ui32Offset) &
~
(SGX_MMU_PAGE_MASK),
(sDevPAddr.
uiAddr +
ui32Offset) &
(SGX_MMU_PAGE_MASK),
(u32)
hUniqueTag2,
(ui32PTE &
SGX_MMU_PDE_ADDR_MASK)
<<
SGX_MMU_PTE_ADDR_ALIGNSHIFT,
ui32PTE &
~SGX_MMU_PDE_ADDR_MASK);
if (eErr != PVRSRV_OK) {
return eErr;
}
#endif
} else {
PVR_ASSERT((ui32PTE & SGX_MMU_PTE_VALID)
== 0UL);
eErr =
PDumpOSBufprintf(hScript,
ui32MaxLenScript,
"WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX%8.8lX\r\n",
(u32) hUniqueTag1,
(sDevPAddr.uiAddr +
ui32Offset) &
~
(SGX_MMU_PAGE_MASK),
(sDevPAddr.uiAddr +
ui32Offset) &
(SGX_MMU_PAGE_MASK),
(ui32PTE <<
SGX_MMU_PTE_ADDR_ALIGNSHIFT),
(u32) hUniqueTag2);
if (eErr != PVRSRV_OK) {
return eErr;
}
}
PDumpOSWriteString2(hScript,
PDUMP_FLAGS_CONTINUOUS);
}
}
ui32PageOffset = 0;
ui32Bytes -= ui32BlockBytes;
pui8LinAddr += ui32BlockBytes;
ui32ParamOutPos += ui32BlockBytes;
}
return PVRSRV_OK;
}
PVRSRV_ERROR PDumpMemKM(void *pvAltLinAddr,
PVRSRV_KERNEL_MEM_INFO * psMemInfo,
u32 ui32Offset,
u32 ui32Bytes, u32 ui32Flags, void *hUniqueTag)
{
PVRSRV_ERROR eErr;
u32 ui32NumPages;
u32 ui32PageByteOffset;
u32 ui32BlockBytes;
u8 *pui8LinAddr;
u8 *pui8DataLinAddr = NULL;
IMG_DEV_VIRTADDR sDevVPageAddr;
IMG_DEV_VIRTADDR sDevVAddr;
IMG_DEV_PHYADDR sDevPAddr;
u32 ui32ParamOutPos;
PDUMP_GET_SCRIPT_AND_FILE_STRING();
PVR_ASSERT((ui32Offset + ui32Bytes) <= psMemInfo->ui32AllocSize);
if (!PDumpOSJTInitialised()) {
return PVRSRV_ERROR_GENERIC;
}
if (ui32Bytes == 0 || PDumpOSIsSuspended()) {
return PVRSRV_OK;
}
if (pvAltLinAddr) {
pui8DataLinAddr = pvAltLinAddr;
} else if (psMemInfo->pvLinAddrKM) {
pui8DataLinAddr = (u8 *) psMemInfo->pvLinAddrKM + ui32Offset;
}
pui8LinAddr = (u8 *) psMemInfo->pvLinAddrKM;
sDevVAddr = psMemInfo->sDevVAddr;
sDevVAddr.uiAddr += ui32Offset;
pui8LinAddr += ui32Offset;
PVR_ASSERT(pui8DataLinAddr);
PDumpOSCheckForSplitting(PDumpOSGetStream(PDUMP_STREAM_PARAM2),
ui32Bytes, ui32Flags);
ui32ParamOutPos = PDumpOSGetStreamOffset(PDUMP_STREAM_PARAM2);
if (!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_PARAM2),
pui8DataLinAddr, ui32Bytes, ui32Flags)) {
return PVRSRV_ERROR_GENERIC;
}
if (PDumpOSGetParamFileNum() == 0) {
eErr =
PDumpOSSprintf(pszFileName, ui32MaxLenFileName,
"%%0%%.prm");
} else {
eErr =
PDumpOSSprintf(pszFileName, ui32MaxLenFileName,
"%%0%%%lu.prm", PDumpOSGetParamFileNum());
}
if (eErr != PVRSRV_OK) {
return eErr;
}
eErr = PDumpOSBufprintf(hScript,
ui32MaxLenScript,
"-- LDB :SGXMEM:VA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX %s\r\n",
(u32) hUniqueTag,
psMemInfo->sDevVAddr.uiAddr,
ui32Offset,
ui32Bytes, ui32ParamOutPos, pszFileName);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, ui32Flags);
PDumpOSCPUVAddrToPhysPages(psMemInfo->sMemBlk.hOSMemHandle,
ui32Offset,
pui8LinAddr, &ui32PageByteOffset);
ui32NumPages =
(ui32PageByteOffset + ui32Bytes + HOST_PAGESIZE() -
1) / HOST_PAGESIZE();
while (ui32NumPages) {
#if 0
u32 ui32BlockBytes = MIN(ui32BytesRemaining, PAGE_SIZE);
CpuPAddr =
OSMemHandleToCpuPAddr(psMemInfo->sMemBlk.hOSMemHandle,
ui32CurrentOffset);
#endif
ui32NumPages--;
sDevVPageAddr.uiAddr = sDevVAddr.uiAddr - ui32PageByteOffset;
PVR_ASSERT((sDevVPageAddr.uiAddr & 0xFFF) == 0);
BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
sDevPAddr.uiAddr += ui32PageByteOffset;
#if 0
if (ui32PageByteOffset) {
ui32BlockBytes =
MIN(ui32BytesRemaining,
PAGE_ALIGN(CpuPAddr.uiAddr) - CpuPAddr.uiAddr);
ui32PageByteOffset = 0;
}
#endif
if (ui32PageByteOffset + ui32Bytes > HOST_PAGESIZE()) {
ui32BlockBytes = HOST_PAGESIZE() - ui32PageByteOffset;
} else {
ui32BlockBytes = ui32Bytes;
}
eErr = PDumpOSBufprintf(hScript,
ui32MaxLenScript,
"LDB :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX %s\r\n",
(u32) hUniqueTag,
sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_MASK),
sDevPAddr.uiAddr & (SGX_MMU_PAGE_MASK),
ui32BlockBytes,
ui32ParamOutPos, pszFileName);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, ui32Flags);
ui32PageByteOffset = 0;
ui32Bytes -= ui32BlockBytes;
sDevVAddr.uiAddr += ui32BlockBytes;
pui8LinAddr += ui32BlockBytes;
ui32ParamOutPos += ui32BlockBytes;
}
return PVRSRV_OK;
}
/**************************************************************************
* Function Name : PDumpMMUDumpPxEntries
* Inputs :
* Outputs :
* Returns : PVRSRV_ERROR
* Description :
**************************************************************************/
PVRSRV_ERROR PDumpMMUDumpPxEntries(MMU_LEVEL eMMULevel,
const IMG_CHAR *pszPDumpDevName,
IMG_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_UINT32 ui32Flags)
{
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;
IMG_VOID *pvRawBytes = 0;
IMG_CHAR aszPxSymbolicAddr[MAX_SYMBOLIC_ADDRESS_LENGTH];
IMG_UINT64 ui64PxE64;
IMG_UINT64 ui64Protflags64;
PDUMP_GET_SCRIPT_STRING();
ui32Flags |= ( PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;
if (!PDumpOSJTInitialised())
{
eErr = PVRSRV_ERROR_PDUMP_NOT_AVAILABLE;
goto ErrOut;
}
if (PDumpOSIsSuspended())
{
eErr = PVRSRV_OK;
goto ErrOut;
}
if (pvPxMem == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "PDUMPMMUDUMPPxENTRIES: PxMem is Null"));
eErr = PVRSRV_ERROR_INVALID_PARAMS;
goto ErrOut;
}
/*
create the symbolic address of the Px
*/
ui64PxSymAddr = sPxDevPAddr.uiAddr;
OSSNPrintf(aszPxSymbolicAddr,
MAX_SYMBOLIC_ADDRESS_LENGTH,
":%s:" MMUPT_FMT,
pszPDumpDevName,
ui64PxSymAddr);
PDUMP_LOCK();
/*
traverse PxEs, dumping entries
*/
for(uiPxEIdx = uiFirstEntry;
uiPxEIdx < uiFirstEntry + uiNumEntries;
uiPxEIdx++)
{
/* Calc the symbolic address offset of the PxE location */
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 & 1) ? 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 == IMG_NULL)
{
pszSymbolicAddr = "none";
}
if (eMMULevel == MMU_LEVEL_1)
{
if (iShiftAmount == 0)
{
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"WRW%s :%s:" MMUPT_FMT ":0x%08X :%s:%s:0x%llx | 0x%llX\n",
pszWrwSuffix,
/* dest */
pszPDumpDevName,
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
{
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"WRW :%s:$1 :%s:" MMUPT_FMT ":0x0",
/* dest */
pszPDumpDevName,
/* src */
pszPDumpDevName,
ui64PxEValueSymAddr);
}
if (eErr != PVRSRV_OK)
{
goto ErrUnlock;
}
PDumpOSWriteString2(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;
}
PDumpOSWriteString2(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;
}
PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);
}
if (eMMULevel == MMU_LEVEL_1)
{
if( iShiftAmount != 0)
{
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"WRW%s :%s:" MMUPT_FMT ":0x%08X :%s:$1 | 0x%llX",
pszWrwSuffix,
/* dest */
pszPDumpDevName,
ui64PxSymAddr,
ui32SymAddrOffset,
/* src */
pszPDumpDevName,
/* ORing prot flags */
ui64Protflags64);
if(eErr != PVRSRV_OK)
{
goto ErrUnlock;
}
PDumpOSWriteString2(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;
}
PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);
/* Finally, we write the register into the actual PxE */
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"WRW%s :%s:" MMUPT_FMT ":0x%08X :%s:$1",
pszWrwSuffix,
/* dest */
pszPDumpDevName,
ui64PxSymAddr,
ui32SymAddrOffset,
/* src */
pszPDumpDevName);
if(eErr != PVRSRV_OK)
{
goto ErrUnlock;
}
PDumpOSWriteString2(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;
}
