PVRSRV_ERROR PDumpHWPerfCBKM(char *pszFileName,
u32 ui32FileOffset,
IMG_DEV_VIRTADDR sDevBaseAddr,
u32 ui32Size, u32 ui32PDumpFlags)
{
PVRSRV_ERROR eErr;
PDUMP_GET_SCRIPT_STRING();
PDumpCommentWithFlags(ui32PDumpFlags,
"\r\n-- Dump Hardware Performance Circular Buffer\r\n");
eErr = PDumpOSBufprintf(hScript, ui32MaxLen,
#if defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
"SAB :SGXMEM:v%x:0x%08lX 0x%08lX 0x%08lX %s.bin\r\n",
PDUMP_DATAMASTER_EDM,
#else
"SAB :SGXMEM:v:0x%08lX 0x%08lX 0x%08lX %s.bin\r\n",
#endif
sDevBaseAddr.uiAddr,
ui32Size, ui32FileOffset, pszFileName);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, ui32PDumpFlags);
return PVRSRV_OK;
}
/**************************************************************************
* Function Name : PDumpMMUFree
* Inputs :
* Outputs :
* Returns : PVRSRV_ERROR
* Description :
**************************************************************************/
PVRSRV_ERROR PDumpMMUFree(const IMG_CHAR *pszPDumpDevName,
MMU_LEVEL eMMULevel,
IMG_DEV_PHYADDR *psDevPAddr)
{
PVRSRV_ERROR eErr;
IMG_UINT64 ui64SymbolicAddr;
IMG_UINT32 ui32Flags = PDUMP_FLAGS_CONTINUOUS;
IMG_CHAR *pszMMUPX;
PDUMP_GET_SCRIPT_STRING();
ui32Flags |= ( PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;
if (eMMULevel >= MMU_LEVEL_LAST)
{
eErr = PVRSRV_ERROR_INVALID_PARAMS;
goto ErrOut;
}
/*
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 ErrOut;
}
PDumpOSLock();
PDumpWriteScript(hScript, ui32Flags);
/*
construct the symbolic address
*/
ui64SymbolicAddr = (IMG_UINT64)psDevPAddr->uiAddr;
/*
Write to the MMU script stream indicating the memory free
*/
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:
PDumpOSUnlock();
ErrOut:
return eErr;
}
/**************************************************************************
* Function Name : PDumpSetMMUContext
* Inputs :
* Outputs : None
* Returns : PVRSRV_ERROR
* Description : Set 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;
PDUMP_GET_SCRIPT_STRING();
eErr = _PdumpAllocMMUContext(&ui32MMUContextID);
if(eErr != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PDumpSetMMUContext: _PdumpAllocMMUContext failed: %d", eErr));
PVR_DBG_BREAK;
goto ErrOut;
}
/*
create the symbolic address of the PC
*/
ui64PCSymAddr = sPCDevPAddr.uiAddr;
pszMMUPX = MMUPX_FMT(3);
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)
{
PVR_DBG_BREAK;
goto ErrOut;
}
PDumpOSLock();
PDumpWriteScript(hScript, PDUMP_FLAGS_CONTINUOUS);
PDumpOSUnlock();
/* return the MMU Context ID */
*pui32MMUContextID = ui32MMUContextID;
ErrOut:
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;
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 PDumpFreePages(BM_HEAP * psBMHeap,
IMG_DEV_VIRTADDR sDevVAddr,
u32 ui32NumBytes,
u32 ui32PageSize,
void *hUniqueTag, int bInterleaved)
{
PVRSRV_ERROR eErr;
u32 ui32NumPages, ui32PageCounter;
IMG_DEV_PHYADDR sDevPAddr;
PVRSRV_DEVICE_NODE *psDeviceNode;
PDUMP_GET_SCRIPT_STRING();
PVR_ASSERT(((u32) sDevVAddr.uiAddr & (ui32PageSize - 1)) == 0);
PVR_ASSERT(((u32) ui32NumBytes & (ui32PageSize - 1)) == 0);
eErr =
PDumpOSBufprintf(hScript, ui32MaxLen,
"-- FREE :SGXMEM:VA_%8.8lX\r\n", sDevVAddr.uiAddr);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
ui32NumPages = ui32NumBytes / ui32PageSize;
psDeviceNode = psBMHeap->pBMContext->psDeviceNode;
for (ui32PageCounter = 0; ui32PageCounter < ui32NumPages;
ui32PageCounter++) {
if (!bInterleaved || (ui32PageCounter % 2) == 0) {
sDevPAddr =
psDeviceNode->pfnMMUGetPhysPageAddr(psBMHeap->
pMMUHeap,
sDevVAddr);
{
eErr =
PDumpOSBufprintf(hScript, ui32MaxLen,
"FREE :SGXMEM:PA_%8.8lX%8.8lX\r\n",
(u32) hUniqueTag,
sDevPAddr.uiAddr);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript,
PDUMP_FLAGS_CONTINUOUS);
}
} else {
}
sDevVAddr.uiAddr += ui32PageSize;
}
return PVRSRV_OK;
}
PVRSRV_ERROR PDumpIDLWithFlags(u32 ui32Clocks, u32 ui32Flags)
{
PVRSRV_ERROR eErr;
PDUMP_GET_SCRIPT_STRING();
PDUMP_DBG(("PDumpIDLWithFlags"));
eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "IDL %lu\r\n", ui32Clocks);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, ui32Flags);
return PVRSRV_OK;
}
/**************************************************************************
* 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;
IMG_UINT32 ui32Flags = PDUMP_FLAGS_CONTINUOUS;
PDUMP_GET_SCRIPT_STRING();
ui32Flags |= ( PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;
/*
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 ErrOut;
}
PDUMP_LOCK();
PDumpOSWriteString2(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;
}
PDumpOSWriteString2(hScript, ui32Flags);
ErrUnlock:
PDUMP_UNLOCK();
ErrOut:
return eErr;
}
PVRSRV_ERROR PDumpRegRead(const u32 ui32RegOffset, u32 ui32Flags)
{
PVRSRV_ERROR eErr;
PDUMP_GET_SCRIPT_STRING();
eErr =
PDumpOSBufprintf(hScript, ui32MaxLen, "RDW :SGXREG:0x%lX\r\n",
ui32RegOffset);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, ui32Flags);
return PVRSRV_OK;
}
PVRSRV_ERROR PDumpCycleCountRegRead(const u32 ui32RegOffset, int bLastFrame)
{
PVRSRV_ERROR eErr;
PDUMP_GET_SCRIPT_STRING();
eErr =
PDumpOSBufprintf(hScript, ui32MaxLen, "RDW :SGXREG:0x%lX\r\n",
ui32RegOffset);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0);
return PVRSRV_OK;
}
PVRSRV_ERROR PDumpBitmapKM(char *pszFileName,
u32 ui32FileOffset,
u32 ui32Width,
u32 ui32Height,
u32 ui32StrideInBytes,
IMG_DEV_VIRTADDR sDevBaseAddr,
u32 ui32Size,
PDUMP_PIXEL_FORMAT ePixelFormat,
PDUMP_MEM_FORMAT eMemFormat, u32 ui32PDumpFlags)
{
PVRSRV_ERROR eErr;
PDUMP_GET_SCRIPT_STRING();
PDumpCommentWithFlags(ui32PDumpFlags,
"\r\n-- Dump bitmap of render\r\n");
#if defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"SII %s %s.bin :SGXMEM:v%x:0x%08lX 0x%08lX 0x%08lX 0x%08X 0x%08lX 0x%08lX 0x%08lX 0x%08X\r\n",
pszFileName,
pszFileName,
PDUMP_DATAMASTER_PIXEL,
sDevBaseAddr.uiAddr,
ui32Size,
ui32FileOffset,
ePixelFormat,
ui32Width,
ui32Height, ui32StrideInBytes, eMemFormat);
#else
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"SII %s %s.bin :SGXMEM:v:0x%08lX 0x%08lX 0x%08lX 0x%08X 0x%08lX 0x%08lX 0x%08lX 0x%08X\r\n",
pszFileName,
pszFileName,
sDevBaseAddr.uiAddr,
ui32Size,
ui32FileOffset,
ePixelFormat,
ui32Width,
ui32Height, ui32StrideInBytes, eMemFormat);
#endif
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, ui32PDumpFlags);
return PVRSRV_OK;
}
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 PDumpCBP(PPVRSRV_KERNEL_MEM_INFO psROffMemInfo,
u32 ui32ROffOffset,
u32 ui32WPosVal,
u32 ui32PacketSize,
u32 ui32BufferSize, u32 ui32Flags, void *hUniqueTag)
{
PVRSRV_ERROR eErr;
u32 ui32PageOffset;
u8 *pui8LinAddr;
IMG_DEV_VIRTADDR sDevVAddr;
IMG_DEV_PHYADDR sDevPAddr;
IMG_DEV_VIRTADDR sDevVPageAddr;
PDUMP_GET_SCRIPT_STRING();
PVR_ASSERT((ui32ROffOffset + sizeof(u32)) <=
psROffMemInfo->ui32AllocSize);
pui8LinAddr = psROffMemInfo->pvLinAddrKM;
sDevVAddr = psROffMemInfo->sDevVAddr;
pui8LinAddr += ui32ROffOffset;
sDevVAddr.uiAddr += ui32ROffOffset;
PDumpOSCPUVAddrToPhysPages(psROffMemInfo->sMemBlk.hOSMemHandle,
ui32ROffOffset,
pui8LinAddr, &ui32PageOffset);
sDevVPageAddr.uiAddr = sDevVAddr.uiAddr - ui32PageOffset;
PVR_ASSERT((sDevVPageAddr.uiAddr & 0xFFF) == 0);
BM_GetPhysPageAddr(psROffMemInfo, sDevVPageAddr, &sDevPAddr);
sDevPAddr.uiAddr += ui32PageOffset;
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"CBP :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX 0x%8.8lX\r\n",
(u32) hUniqueTag,
sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_MASK),
sDevPAddr.uiAddr & (SGX_MMU_PAGE_MASK),
ui32WPosVal, ui32PacketSize, ui32BufferSize);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, ui32Flags);
return PVRSRV_OK;
}
PVRSRV_ERROR PDumpRegWithFlagsKM(u32 ui32Reg, u32 ui32Data, u32 ui32Flags)
{
PVRSRV_ERROR eErr;
PDUMP_GET_SCRIPT_STRING()
PDUMP_DBG(("PDumpRegWithFlagsKM"));
eErr =
PDumpOSBufprintf(hScript, ui32MaxLen,
"WRW :SGXREG:0x%8.8lX 0x%8.8lX\r\n", ui32Reg,
ui32Data);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, ui32Flags);
return PVRSRV_OK;
}
PVRSRV_ERROR PDumpPDRegWithFlags(u32 ui32Reg,
u32 ui32Data, u32 ui32Flags, void *hUniqueTag)
{
PVRSRV_ERROR eErr;
PDUMP_GET_SCRIPT_STRING()
#if defined(SGX_FEATURE_36BIT_MMU)
eErr = PDumpOSBufprintf(hScript, ui32MaxLen,
"WRW :SGXMEM:$1 :SGXMEM:PA_%8.8lX%8.8lX:0x0\r\n",
(u32) hUniqueTag,
(ui32Data & SGX_MMU_PDE_ADDR_MASK) <<
SGX_MMU_PDE_ADDR_ALIGNSHIFT);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, ui32Flags);
eErr =
PDumpOSBufprintf(hScript, ui32MaxLen,
"SHR :SGXMEM:$1 :SGXMEM:$1 0x4\r\n");
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, ui32Flags);
eErr = PDumpOSBufprintf(hScript, ui32MaxLen,
"WRW :SGXREG:0x%8.8lX: SGXMEM:$1\r\n", ui32Reg);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, ui32Flags);
#else
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"WRW :SGXREG:0x%8.8lX :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX\r\n",
ui32Reg,
(u32) hUniqueTag,
(ui32Data & SGX_MMU_PDE_ADDR_MASK) <<
SGX_MMU_PDE_ADDR_ALIGNSHIFT,
ui32Data & ~SGX_MMU_PDE_ADDR_MASK);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, ui32Flags);
#endif
return PVRSRV_OK;
}
PVRSRV_ERROR PDumpMallocPageTable(PVRSRV_DEVICE_TYPE eDeviceType,
IMG_CPU_VIRTADDR pvLinAddr,
u32 ui32PTSize, void *hUniqueTag)
{
PVRSRV_ERROR eErr;
IMG_DEV_PHYADDR sDevPAddr;
u32 ui32Page;
PDUMP_GET_SCRIPT_STRING();
PVR_ASSERT(((u32) pvLinAddr & (ui32PTSize - 1)) == 0);
eErr =
PDumpOSBufprintf(hScript, ui32MaxLen,
"-- MALLOC :SGXMEM:PAGE_TABLE 0x%8.8lX %lu\r\n",
ui32PTSize, SGX_MMU_PAGE_SIZE);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
{
PDumpOSCPUVAddrToDevPAddr(eDeviceType,
NULL,
0,
(u8 *) pvLinAddr,
SGX_MMU_PAGE_SIZE, &sDevPAddr);
ui32Page = sDevPAddr.uiAddr >> SGX_MMU_PAGE_SHIFT;
eErr =
PDumpOSBufprintf(hScript, ui32MaxLen,
"MALLOC :SGXMEM:PA_%8.8lX%8.8lX 0x%lX %lu 0x%8.8lX\r\n",
(u32) hUniqueTag,
ui32Page * SGX_MMU_PAGE_SIZE,
SGX_MMU_PAGE_SIZE, SGX_MMU_PAGE_SIZE,
ui32Page * SGX_MMU_PAGE_SIZE);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
}
return PVRSRV_OK;
}
PVRSRV_ERROR PDumpReadRegKM(char *pszFileName,
u32 ui32FileOffset,
u32 ui32Address, u32 ui32Size, u32 ui32PDumpFlags)
{
PVRSRV_ERROR eErr;
PDUMP_GET_SCRIPT_STRING();
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"SAB :SGXREG:0x%08lX 0x%08lX %s\r\n",
ui32Address, ui32FileOffset, pszFileName);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, ui32PDumpFlags);
return PVRSRV_OK;
}
static PVRSRV_ERROR PDumpSignatureRegister(char *pszFileName,
u32 ui32Address,
u32 ui32Size,
u32 * pui32FileOffset, u32 ui32Flags)
{
PVRSRV_ERROR eErr;
PDUMP_GET_SCRIPT_STRING();
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"SAB :SGXREG:0x%08X 0x%08X %s\r\n",
ui32Address, *pui32FileOffset, pszFileName);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, ui32Flags);
*pui32FileOffset += ui32Size;
return PVRSRV_OK;
}
/**************************************************************************
* 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;
IMG_UINT32 ui32Flags = PDUMP_FLAGS_CONTINUOUS;
PDUMP_GET_SCRIPT_STRING();
ui32Flags |= ( PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;
/*
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 ErrOut;
}
PDUMP_LOCK();
PDumpOSWriteString2(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;
}
PDumpOSWriteString2(hScript, ui32Flags);
ErrUnlock:
PDUMP_UNLOCK();
ErrOut:
return eErr;
}
/**************************************************************************
* Function Name : PDumpClearMMUContext
* Inputs :
* Outputs : None
* Returns : PVRSRV_ERROR
* Description : Clear MMU Context
**************************************************************************/
PVRSRV_ERROR PDumpMMUFreeMMUContext(const IMG_CHAR *pszPDumpMemSpaceName,
IMG_UINT32 ui32MMUContextID)
{
PVRSRV_ERROR eErr;
PDUMP_GET_SCRIPT_STRING();
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"-- Clear MMU Context for memory space %s", pszPDumpMemSpaceName);
if(eErr != PVRSRV_OK)
{
goto ErrOut;
}
PDUMP_LOCK();
PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"MMU :%s:v%d",
pszPDumpMemSpaceName,
ui32MMUContextID);
if(eErr != PVRSRV_OK)
{
goto ErrUnlock;
}
PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
eErr = _PdumpFreeMMUContext(ui32MMUContextID);
if(eErr != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PDumpClearMMUContext: _PdumpFreeMMUContext failed: %d", eErr));
goto ErrUnlock;
}
ErrUnlock:
PDUMP_UNLOCK();
ErrOut:
return eErr;
}
PVRSRV_ERROR PDumpRegPolWithFlagsKM(u32 ui32RegAddr, u32 ui32RegValue,
u32 ui32Mask, u32 ui32Flags)
{
#define POLL_DELAY 1000UL
#define POLL_COUNT_LONG (2000000000UL / POLL_DELAY)
#define POLL_COUNT_SHORT (1000000UL / POLL_DELAY)
PVRSRV_ERROR eErr;
u32 ui32PollCount;
PDUMP_GET_SCRIPT_STRING();
PDUMP_DBG(("PDumpRegPolWithFlagsKM"));
if (((ui32RegAddr == EUR_CR_EVENT_STATUS) &&
(ui32RegValue & ui32Mask & EUR_CR_EVENT_STATUS_TA_FINISHED_MASK) !=
0) || ((ui32RegAddr == EUR_CR_EVENT_STATUS)
&& (ui32RegValue & ui32Mask &
EUR_CR_EVENT_STATUS_PIXELBE_END_RENDER_MASK) != 0)
|| ((ui32RegAddr == EUR_CR_EVENT_STATUS)
&& (ui32RegValue & ui32Mask &
EUR_CR_EVENT_STATUS_DPM_3D_MEM_FREE_MASK) != 0)) {
ui32PollCount = POLL_COUNT_LONG;
} else {
ui32PollCount = POLL_COUNT_SHORT;
}
eErr =
PDumpOSBufprintf(hScript, ui32MaxLen,
"POL :SGXREG:0x%8.8lX 0x%8.8lX 0x%8.8lX %d %lu %d\r\n",
ui32RegAddr, ui32RegValue, ui32Mask, 0,
ui32PollCount, POLL_DELAY);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, ui32Flags);
return PVRSRV_OK;
}
PVRSRV_ERROR PDumpPDDevPAddrKM(PVRSRV_KERNEL_MEM_INFO * psMemInfo,
u32 ui32Offset,
IMG_DEV_PHYADDR sPDDevPAddr,
void *hUniqueTag1, void *hUniqueTag2)
{
PVRSRV_ERROR eErr;
u32 ui32PageByteOffset;
IMG_DEV_VIRTADDR sDevVAddr;
IMG_DEV_VIRTADDR sDevVPageAddr;
IMG_DEV_PHYADDR sDevPAddr;
PDUMP_GET_SCRIPT_STRING();
if (!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_PARAM2),
(u8 *) & sPDDevPAddr,
sizeof(IMG_DEV_PHYADDR),
PDUMP_FLAGS_CONTINUOUS)) {
return PVRSRV_ERROR_GENERIC;
}
sDevVAddr = psMemInfo->sDevVAddr;
ui32PageByteOffset = sDevVAddr.uiAddr & (SGX_MMU_PAGE_MASK);
sDevVPageAddr.uiAddr = sDevVAddr.uiAddr - ui32PageByteOffset;
PVR_ASSERT((sDevVPageAddr.uiAddr & 0xFFF) == 0);
BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
sDevPAddr.uiAddr += ui32PageByteOffset + ui32Offset;
if ((sPDDevPAddr.uiAddr & SGX_MMU_PDE_ADDR_MASK) != 0UL) {
#if defined(SGX_FEATURE_36BIT_MMU)
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"WRW :SGXMEM:$1 :SGXMEM:PA_%8.8lX%8.8lX:0x0\r\n",
(u32) hUniqueTag2, sPDDevPAddr.uiAddr);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
eErr =
PDumpOSBufprintf(hScript, ui32MaxLen,
"AND :SGXMEM:$2 :SGXMEM:$1 0xFFFFFFFF\r\n");
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX :SGXMEM:$2\r\n",
(u32) hUniqueTag1,
(sDevPAddr.
uiAddr) & ~(SGX_MMU_PAGE_MASK),
(sDevPAddr.
uiAddr) & (SGX_MMU_PAGE_MASK));
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
eErr =
PDumpOSBufprintf(hScript, ui32MaxLen,
"SHR :SGXMEM:$2 :SGXMEM:$1 0x20\r\n");
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX :SGXMEM:$2\r\n",
(u32) hUniqueTag1,
(sDevPAddr.uiAddr +
4) & ~(SGX_MMU_PAGE_MASK),
(sDevPAddr.uiAddr +
4) & (SGX_MMU_PAGE_MASK));
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
#else
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"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 & ~(SGX_MMU_PAGE_MASK),
sDevPAddr.uiAddr & (SGX_MMU_PAGE_MASK),
(u32) hUniqueTag2,
sPDDevPAddr.
uiAddr & SGX_MMU_PDE_ADDR_MASK,
sPDDevPAddr.
uiAddr & ~SGX_MMU_PDE_ADDR_MASK);
if (eErr != PVRSRV_OK) {
return eErr;
}
#endif
} else {
PVR_ASSERT(!(sDevPAddr.uiAddr & SGX_MMU_PTE_VALID));
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX\r\n",
(u32) hUniqueTag1,
sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_MASK),
sDevPAddr.uiAddr & (SGX_MMU_PAGE_MASK),
sPDDevPAddr.uiAddr);
if (eErr != PVRSRV_OK) {
return eErr;
}
}
PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
return PVRSRV_OK;
}
PVRSRV_ERROR PDumpMemPolKM(PVRSRV_KERNEL_MEM_INFO * psMemInfo,
u32 ui32Offset,
u32 ui32Value,
u32 ui32Mask,
PDUMP_POLL_OPERATOR eOperator,
u32 ui32Flags, void *hUniqueTag)
{
#define MEMPOLL_DELAY (1000)
#define MEMPOLL_COUNT (2000000000 / MEMPOLL_DELAY)
PVRSRV_ERROR eErr;
u32 ui32PageOffset;
u8 *pui8LinAddr;
IMG_DEV_PHYADDR sDevPAddr;
IMG_DEV_VIRTADDR sDevVPageAddr;
PDUMP_GET_SCRIPT_STRING();
PVR_ASSERT((ui32Offset + sizeof(u32)) <= psMemInfo->ui32AllocSize);
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"-- POL :SGXMEM:VA_%8.8lX 0x%8.8lX 0x%8.8lX %d %d %d\r\n",
psMemInfo->sDevVAddr.uiAddr + ui32Offset,
ui32Value,
ui32Mask,
eOperator, MEMPOLL_COUNT, MEMPOLL_DELAY);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, ui32Flags);
pui8LinAddr = psMemInfo->pvLinAddrKM;
pui8LinAddr += ui32Offset;
PDumpOSCPUVAddrToPhysPages(psMemInfo->sMemBlk.hOSMemHandle,
ui32Offset, pui8LinAddr, &ui32PageOffset);
sDevVPageAddr.uiAddr =
psMemInfo->sDevVAddr.uiAddr + ui32Offset - ui32PageOffset;
PVR_ASSERT((sDevVPageAddr.uiAddr & 0xFFF) == 0);
BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
sDevPAddr.uiAddr += ui32PageOffset;
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
"POL :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX %d %d %d\r\n",
(u32) hUniqueTag,
sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_MASK),
sDevPAddr.uiAddr & (SGX_MMU_PAGE_MASK),
ui32Value,
ui32Mask,
eOperator, MEMPOLL_COUNT, MEMPOLL_DELAY);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, ui32Flags);
return PVRSRV_OK;
}
/**************************************************************************
* 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)
{
PVRSRV_ERROR eErr;
IMG_UINT32 ui32Flags = PDUMP_FLAGS_CONTINUOUS;
IMG_UINT64 ui64SymbolicAddr;
PDUMP_GET_SCRIPT_STRING();
ui32Flags |= ( PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;
if (eMMULevel >= MMU_LEVEL_LAST)
{
eErr = PVRSRV_ERROR_INVALID_PARAMS;
goto ErrOut;
}
/*
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 ErrOut;
}
PDUMP_LOCK();
PDumpOSWriteString2(hScript, ui32Flags);
/*
construct the symbolic address
*/
ui64SymbolicAddr = (IMG_UINT64)psDevPAddr->uiAddr;
/*
Write to the MMU script stream indicating the memory allocation
*/
eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "MALLOC :%s:" MMUPT_FMT " 0x%X 0x%X",
pszPDumpDevName,
ui64SymbolicAddr,
ui32Size,
ui32Align
/* don't need this sDevPAddr.uiAddr*/);
if(eErr != PVRSRV_OK)
{
goto ErrUnlock;
}
PDumpOSWriteString2(hScript, ui32Flags);
ErrUnlock:
PDUMP_UNLOCK();
ErrOut:
return eErr;
}
PVRSRV_ERROR PDumpMallocPages(PVRSRV_DEVICE_TYPE eDeviceType,
u32 ui32DevVAddr,
IMG_CPU_VIRTADDR pvLinAddr,
void *hOSMemHandle,
u32 ui32NumBytes,
u32 ui32PageSize, void *hUniqueTag)
{
PVRSRV_ERROR eErr;
u8 *pui8LinAddr;
u32 ui32Offset;
u32 ui32NumPages;
IMG_DEV_PHYADDR sDevPAddr;
u32 ui32Page;
PDUMP_GET_SCRIPT_STRING();
#if defined(LINUX)
PVR_ASSERT(hOSMemHandle);
#else
PVR_ASSERT(((u32) pvLinAddr & (SGX_MMU_PAGE_MASK)) == 0);
#endif
PVR_ASSERT(((u32) ui32DevVAddr & (SGX_MMU_PAGE_MASK)) == 0);
PVR_ASSERT(((u32) ui32NumBytes & (SGX_MMU_PAGE_MASK)) == 0);
eErr =
PDumpOSBufprintf(hScript, ui32MaxLen,
"-- MALLOC :SGXMEM:VA_%8.8lX 0x%8.8lX %lu\r\n",
ui32DevVAddr, ui32NumBytes, ui32PageSize);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
pui8LinAddr = (u8 *) pvLinAddr;
ui32Offset = 0;
ui32NumPages = ui32NumBytes / ui32PageSize;
while (ui32NumPages) {
ui32NumPages--;
PDumpOSCPUVAddrToDevPAddr(eDeviceType,
hOSMemHandle,
ui32Offset,
pui8LinAddr,
ui32PageSize, &sDevPAddr);
ui32Page = sDevPAddr.uiAddr / ui32PageSize;
pui8LinAddr += ui32PageSize;
ui32Offset += ui32PageSize;
eErr =
PDumpOSBufprintf(hScript, ui32MaxLen,
"MALLOC :SGXMEM:PA_%8.8lX%8.8lX %lu %lu 0x%8.8lX\r\n",
(u32) hUniqueTag, ui32Page * ui32PageSize,
ui32PageSize, ui32PageSize,
ui32Page * ui32PageSize);
if (eErr != PVRSRV_OK) {
return eErr;
}
PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
}
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;
}
