/*****************************************************************************
FUNCTION : DBGDrivRead
PURPOSE :
PARAMETERS :
RETURNS :
*****************************************************************************/
static IMG_UINT32 DBGDIOCDrivRead(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
IMG_UINT32 * pui32BytesCopied;
PDBG_IN_READ psInParams;
PDBG_STREAM psStream;
IMG_UINT8 *pui8ReadBuffer;
#ifdef UNDER_WDDM
IMG_UINT8 *pui8ClientBuffer;
#endif
psInParams = (PDBG_IN_READ) pvInBuffer;
pui32BytesCopied = (IMG_UINT32 *) pvOutBuffer;
#ifdef UNDER_WDDM
/* WDDM DbgDriv operates at DISPATCH level so it cannot write directly
* to pdump.exe's userspace buffer
*/
pui8ReadBuffer = HostNonPageablePageAlloc(
(psInParams->ui32OutBufferSize + HOST_PAGESIZE - 1) / HOST_PAGESIZE);
pui8ClientBuffer = psInParams->u.pui8OutBuffer;
#else
pui8ReadBuffer = psInParams->u.pui8OutBuffer;
#endif
psStream = SID2PStream(psInParams->hStream);
if (psStream != (PDBG_STREAM)IMG_NULL)
{
*pui32BytesCopied = ExtDBGDrivRead(psStream,
psInParams->bReadInitBuffer,
psInParams->ui32OutBufferSize,
pui8ReadBuffer);
#ifdef UNDER_WDDM
if(*pui32BytesCopied > 0)
{
HostMemCopy(pui8ClientBuffer, pui8ReadBuffer, *pui32BytesCopied);
}
HostNonPageablePageFree(pui8ReadBuffer);
#endif
return(IMG_TRUE);
}
else
{
/* invalid SID */
*pui32BytesCopied = 0;
return(IMG_FALSE);
}
}
/*****************************************************************************
FUNCTION : DBGDrivReadString
PURPOSE :
PARAMETERS :
RETURNS :
*****************************************************************************/
static IMG_UINT32 DBGDIOCDrivReadString(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
IMG_UINT32 * pui32OutLen;
PDBG_IN_READSTRING psParams;
PDBG_STREAM psStream;
IMG_CHAR *pcReadBuffer;
#ifdef UNDER_WDDM
IMG_CHAR *pcClientBuffer;
#endif
psParams = (PDBG_IN_READSTRING) pvInBuffer;
pui32OutLen = (IMG_UINT32 *) pvOutBuffer;
#ifdef UNDER_WDDM
/* WDDM DbgDriv operates at DISPATCH level so it cannot write directly
* to pdump.exe's userspace buffer
*/
pcReadBuffer = HostNonPageablePageAlloc(
(psParams->ui32StringLen + HOST_PAGESIZE - 1) / HOST_PAGESIZE);
pcClientBuffer = psParams->u.pszString;
#else
pcReadBuffer = psParams->u.pszString;
#endif
psStream = SID2PStream(psParams->hStream);
if (psStream != (PDBG_STREAM)IMG_NULL)
{
*pui32OutLen = ExtDBGDrivReadString(psStream,
pcReadBuffer, psParams->ui32StringLen);
#ifdef UNDER_WDDM
if(*pui32OutLen > 0)
{
HostMemCopy(pcClientBuffer, pcReadBuffer, *pui32OutLen);
}
HostNonPageablePageFree(pcReadBuffer);
#endif
return(IMG_TRUE);
}
else
{
/* invalid SID */
*pui32OutLen = 0;
return(IMG_FALSE);
}
}
IMG_VOID * IMG_CALLCONV DBGDrivCreateStream(IMG_CHAR * pszName,
IMG_UINT32 ui32CapMode,
IMG_UINT32 ui32OutMode,
IMG_UINT32 ui32Flags,
IMG_UINT32 ui32Size)
{
PDBG_STREAM psStream;
PDBG_STREAM psInitStream;
PDBG_LASTFRAME_BUFFER psLFBuffer;
PDBG_STREAM_CONTROL psCtrl;
IMG_UINT32 ui32Off;
IMG_VOID * pvBase;
static IMG_CHAR pszNameInitSuffix[] = "_Init";
IMG_UINT32 ui32OffSuffix;
psStream = (PDBG_STREAM) DBGDrivFindStream(pszName, IMG_FALSE);
if (psStream)
{
return ((IMG_VOID *) psStream);
}
psStream = HostNonPageablePageAlloc(1);
psInitStream = HostNonPageablePageAlloc(1);
psLFBuffer = HostNonPageablePageAlloc(1);
psCtrl = HostNonPageablePageAlloc(1);
if (
(!psStream) ||
(!psInitStream) ||
(!psLFBuffer) ||
(!psCtrl)
)
{
PVR_DPF((PVR_DBG_ERROR,"DBGDriv: Couldn't alloc control structs\n\r"));
return((IMG_VOID *) 0);
}
if ((ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
{
pvBase = HostNonPageablePageAlloc(ui32Size);
}
else
{
pvBase = HostPageablePageAlloc(ui32Size);
}
if (!pvBase)
{
PVR_DPF((PVR_DBG_ERROR,"DBGDriv: Couldn't alloc Stream buffer\n\r"));
HostNonPageablePageFree(psStream);
return((IMG_VOID *) 0);
}
psCtrl->ui32Flags = ui32Flags;
psCtrl->ui32CapMode = ui32CapMode;
psCtrl->ui32OutMode = ui32OutMode;
psCtrl->ui32DebugLevel = DEBUG_LEVEL_0;
psCtrl->ui32DefaultMode = ui32CapMode;
psCtrl->ui32Start = 0;
psCtrl->ui32End = 0;
psCtrl->ui32Current = 0;
psCtrl->ui32SampleRate = 1;
psCtrl->bInitPhaseComplete = IMG_FALSE;
psStream->psNext = 0;
psStream->pvBase = pvBase;
psStream->psCtrl = psCtrl;
psStream->ui32Size = ui32Size * 4096UL;
psStream->ui32RPtr = 0;
psStream->ui32WPtr = 0;
psStream->ui32DataWritten = 0;
psStream->ui32Marker = 0;
psStream->bCircularAllowed = IMG_TRUE;
psStream->ui32InitPhaseWOff = 0;
if ((ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
{
pvBase = HostNonPageablePageAlloc(ui32Size);
}
else
{
pvBase = HostPageablePageAlloc(ui32Size);
}
if (!pvBase)
{
PVR_DPF((PVR_DBG_ERROR,"DBGDriv: Couldn't alloc InitStream buffer\n\r"));
if ((psStream->psCtrl->ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
{
HostNonPageablePageFree(psStream->pvBase);
}
else
{
HostPageablePageFree(psStream->pvBase);
}
HostNonPageablePageFree(psStream);
return((IMG_VOID *) 0);
}
psInitStream->psNext = 0;
psInitStream->pvBase = pvBase;
psInitStream->psCtrl = psCtrl;
psInitStream->ui32Size = ui32Size * 4096UL;
psInitStream->ui32RPtr = 0;
psInitStream->ui32WPtr = 0;
psInitStream->ui32DataWritten = 0;
psInitStream->ui32Marker = 0;
psInitStream->bCircularAllowed = IMG_FALSE;
psInitStream->ui32InitPhaseWOff = 0;
psStream->psInitStream = psInitStream;
psLFBuffer->psStream = psStream;
psLFBuffer->ui32BufLen = 0UL;
g_bHotkeyMiddump = IMG_FALSE;
g_ui32HotkeyMiddumpStart = 0xffffffffUL;
g_ui32HotkeyMiddumpEnd = 0xffffffffUL;
ui32Off = 0;
do
{
psStream->szName[ui32Off] = pszName[ui32Off];
psInitStream->szName[ui32Off] = pszName[ui32Off];
ui32Off++;
}
while ((pszName[ui32Off] != 0) && (ui32Off < (4096UL - sizeof(DBG_STREAM))));
psStream->szName[ui32Off] = pszName[ui32Off];
ui32OffSuffix = 0;
do
{
psInitStream->szName[ui32Off] = pszNameInitSuffix[ui32OffSuffix];
ui32Off++;
ui32OffSuffix++;
}
while ( (pszNameInitSuffix[ui32OffSuffix] != 0) &&
(ui32Off < (4096UL - sizeof(DBG_STREAM))));
psInitStream->szName[ui32Off] = pszNameInitSuffix[ui32OffSuffix];
psStream->psNext = g_psStreamList;
g_psStreamList = psStream;
psLFBuffer->psNext = g_psLFBufferList;
g_psLFBufferList = psLFBuffer;
AddSIDEntry(psStream);
return((IMG_VOID *) psStream);
}
IMG_BOOL ExpandStreamBuffer(PDBG_STREAM psStream, IMG_UINT32 ui32NewSize)
{
IMG_VOID * pvNewBuf;
IMG_UINT32 ui32NewSizeInPages;
IMG_UINT32 ui32NewWOffset;
IMG_UINT32 ui32NewROffset;
IMG_UINT32 ui32SpaceInOldBuf;
if (psStream->ui32Size >= ui32NewSize)
{
return IMG_FALSE;
}
ui32SpaceInOldBuf = SpaceInStream(psStream);
ui32NewSizeInPages = ((ui32NewSize + 0xfffUL) & ~0xfffUL) / 4096UL;
if ((psStream->psCtrl->ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
{
pvNewBuf = HostNonPageablePageAlloc(ui32NewSizeInPages);
}
else
{
pvNewBuf = HostPageablePageAlloc(ui32NewSizeInPages);
}
if (pvNewBuf == IMG_NULL)
{
return IMG_FALSE;
}
if(psStream->bCircularAllowed)
{
if (psStream->ui32RPtr <= psStream->ui32WPtr)
{
HostMemCopy(pvNewBuf,
(IMG_VOID *)((IMG_UINTPTR_T)psStream->pvBase + psStream->ui32RPtr),
psStream->ui32WPtr - psStream->ui32RPtr);
}
else
{
IMG_UINT32 ui32FirstCopySize;
ui32FirstCopySize = psStream->ui32Size - psStream->ui32RPtr;
HostMemCopy(pvNewBuf,
(IMG_VOID *)((IMG_UINTPTR_T)psStream->pvBase + psStream->ui32RPtr),
ui32FirstCopySize);
HostMemCopy((IMG_VOID *)((IMG_UINTPTR_T)pvNewBuf + ui32FirstCopySize),
(IMG_VOID *)(IMG_PBYTE)psStream->pvBase,
psStream->ui32WPtr);
}
ui32NewROffset = 0;
}
else
{
HostMemCopy(pvNewBuf, psStream->pvBase, psStream->ui32WPtr);
ui32NewROffset = psStream->ui32RPtr;
}
ui32NewWOffset = psStream->ui32Size - ui32SpaceInOldBuf;
if ((psStream->psCtrl->ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
{
HostNonPageablePageFree(psStream->pvBase);
}
else
{
HostPageablePageFree(psStream->pvBase);
}
psStream->pvBase = pvNewBuf;
psStream->ui32RPtr = ui32NewROffset;
psStream->ui32WPtr = ui32NewWOffset;
psStream->ui32Size = ui32NewSizeInPages * 4096;
return IMG_TRUE;
}
