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 (!PDumpReady())
{
eError = PVRSRV_ERROR_PDUMP_NOT_AVAILABLE;
goto ErrOut;
}
if (PDumpIsDumpSuspended())
{
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);
PDumpOSLock();
PDumpWriteScript(hScript, ui32PDumpFlags);
PDumpOSUnlock();
ErrOut:
return eError;
}
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 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;
}
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 PDumpCommentKM(char *pszComment, u32 ui32Flags)
{
PVRSRV_ERROR eErr;
PDUMP_GET_MSG_STRING();
PDUMP_DBG(("PDumpCommentKM"));
if (!PDumpOSWriteString2("-- ", ui32Flags)) {
if (ui32Flags & PDUMP_FLAGS_CONTINUOUS) {
return PVRSRV_ERROR_GENERIC;
} else {
return PVRSRV_ERROR_CMD_NOT_PROCESSED;
}
}
eErr = PDumpOSBufprintf(hMsg, ui32MaxLen, "%s", pszComment);
if ((eErr != PVRSRV_OK) && (eErr != PVRSRV_ERROR_PDUMP_BUF_OVERFLOW)) {
return eErr;
}
PDumpOSVerifyLineEnding(hMsg, ui32MaxLen);
PDumpOSWriteString2(hMsg, 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 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;
}
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;
}
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;
}
static PVRSRV_ERROR
_ContiguousPDumpBytes(const IMG_CHAR *pszSymbolicName,
IMG_UINT32 ui32SymAddrOffset,
IMG_BOOL bFlush,
IMG_UINT32 uiNumBytes,
IMG_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();
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)
{
PDumpOSCheckForSplitting(PDumpOSGetStream(PDUMP_STREAM_PARAM2), uiAccumulatedBytes, ui32Flags);
ui32ParamOutPos = PDumpOSGetStreamOffset(PDUMP_STREAM_PARAM2);
if (PDumpOSGetParamFileNum() == 0)
{
eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%.prm");
}
else
{
eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%_%u.prm", PDumpOSGetParamFileNum());
}
if(eErr != PVRSRV_OK)
{
goto ErrOut;
}
if(!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_PARAM2),
(IMG_UINT8 *)(IMG_UINTPTR_T)pvBasePointer,
uiAccumulatedBytes,
ui32Flags))
{
eErr = PVRSRV_ERROR_PDUMP_BUFFER_FULL;
goto ErrOut;
}
eErr = PDumpOSBufprintf(hScript, ui32MaxLenScript,
"LDB %s:0x%X 0x%X 0x%X %s",
/* dest */
pszSymbolicName,
ui32BaseOffset,
/* size */
uiAccumulatedBytes,
/* file offset */
ui32ParamOutPos,
/* filename */
pszFileName);
if(eErr != PVRSRV_OK)
{
goto ErrOut;
}
PDumpOSWriteString2(hScript, ui32Flags);
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 : 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;
}
/**************************************************************************
* 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;
}
static PVRSRV_ERROR
_ContiguousPDumpBytes(const IMG_CHAR *pszSymbolicName,
IMG_UINT32 ui32SymAddrOffset,
IMG_BOOL bFlush,
IMG_UINT32 uiNumBytes,
IMG_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);
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 *)(IMG_UINTPTR_T)pvBasePointer,
uiAccumulatedBytes, ui32Flags,
&ui32ParamOutPos, pszFileName);
PVR_LOGG_IF_ERROR(eErr, "PDumpWriteParameter", ErrOut);
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);
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;
}
