IMG_UINT32 IMG_CALLCONV DBGDrivWriteLF(PDBG_STREAM psStream, IMG_UINT8 * pui8InBuf, IMG_UINT32 ui32InBuffSize, IMG_UINT32 ui32Level, IMG_UINT32 ui32Flags)
{
PDBG_LASTFRAME_BUFFER psLFBuffer;
if (!StreamValidForWrite(psStream))
{
return(0xFFFFFFFFUL);
}
if ((psStream->psCtrl->ui32DebugLevel & ui32Level) == 0)
{
return(0xFFFFFFFFUL);
}
if ((psStream->psCtrl->ui32CapMode & DEBUG_CAPMODE_FRAMED) != 0)
{
if ((psStream->psCtrl->ui32Flags & DEBUG_FLAGS_ENABLESAMPLE) == 0)
{
return(ui32InBuffSize);
}
}
else if (psStream->psCtrl->ui32CapMode == DEBUG_CAPMODE_HOTKEY)
{
if ((psStream->psCtrl->ui32Current != g_ui32HotKeyFrame) || (g_bHotKeyPressed == IMG_FALSE))
{
return(ui32InBuffSize);
}
}
psLFBuffer = FindLFBuf(psStream);
if (ui32Flags & WRITELF_FLAGS_RESETBUF)
{
ui32InBuffSize = (ui32InBuffSize > LAST_FRAME_BUF_SIZE) ? LAST_FRAME_BUF_SIZE : ui32InBuffSize;
HostMemCopy((IMG_VOID *)psLFBuffer->ui8Buffer, (IMG_VOID *)pui8InBuf, ui32InBuffSize);
psLFBuffer->ui32BufLen = ui32InBuffSize;
}
else
{
ui32InBuffSize = ((psLFBuffer->ui32BufLen + ui32InBuffSize) > LAST_FRAME_BUF_SIZE) ? (LAST_FRAME_BUF_SIZE - psLFBuffer->ui32BufLen) : ui32InBuffSize;
HostMemCopy((IMG_VOID *)(&psLFBuffer->ui8Buffer[psLFBuffer->ui32BufLen]), (IMG_VOID *)pui8InBuf, ui32InBuffSize);
psLFBuffer->ui32BufLen += ui32InBuffSize;
}
return(ui32InBuffSize);
}
static void Write(PDBG_STREAM psStream,IMG_PUINT8 pui8Data,IMG_UINT32 ui32InBuffSize)
{
if (!psStream->bCircularAllowed)
{
}
if ((psStream->ui32WPtr + ui32InBuffSize) > psStream->ui32Size)
{
IMG_UINT32 ui32B1 = psStream->ui32Size - psStream->ui32WPtr;
IMG_UINT32 ui32B2 = ui32InBuffSize - ui32B1;
HostMemCopy((IMG_PVOID)((IMG_UINTPTR_T)psStream->pvBase + psStream->ui32WPtr),
(IMG_PVOID) pui8Data,
ui32B1);
HostMemCopy(psStream->pvBase,
(IMG_PVOID)(pui8Data + ui32B1),
ui32B2);
psStream->ui32WPtr = ui32B2;
}
else
{
HostMemCopy((IMG_PVOID)((IMG_UINTPTR_T)psStream->pvBase + psStream->ui32WPtr),
(IMG_PVOID) pui8Data,
ui32InBuffSize);
psStream->ui32WPtr += ui32InBuffSize;
if (psStream->ui32WPtr == psStream->ui32Size)
{
psStream->ui32WPtr = 0;
}
}
psStream->ui32DataWritten += ui32InBuffSize;
}
/*****************************************************************************
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);
}
}
void MonoOut(IMG_CHAR * pszString,IMG_BOOL bNewLine)
{
#if defined (_WIN64)
PVR_UNREFERENCED_PARAMETER(pszString);
PVR_UNREFERENCED_PARAMETER(bNewLine);
#else
IMG_UINT32 i;
IMG_CHAR * pScreen;
pScreen = (IMG_CHAR *) DBGDRIV_MONOBASE;
pScreen += g_ui32Line * 160;
i=0;
do
{
pScreen[g_ui32LOff + (i*2)] = pszString[i];
pScreen[g_ui32LOff + (i*2)+1] = 127;
i++;
}
while ((pszString[i] != 0) && (i < 4096));
g_ui32LOff += i * 2;
if (bNewLine)
{
g_ui32LOff = 0;
g_ui32Line++;
}
if (g_ui32Line == g_ui32MonoLines)
{
g_ui32Line = g_ui32MonoLines - 1;
HostMemCopy((IMG_VOID *)DBGDRIV_MONOBASE,(IMG_VOID *)(DBGDRIV_MONOBASE + 160),160 * (g_ui32MonoLines - 1));
HostMemSet((IMG_VOID *)(DBGDRIV_MONOBASE + (160 * (g_ui32MonoLines - 1))),0,160);
}
#endif
}
IMG_UINT32 IMG_CALLCONV DBGDrivReadLF(PDBG_STREAM psStream, IMG_UINT32 ui32OutBuffSize, IMG_UINT8 * pui8OutBuf)
{
PDBG_LASTFRAME_BUFFER psLFBuffer;
IMG_UINT32 ui32Data;
if (!StreamValidForRead(psStream))
{
return(0);
}
psLFBuffer = FindLFBuf(psStream);
ui32Data = (ui32OutBuffSize < psLFBuffer->ui32BufLen) ? ui32OutBuffSize : psLFBuffer->ui32BufLen;
HostMemCopy((IMG_VOID *)pui8OutBuf, (IMG_VOID *)psLFBuffer->ui8Buffer, ui32Data);
return ui32Data;
}
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;
}
IMG_UINT32 IMG_CALLCONV DBGDrivRead(PDBG_STREAM psMainStream, IMG_BOOL bReadInitBuffer, IMG_UINT32 ui32OutBuffSize,IMG_UINT8 * pui8OutBuf)
{
IMG_UINT32 ui32Data;
DBG_STREAM *psStream;
if (!StreamValidForRead(psMainStream))
{
PVR_DPF((PVR_DBG_ERROR, "DBGDrivRead: buffer %x is invalid", (IMG_UINTPTR_T) psMainStream));
return(0);
}
if(bReadInitBuffer)
{
psStream = psMainStream->psInitStream;
}
else
{
psStream = psMainStream;
}
if (psStream->ui32RPtr == psStream->ui32WPtr ||
((psStream->ui32InitPhaseWOff > 0) &&
(psStream->ui32RPtr >= psStream->ui32InitPhaseWOff)) )
{
return(0);
}
if (psStream->ui32RPtr <= psStream->ui32WPtr)
{
ui32Data = psStream->ui32WPtr - psStream->ui32RPtr;
}
else
{
ui32Data = psStream->ui32WPtr + (psStream->ui32Size - psStream->ui32RPtr);
}
if ((psStream->ui32InitPhaseWOff > 0) &&
(psStream->ui32InitPhaseWOff < psStream->ui32WPtr))
{
ui32Data = psStream->ui32InitPhaseWOff - psStream->ui32RPtr;
}
if (ui32Data > ui32OutBuffSize)
{
ui32Data = ui32OutBuffSize;
}
PVR_DPF((PVR_DBGDRIV_MESSAGE, "Send %x b from %s: Roff = %x, WOff = %x",
ui32Data,
psStream->szName,
psStream->ui32RPtr,
psStream->ui32WPtr));
if ((psStream->ui32RPtr + ui32Data) > psStream->ui32Size)
{
IMG_UINT32 ui32B1 = psStream->ui32Size - psStream->ui32RPtr;
IMG_UINT32 ui32B2 = ui32Data - ui32B1;
HostMemCopy((IMG_VOID *) pui8OutBuf,
(IMG_VOID *)((IMG_UINTPTR_T)psStream->pvBase + psStream->ui32RPtr),
ui32B1);
HostMemCopy((IMG_VOID *)(pui8OutBuf + ui32B1),
psStream->pvBase,
ui32B2);
psStream->ui32RPtr = ui32B2;
}
else
{
HostMemCopy((IMG_VOID *) pui8OutBuf,
(IMG_VOID *)((IMG_UINTPTR_T)psStream->pvBase + psStream->ui32RPtr),
ui32Data);
psStream->ui32RPtr += ui32Data;
if (psStream->ui32RPtr == psStream->ui32Size)
{
psStream->ui32RPtr = 0;
}
}
return(ui32Data);
}
