enum PVRSRV_ERROR PDumpDriverInfoKM(char *pszString, u32 ui32Flags)
{
u32 ui32Count = 0;
__PDBG_PDUMP_STATE_GET_MSG_STRING(PVRSRV_ERROR_GENERIC);
snprintf(pszMsg, SZ_MSG_SIZE_MAX, "%s", pszString);
while ((pszMsg[ui32Count] != 0) && (ui32Count < SZ_MSG_SIZE_MAX))
ui32Count++;
if ((pszMsg[ui32Count - 1] != '\n') && (ui32Count < SZ_MSG_SIZE_MAX)) {
pszMsg[ui32Count] = '\n';
ui32Count++;
pszMsg[ui32Count] = '\0';
}
if ((pszMsg[ui32Count - 2] != '\r') && (ui32Count < SZ_MSG_SIZE_MAX)) {
pszMsg[ui32Count - 1] = '\r';
pszMsg[ui32Count] = '\n';
ui32Count++;
pszMsg[ui32Count] = '\0';
}
if (!PDumpWriteILock(gsDBGPdumpState.psStream[PDUMP_STREAM_DRIVERINFO],
(u8 *) pszMsg, ui32Count, ui32Flags)) {
if (ui32Flags & PDUMP_FLAGS_CONTINUOUS)
return PVRSRV_ERROR_GENERIC;
else
return PVRSRV_ERROR_CMD_NOT_PROCESSED;
}
return PVRSRV_OK;
}
/*!
* \name PDumpOSWriteString
*/
IMG_BOOL PDumpOSWriteString(IMG_HANDLE hStream,
IMG_UINT8 *psui8Data,
IMG_UINT32 ui32Size,
IMG_UINT32 ui32Flags)
{
PDBG_STREAM psStream = (PDBG_STREAM)hStream;
return PDumpWriteILock(psStream,
psui8Data,
ui32Size,
ui32Flags);
}
/*****************************************************************************
FUNCTION : PDumpWriteString2
PURPOSE :
PARAMETERS :
RETURNS :
*****************************************************************************/
static IMG_BOOL PDumpWriteString2(IMG_CHAR * pszString, IMG_UINT32 ui32Flags)
{
return PDumpWriteILock(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2], (IMG_UINT8 *) pszString, strlen(pszString), ui32Flags);
}
enum PVRSRV_ERROR PDumpPDDevPAddrKM(struct PVRSRV_KERNEL_MEM_INFO *psMemInfo,
u32 ui32Offset,
struct IMG_DEV_PHYADDR sPDDevPAddr,
void *hUniqueTag1, void *hUniqueTag2)
{
u32 ui32ParamOutPos;
struct IMG_CPU_PHYADDR CpuPAddr;
u32 ui32PageByteOffset;
struct IMG_DEV_VIRTADDR sDevVAddr;
struct IMG_DEV_VIRTADDR sDevVPageAddr;
struct IMG_DEV_PHYADDR sDevPAddr;
__PDBG_PDUMP_STATE_GET_SCRIPT_AND_FILE_STRING(PVRSRV_ERROR_GENERIC);
ui32ParamOutPos =
gpfnDbgDrv->pfnGetStreamOffset(gsDBGPdumpState.
psStream[PDUMP_STREAM_PARAM2]);
if (!PDumpWriteILock(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2],
(u8 *)&sPDDevPAddr, sizeof(struct IMG_DEV_PHYADDR),
PDUMP_FLAGS_CONTINUOUS))
return PVRSRV_ERROR_GENERIC;
if (gsDBGPdumpState.ui32ParamFileNum == 0)
snprintf(pszFile, SZ_FILENAME_SIZE_MAX, "%%0%%.prm");
else
snprintf(pszFile, SZ_FILENAME_SIZE_MAX, "%%0%%%lu.prm",
gsDBGPdumpState.ui32ParamFileNum);
CpuPAddr =
OSMemHandleToCpuPAddr(psMemInfo->sMemBlk.hOSMemHandle, ui32Offset);
ui32PageByteOffset = CpuPAddr.uiAddr & (PAGE_SIZE - 1);
sDevVAddr = psMemInfo->sDevVAddr;
sDevVAddr.uiAddr += ui32Offset;
sDevVPageAddr.uiAddr = sDevVAddr.uiAddr - ui32PageByteOffset;
BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
sDevPAddr.uiAddr += ui32PageByteOffset;
if ((sPDDevPAddr.uiAddr & SGX_MMU_PDE_ADDR_MASK) != 0) {
snprintf(pszScript,
SZ_SCRIPT_SIZE_MAX,
"WRW :SGXMEM:PA_%p%8.8lX:0x%8.8lX :"
"SGXMEM:PA_%p%8.8lX:0x%8.8lX\r\n",
hUniqueTag1,
sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_SIZE - 1),
sDevPAddr.uiAddr & (SGX_MMU_PAGE_SIZE - 1),
hUniqueTag2,
sPDDevPAddr.uiAddr & SGX_MMU_PDE_ADDR_MASK,
sPDDevPAddr.uiAddr & ~SGX_MMU_PDE_ADDR_MASK);
} else {
PVR_ASSERT(!(sDevPAddr.uiAddr & SGX_MMU_PTE_VALID));
snprintf(pszScript,
SZ_SCRIPT_SIZE_MAX,
"WRW :SGXMEM:PA_%p%8.8lX:0x%8.8lX 0x%8.8lX\r\n",
hUniqueTag1,
sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_SIZE - 1),
sDevPAddr.uiAddr & (SGX_MMU_PAGE_SIZE - 1),
sPDDevPAddr.uiAddr);
}
PDumpWriteString2(pszScript, PDUMP_FLAGS_CONTINUOUS);
return PVRSRV_OK;
}
enum PVRSRV_ERROR PDumpMem2KM(enum PVRSRV_DEVICE_TYPE eDeviceType,
void *pvLinAddr, u32 ui32Bytes, u32 ui32Flags,
IMG_BOOL bInitialisePages, void *hUniqueTag1,
void *hUniqueTag2)
{
u32 ui32NumPages;
u32 ui32PageOffset;
u32 ui32BlockBytes;
u8 *pui8LinAddr;
struct IMG_DEV_PHYADDR sDevPAddr;
struct IMG_CPU_PHYADDR sCpuPAddr;
u32 ui32Offset;
u32 ui32ParamOutPos;
__PDBG_PDUMP_STATE_GET_SCRIPT_AND_FILE_STRING(PVRSRV_ERROR_GENERIC);
if (ui32Flags)
;
if (!pvLinAddr)
return PVRSRV_ERROR_GENERIC;
if (gui32PDumpSuspended)
return PVRSRV_OK;
ui32ParamOutPos =
gpfnDbgDrv->pfnGetStreamOffset(gsDBGPdumpState.
psStream[PDUMP_STREAM_PARAM2]);
if (bInitialisePages) {
if (!PDumpWriteILock
(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2], pvLinAddr,
ui32Bytes, PDUMP_FLAGS_CONTINUOUS))
return PVRSRV_ERROR_GENERIC;
if (gsDBGPdumpState.ui32ParamFileNum == 0)
snprintf(pszFile, SZ_FILENAME_SIZE_MAX, "%%0%%.prm");
else
snprintf(pszFile, SZ_FILENAME_SIZE_MAX, "%%0%%%lu.prm",
gsDBGPdumpState.ui32ParamFileNum);
}
ui32PageOffset = (u32) pvLinAddr & (HOST_PAGESIZE() - 1);
ui32NumPages =
(ui32PageOffset + ui32Bytes + HOST_PAGESIZE() -
1) / HOST_PAGESIZE();
pui8LinAddr = (u8 *) pvLinAddr;
while (ui32NumPages--) {
sCpuPAddr = OSMapLinToCPUPhys(pui8LinAddr);
sDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
if (ui32PageOffset + ui32Bytes > HOST_PAGESIZE())
ui32BlockBytes = HOST_PAGESIZE() - ui32PageOffset;
else
ui32BlockBytes = ui32Bytes;
if (bInitialisePages) {
snprintf(pszScript,
SZ_SCRIPT_SIZE_MAX,
"LDB :SGXMEM:PA_%p%8.8lX:0x%8.8lX 0x%8.8lX "
"0x%8.8lX %s\r\n",
hUniqueTag1,
sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_SIZE - 1),
sDevPAddr.uiAddr & (SGX_MMU_PAGE_SIZE - 1),
ui32BlockBytes, ui32ParamOutPos, pszFile);
PDumpWriteString2(pszScript, 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) {
snprintf(pszScript,
SZ_SCRIPT_SIZE_MAX,
"WRW :SGXMEM:PA_%p%8.8lX:"
"0x%8.8lX :SGXMEM:"
"PA_%p%8.8lX:0x%8.8lX\r\n",
hUniqueTag1,
(sDevPAddr.uiAddr +
ui32Offset) &
~(SGX_MMU_PAGE_SIZE - 1),
(sDevPAddr.uiAddr +
ui32Offset) &
(SGX_MMU_PAGE_SIZE - 1),
hUniqueTag2,
ui32PTE &
SGX_MMU_PDE_ADDR_MASK,
ui32PTE &
~SGX_MMU_PDE_ADDR_MASK);
} else {
PVR_ASSERT(!
(ui32PTE &
SGX_MMU_PTE_VALID));
snprintf(pszScript, SZ_SCRIPT_SIZE_MAX,
"WRW :SGXMEM:PA_%p%8.8lX:"
"0x%8.8lX 0x%8.8lX%p\r\n",
hUniqueTag1,
(sDevPAddr.uiAddr +
ui32Offset) &
~(SGX_MMU_PAGE_SIZE - 1),
(sDevPAddr.uiAddr +
ui32Offset) &
(SGX_MMU_PAGE_SIZE - 1),
ui32PTE, hUniqueTag2);
}
PDumpWriteString2(pszScript,
PDUMP_FLAGS_CONTINUOUS);
}
}
ui32PageOffset = 0;
ui32Bytes -= ui32BlockBytes;
pui8LinAddr += ui32BlockBytes;
ui32ParamOutPos += ui32BlockBytes;
}
return PVRSRV_OK;
}
enum PVRSRV_ERROR PDumpMemKM(void *pvAltLinAddr,
struct PVRSRV_KERNEL_MEM_INFO *psMemInfo,
u32 ui32Offset, u32 ui32Bytes, u32 ui32Flags,
void *hUniqueTag)
{
u32 ui32PageByteOffset;
u8 *pui8DataLinAddr;
struct IMG_DEV_VIRTADDR sDevVPageAddr;
struct IMG_DEV_VIRTADDR sDevVAddr;
struct IMG_DEV_PHYADDR sDevPAddr;
struct IMG_CPU_PHYADDR CpuPAddr;
u32 ui32ParamOutPos;
u32 ui32CurrentOffset;
u32 ui32BytesRemaining;
struct LinuxMemArea *psLinuxMemArea;
enum LINUX_MEM_AREA_TYPE eRootAreaType;
char *pui8TransientCpuVAddr;
__PDBG_PDUMP_STATE_GET_SCRIPT_AND_FILE_STRING(PVRSRV_ERROR_GENERIC);
PVR_ASSERT((ui32Offset + ui32Bytes) <= psMemInfo->ui32AllocSize);
if (ui32Bytes == 0 || gui32PDumpSuspended)
return PVRSRV_OK;
if (pvAltLinAddr) {
pui8DataLinAddr = pvAltLinAddr;
} else if (psMemInfo->pvLinAddrKM) {
pui8DataLinAddr =
(u8 *) psMemInfo->pvLinAddrKM + ui32Offset;
} else {
pui8DataLinAddr = 0;
psLinuxMemArea =
(struct LinuxMemArea *)psMemInfo->sMemBlk.hOSMemHandle;
eRootAreaType = LinuxMemAreaRootType(psLinuxMemArea);
}
ui32ParamOutPos =
gpfnDbgDrv->pfnGetStreamOffset(gsDBGPdumpState.
psStream[PDUMP_STREAM_PARAM2]);
if (pui8DataLinAddr) {
if (!PDumpWriteILock
(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2],
pui8DataLinAddr, ui32Bytes, ui32Flags))
return PVRSRV_ERROR_GENERIC;
} else if (eRootAreaType == LINUX_MEM_AREA_IO) {
CpuPAddr =
OSMemHandleToCpuPAddr(psMemInfo->sMemBlk.hOSMemHandle,
ui32Offset);
pui8TransientCpuVAddr =
IORemapWrapper(CpuPAddr, ui32Bytes, PVRSRV_HAP_CACHED);
if (!PDumpWriteILock
(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2],
pui8TransientCpuVAddr, ui32Bytes, ui32Flags)) {
IOUnmapWrapper(pui8TransientCpuVAddr);
return PVRSRV_ERROR_GENERIC;
}
IOUnmapWrapper(pui8TransientCpuVAddr);
} else {
PVR_ASSERT(eRootAreaType == LINUX_MEM_AREA_ALLOC_PAGES);
ui32BytesRemaining = ui32Bytes;
ui32CurrentOffset = ui32Offset;
while (ui32BytesRemaining > 0) {
u32 ui32BlockBytes =
MIN(ui32BytesRemaining, PAGE_SIZE);
struct page *psCurrentPage = NULL;
CpuPAddr =
OSMemHandleToCpuPAddr(psMemInfo->sMemBlk.
hOSMemHandle,
ui32CurrentOffset);
if (CpuPAddr.uiAddr & (PAGE_SIZE - 1))
ui32BlockBytes =
MIN(ui32BytesRemaining,
PAGE_ALIGN(CpuPAddr.uiAddr) -
CpuPAddr.uiAddr);
psCurrentPage =
LinuxMemAreaOffsetToPage(psLinuxMemArea,
ui32CurrentOffset);
pui8TransientCpuVAddr = KMapWrapper(psCurrentPage);
pui8TransientCpuVAddr += (CpuPAddr.uiAddr & ~PAGE_MASK);
if (!pui8TransientCpuVAddr)
return PVRSRV_ERROR_GENERIC;
if (!PDumpWriteILock
(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2],
pui8TransientCpuVAddr, ui32BlockBytes,
ui32Flags)) {
KUnMapWrapper(psCurrentPage);
return PVRSRV_ERROR_GENERIC;
}
KUnMapWrapper(psCurrentPage);
ui32BytesRemaining -= ui32BlockBytes;
ui32CurrentOffset += ui32BlockBytes;
}
PVR_ASSERT(ui32BytesRemaining == 0);
}
if (gsDBGPdumpState.ui32ParamFileNum == 0)
snprintf(pszFile, SZ_FILENAME_SIZE_MAX, "%%0%%.prm");
else
snprintf(pszFile, SZ_FILENAME_SIZE_MAX, "%%0%%%lu.prm",
gsDBGPdumpState.ui32ParamFileNum);
snprintf(pszScript,
SZ_SCRIPT_SIZE_MAX,
"-- LDB :SGXMEM:VA_%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX %s\r\n",
psMemInfo->sDevVAddr.uiAddr,
ui32Offset, ui32Bytes, ui32ParamOutPos, pszFile);
PDumpWriteString2(pszScript, ui32Flags);
CpuPAddr =
OSMemHandleToCpuPAddr(psMemInfo->sMemBlk.hOSMemHandle, ui32Offset);
ui32PageByteOffset = CpuPAddr.uiAddr & (PAGE_SIZE - 1);
sDevVAddr = psMemInfo->sDevVAddr;
sDevVAddr.uiAddr += ui32Offset;
ui32BytesRemaining = ui32Bytes;
ui32CurrentOffset = ui32Offset;
while (ui32BytesRemaining > 0) {
u32 ui32BlockBytes = MIN(ui32BytesRemaining, PAGE_SIZE);
CpuPAddr =
OSMemHandleToCpuPAddr(psMemInfo->sMemBlk.hOSMemHandle,
ui32CurrentOffset);
sDevVPageAddr.uiAddr =
psMemInfo->sDevVAddr.uiAddr + ui32CurrentOffset -
ui32PageByteOffset;
BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
sDevPAddr.uiAddr += ui32PageByteOffset;
if (ui32PageByteOffset) {
ui32BlockBytes =
MIN(ui32BytesRemaining,
PAGE_ALIGN(CpuPAddr.uiAddr) - CpuPAddr.uiAddr);
ui32PageByteOffset = 0;
}
snprintf(pszScript,
SZ_SCRIPT_SIZE_MAX,
"LDB :SGXMEM:PA_%p%8.8lX:0x%8.8lX 0x%8.8lX "
"0x%8.8lX %s\r\n",
hUniqueTag,
sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_SIZE - 1),
sDevPAddr.uiAddr & (SGX_MMU_PAGE_SIZE - 1),
ui32BlockBytes, ui32ParamOutPos, pszFile);
PDumpWriteString2(pszScript, ui32Flags);
ui32BytesRemaining -= ui32BlockBytes;
ui32CurrentOffset += ui32BlockBytes;
ui32ParamOutPos += ui32BlockBytes;
}
PVR_ASSERT(ui32BytesRemaining == 0);
return PVRSRV_OK;
}
static IMG_BOOL PDumpWriteString2(char *pszString, u32 ui32Flags)
{
return PDumpWriteILock(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2],
(u8 *)pszString, strlen(pszString), ui32Flags);
}
