PVRSRV_ERROR IMG_CALLCONV PVRSRVSaveRestoreLiveSegments(IMG_HANDLE hArena, IMG_PBYTE pbyBuffer,
IMG_SIZE_T *puiBufSize, IMG_BOOL bSave)
{
IMG_SIZE_T uiBytesSaved = 0;
IMG_PVOID pvLocalMemCPUVAddr;
RA_SEGMENT_DETAILS sSegDetails;
if (hArena == IMG_NULL)
{
return (PVRSRV_ERROR_INVALID_PARAMS);
}
sSegDetails.uiSize = 0;
sSegDetails.sCpuPhyAddr.uiAddr = 0;
sSegDetails.hSegment = 0;
while (RA_GetNextLiveSegment(hArena, &sSegDetails))
{
if (pbyBuffer == IMG_NULL)
{
uiBytesSaved += sizeof(sSegDetails.uiSize) + sSegDetails.uiSize;
}
else
{
if ((uiBytesSaved + sizeof(sSegDetails.uiSize) + sSegDetails.uiSize) > *puiBufSize)
{
return (PVRSRV_ERROR_OUT_OF_MEMORY);
}
PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVSaveRestoreLiveSegments: Base %08x size %08x", sSegDetails.sCpuPhyAddr.uiAddr, sSegDetails.uiSize));
pvLocalMemCPUVAddr = OSMapPhysToLin(sSegDetails.sCpuPhyAddr,
sSegDetails.uiSize,
PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
IMG_NULL);
if (pvLocalMemCPUVAddr == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVSaveRestoreLiveSegments: Failed to map local memory to host"));
return (PVRSRV_ERROR_OUT_OF_MEMORY);
}
if (bSave)
{
OSMemCopy(pbyBuffer, &sSegDetails.uiSize, sizeof(sSegDetails.uiSize));
pbyBuffer += sizeof(sSegDetails.uiSize);
OSMemCopy(pbyBuffer, pvLocalMemCPUVAddr, sSegDetails.uiSize);
pbyBuffer += sSegDetails.uiSize;
}
else
{
IMG_UINT32 uiSize;
OSMemCopy(&uiSize, pbyBuffer, sizeof(sSegDetails.uiSize));
if (uiSize != sSegDetails.uiSize)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVSaveRestoreLiveSegments: Segment size error"));
}
else
{
pbyBuffer += sizeof(sSegDetails.uiSize);
OSMemCopy(pvLocalMemCPUVAddr, pbyBuffer, sSegDetails.uiSize);
pbyBuffer += sSegDetails.uiSize;
}
}
uiBytesSaved += sizeof(sSegDetails.uiSize) + sSegDetails.uiSize;
OSUnMapPhysToLin(pvLocalMemCPUVAddr,
sSegDetails.uiSize,
PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
IMG_NULL);
}
}
if (pbyBuffer == IMG_NULL)
{
*puiBufSize = uiBytesSaved;
}
return (PVRSRV_OK);
}
PVRSRV_ERROR
PVRSRVSyncPrimOpCreateKM(IMG_UINT32 ui32SyncBlockCount,
SYNC_PRIMITIVE_BLOCK **papsSyncPrimBlock,
IMG_UINT32 ui32ClientSyncCount,
IMG_UINT32 *paui32SyncBlockIndex,
IMG_UINT32 *paui32Index,
IMG_UINT32 ui32ServerSyncCount,
SERVER_SYNC_PRIMITIVE **papsServerSync,
SERVER_OP_COOKIE **ppsServerCookie)
{
SERVER_OP_COOKIE *psNewCookie;
IMG_UINT32 ui32BlockAllocSize;
IMG_UINT32 ui32ServerAllocSize;
IMG_UINT32 ui32ClientAllocSize;
IMG_UINT32 ui32TotalAllocSize;
IMG_UINT32 i;
IMG_CHAR *pcPtr;
PVRSRV_ERROR eError;
/* Allocate space for all the sync block list */
ui32BlockAllocSize = ui32SyncBlockCount * (sizeof(SYNC_PRIMITIVE_BLOCK *));
/* Allocate space for all the client sync size elements */
ui32ClientAllocSize = ui32ClientSyncCount * (5 * sizeof(IMG_UINT32));
/* Allocate space for all the server sync size elements */
ui32ServerAllocSize = ui32ServerSyncCount * (sizeof(SERVER_SYNC_PRIMITIVE *)
+ (2 * sizeof(IMG_UINT32)));
ui32TotalAllocSize = sizeof(SERVER_OP_COOKIE) +
ui32BlockAllocSize +
ui32ServerAllocSize +
ui32ClientAllocSize;
psNewCookie = OSAllocMem(ui32TotalAllocSize);
pcPtr = (IMG_CHAR *) psNewCookie;
if (!psNewCookie)
{
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto e0;
}
OSMemSet(psNewCookie, 0, ui32TotalAllocSize);
/* Setup the pointers */
pcPtr += sizeof(SERVER_OP_COOKIE);
psNewCookie->papsSyncPrimBlock = (SYNC_PRIMITIVE_BLOCK **) pcPtr;
pcPtr += sizeof(SYNC_PRIMITIVE_BLOCK *) * ui32SyncBlockCount;
psNewCookie->paui32SyncBlockIndex = (IMG_UINT32 *) pcPtr;
pcPtr += sizeof(IMG_UINT32) * ui32ClientSyncCount;
psNewCookie->paui32Index = (IMG_UINT32 *) pcPtr;
pcPtr += sizeof(IMG_UINT32) * ui32ClientSyncCount;
psNewCookie->paui32Flags = (IMG_UINT32 *) pcPtr;
pcPtr += sizeof(IMG_UINT32) * ui32ClientSyncCount;
psNewCookie->paui32FenceValue = (IMG_UINT32 *) pcPtr;
pcPtr += sizeof(IMG_UINT32) * ui32ClientSyncCount;
psNewCookie->paui32UpdateValue = (IMG_UINT32 *) pcPtr;
pcPtr += sizeof(IMG_UINT32) * ui32ClientSyncCount;
psNewCookie->papsServerSync =(SERVER_SYNC_PRIMITIVE **) pcPtr;
pcPtr += sizeof(SERVER_SYNC_PRIMITIVE *) * ui32ServerSyncCount;
psNewCookie->paui32ServerFenceValue = (IMG_UINT32 *) pcPtr;
pcPtr += sizeof(IMG_UINT32) * ui32ServerSyncCount;
psNewCookie->paui32ServerUpdateValue = (IMG_UINT32 *) pcPtr;
pcPtr += sizeof(IMG_UINT32) * ui32ServerSyncCount;
/* Check the pointer setup went ok */
PVR_ASSERT(pcPtr == (((IMG_CHAR *) psNewCookie) + ui32TotalAllocSize));
psNewCookie->ui32SyncBlockCount= ui32SyncBlockCount;
psNewCookie->ui32ServerSyncCount = ui32ServerSyncCount;
psNewCookie->ui32ClientSyncCount = ui32ClientSyncCount;
psNewCookie->bActive = IMG_FALSE;
/* Copy all the data into our server cookie */
OSMemCopy(psNewCookie->papsSyncPrimBlock,
papsSyncPrimBlock,
sizeof(SYNC_PRIMITIVE_BLOCK *) * ui32SyncBlockCount);
OSMemCopy(psNewCookie->paui32SyncBlockIndex,
paui32SyncBlockIndex,
sizeof(IMG_UINT32) * ui32ClientSyncCount);
OSMemCopy(psNewCookie->paui32Index,
paui32Index,
sizeof(IMG_UINT32) * ui32ClientSyncCount);
OSMemCopy(psNewCookie->papsServerSync,
papsServerSync,
sizeof(SERVER_SYNC_PRIMITIVE *) *ui32ServerSyncCount);
/*
Take a reference on all the sync blocks and server syncs so they can't
be freed while we're using them
*/
for (i=0;i<ui32SyncBlockCount;i++)
{
_SyncPrimitiveBlockRef(psNewCookie->papsSyncPrimBlock[i]);
}
for (i=0;i<ui32ServerSyncCount;i++)
{
_ServerSyncRef(psNewCookie->papsServerSync[i]);
}
*ppsServerCookie = psNewCookie;
return PVRSRV_OK;
e0:
return eError;
}
/*
Reserve space in the CCB and fill in the command and client sync data
*/
PVRSRV_ERROR RGXCmdHelperAcquireCmdCCB(IMG_UINT32 ui32CmdCount,
RGX_CCB_CMD_HELPER_DATA *asCmdHelperData,
IMG_BOOL *pbKickRequired)
{
IMG_UINT32 ui32BeforeWOff = asCmdHelperData[0].psClientCCB->ui32HostWriteOffset;
IMG_UINT32 ui32AllocSize = 0;
IMG_UINT32 i;
IMG_UINT8 *pui8StartPtr;
PVRSRV_ERROR eError;
*pbKickRequired = IMG_FALSE;
/*
Workout how much space we need for all the command(s)
*/
for (i=0;i<ui32CmdCount;i++)
{
if (asCmdHelperData[0].bPDumpContinuous != asCmdHelperData[i].bPDumpContinuous)
{
PVR_DPF((PVR_DBG_ERROR, "%s: PDump continuous is not consistent (%s != %s) for command %d",
__FUNCTION__,
asCmdHelperData[0].bPDumpContinuous?"IMG_TRUE":"IMG_FALSE",
asCmdHelperData[i].bPDumpContinuous?"IMG_TRUE":"IMG_FALSE",
ui32CmdCount));
return PVRSRV_ERROR_INVALID_PARAMS;
}
ui32AllocSize += asCmdHelperData[i].ui32FenceCmdSize +
asCmdHelperData[i].ui32DMCmdSize +
asCmdHelperData[i].ui32UpdateCmdSize;
}
/*
Acquire space in the CCB for all the command(s).
*/
eError = RGXAcquireCCB(asCmdHelperData[0].psClientCCB,
ui32AllocSize,
(IMG_PVOID *)&pui8StartPtr,
asCmdHelperData[0].bPDumpContinuous);
if (eError != PVRSRV_OK)
{
/* Failed so bail out and allow the client side to retry */
if (asCmdHelperData[0].psClientCCB->ui32HostWriteOffset != ui32BeforeWOff)
{
*pbKickRequired = IMG_TRUE;
}
return eError;
}
/*
For each command fill in the fence, DM, and update command
Note:
We only fill in the client fences here, the server fences (and updates)
will be filled in together at the end. This is because we might fail the
kernel CCB alloc and would then have to rollback the server syncs if
we took the operation here
*/
for (i=0;i<ui32CmdCount;i++)
{
RGX_CCB_CMD_HELPER_DATA *psCmdHelperData = &asCmdHelperData[i];
IMG_UINT8 *pui8CmdPtr;
IMG_UINT8 *pui8ServerFenceStart = 0;
IMG_UINT8 *pui8ServerUpdateStart = 0;
#if defined(PDUMP)
IMG_UINT32 ui32CtxAddr = FWCommonContextGetFWAddress(asCmdHelperData->psClientCCB->psServerCommonContext).ui32Addr;
IMG_UINT32 ui32CcbWoff = RGXGetHostWriteOffsetCCB(FWCommonContextGetClientCCB(asCmdHelperData->psClientCCB->psServerCommonContext));
#endif
if (psCmdHelperData->ui32ClientFenceCount+psCmdHelperData->ui32ClientUpdateCount != 0)
{
PDUMPCOMMENT("Start of %s client syncs for cmd[%d] on FWCtx %08x Woff 0x%x bytes",
psCmdHelperData->psClientCCB->szName, i, ui32CtxAddr, ui32CcbWoff);
}
/*
Create the fence command.
*/
if (psCmdHelperData->ui32FenceCmdSize)
{
RGXFWIF_CCB_CMD_HEADER *psHeader;
IMG_UINT k;
/* Fences are at the start of the command */
pui8CmdPtr = pui8StartPtr;
psHeader = (RGXFWIF_CCB_CMD_HEADER *) pui8CmdPtr;
psHeader->eCmdType = RGXFWIF_CCB_CMD_TYPE_FENCE;
psHeader->ui32CmdSize = psCmdHelperData->ui32FenceCmdSize - sizeof(RGXFWIF_CCB_CMD_HEADER);
pui8CmdPtr += sizeof(RGXFWIF_CCB_CMD_HEADER);
/* Fill in the client fences */
for (k = 0; k < psCmdHelperData->ui32ClientFenceCount; k++)
{
RGXFWIF_UFO *psUFOPtr = (RGXFWIF_UFO *) pui8CmdPtr;
psUFOPtr->puiAddrUFO = psCmdHelperData->pauiFenceUFOAddress[k];
psUFOPtr->ui32Value = psCmdHelperData->paui32FenceValue[k];
pui8CmdPtr += sizeof(RGXFWIF_UFO);
#if defined SYNC_COMMAND_DEBUG
PVR_DPF((PVR_DBG_ERROR, "%s client sync fence - 0x%x -> 0x%x",
psCmdHelperData->psClientCCB->szName, psUFOPtr->puiAddrUFO.ui32Addr, psUFOPtr->ui32Value));
#endif
PDUMPCOMMENT(".. %s client sync fence - 0x%x -> 0x%x",
psCmdHelperData->psClientCCB->szName, psUFOPtr->puiAddrUFO.ui32Addr, psUFOPtr->ui32Value);
}
pui8ServerFenceStart = pui8CmdPtr;
}
/*
Create the DM command
*/
if (psCmdHelperData->ui32DMCmdSize)
{
RGXFWIF_CCB_CMD_HEADER *psHeader;
/* The command is after any fences */
pui8CmdPtr = pui8StartPtr + psCmdHelperData->ui32FenceCmdSize;
psHeader = (RGXFWIF_CCB_CMD_HEADER *) pui8CmdPtr;
psHeader->eCmdType = psCmdHelperData->eType;
psHeader->ui32CmdSize = psCmdHelperData->ui32DMCmdSize - sizeof(RGXFWIF_CCB_CMD_HEADER);
pui8CmdPtr += sizeof(RGXFWIF_CCB_CMD_HEADER);
OSMemCopy(pui8CmdPtr, psCmdHelperData->pui8DMCmd, psCmdHelperData->ui32CmdSize);
}
/*
Create the update command.
Note:
We only fill in the client updates here, the server updates (and fences)
will be filled in together at the end
*/
if (psCmdHelperData->ui32UpdateCmdSize)
{
RGXFWIF_CCB_CMD_HEADER *psHeader;
IMG_UINT k;
/* And the update is after the DM command */
pui8CmdPtr = pui8StartPtr + psCmdHelperData->ui32FenceCmdSize + psCmdHelperData->ui32DMCmdSize;
psHeader = (RGXFWIF_CCB_CMD_HEADER *) pui8CmdPtr;
psHeader->eCmdType = RGXFWIF_CCB_CMD_TYPE_UPDATE;
psHeader->ui32CmdSize = psCmdHelperData->ui32UpdateCmdSize - sizeof(RGXFWIF_CCB_CMD_HEADER);
pui8CmdPtr += sizeof(RGXFWIF_CCB_CMD_HEADER);
/* Fill in the client updates */
for (k = 0; k < psCmdHelperData->ui32ClientUpdateCount; k++)
{
RGXFWIF_UFO *psUFOPtr = (RGXFWIF_UFO *) pui8CmdPtr;
psUFOPtr->puiAddrUFO = psCmdHelperData->pauiUpdateUFOAddress[k];
psUFOPtr->ui32Value = psCmdHelperData->paui32UpdateValue[k];
pui8CmdPtr += sizeof(RGXFWIF_UFO);
#if defined SYNC_COMMAND_DEBUG
PVR_DPF((PVR_DBG_ERROR, "%s client sync update - 0x%x -> 0x%x",
psCmdHelperData->psClientCCB->szName, psUFOPtr->puiAddrUFO.ui32Addr, psUFOPtr->ui32Value));
#endif
PDUMPCOMMENT(".. %s client sync update - 0x%x -> 0x%x",
psCmdHelperData->psClientCCB->szName, psUFOPtr->puiAddrUFO.ui32Addr, psUFOPtr->ui32Value);
}
pui8ServerUpdateStart = pui8CmdPtr;
}
/* Save the server sync fence & update offsets for submit time */
psCmdHelperData->pui8ServerFenceStart = pui8ServerFenceStart;
psCmdHelperData->pui8ServerUpdateStart = pui8ServerUpdateStart;
/* Save start for sanity checking at submit time */
psCmdHelperData->pui8StartPtr = pui8StartPtr;
/* Set the start pointer for the next iteration around the loop */
pui8StartPtr += psCmdHelperData->ui32FenceCmdSize +
psCmdHelperData->ui32DMCmdSize +
psCmdHelperData->ui32UpdateCmdSize;
if (psCmdHelperData->ui32ClientFenceCount+psCmdHelperData->ui32ClientUpdateCount != 0)
{
PDUMPCOMMENT("End of %s client syncs for cmd[%d] on FWCtx %08x Woff 0x%x bytes",
psCmdHelperData->psClientCCB->szName, i, ui32CtxAddr, ui32CcbWoff);
}
else
{
PDUMPCOMMENT("No %s client syncs for cmd[%d] on FWCtx %08x Woff 0x%x bytes",
psCmdHelperData->psClientCCB->szName, i, ui32CtxAddr, ui32CcbWoff);
}
}
*pbKickRequired = IMG_TRUE;
return PVRSRV_OK;
}
PVRSRV_ERROR
PVRSRVSyncPrimOpTakeKM(SERVER_OP_COOKIE *psServerCookie,
IMG_UINT32 ui32ClientSyncCount,
IMG_UINT32 *paui32Flags,
IMG_UINT32 *paui32FenceValue,
IMG_UINT32 *paui32UpdateValue,
IMG_UINT32 ui32ServerSyncCount,
IMG_UINT32 *paui32ServerFlags)
{
IMG_UINT32 i;
if ((ui32ClientSyncCount != psServerCookie->ui32ClientSyncCount) ||
(ui32ServerSyncCount != psServerCookie->ui32ServerSyncCount))
{
/* The bridge layer should have stopped us getting here but check incase */
PVR_DPF((PVR_DBG_ERROR, "%s: Invalid sync counts", __FUNCTION__));
return PVRSRV_ERROR_INVALID_PARAMS;
}
for (i=0;i<ui32ServerSyncCount;i++)
{
/* Server syncs must fence */
if ((paui32ServerFlags[i] & PVRSRV_CLIENT_SYNC_PRIM_OP_CHECK) == 0)
{
return PVRSRV_ERROR_INVALID_SYNC_PRIM_OP;
}
}
/*
For client syncs all we need to do is save the values
that we've been passed
*/
OSMemCopy(psServerCookie->paui32Flags,
paui32Flags,
sizeof(IMG_UINT32) * ui32ClientSyncCount);
OSMemCopy(psServerCookie->paui32FenceValue,
paui32FenceValue,
sizeof(IMG_UINT32) * ui32ClientSyncCount);
OSMemCopy(psServerCookie->paui32UpdateValue,
paui32UpdateValue,
sizeof(IMG_UINT32) * ui32ClientSyncCount);
/*
For server syncs we just take an operation
*/
for (i=0;i<ui32ServerSyncCount;i++)
{
/*
Take op can only take one operation at a time so we can't
optimise away fences so just report the requestor as unknown
*/
PVRSRVServerSyncQueueSWOpKM(psServerCookie->papsServerSync[i],
&psServerCookie->paui32ServerFenceValue[i],
&psServerCookie->paui32ServerUpdateValue[i],
SYNC_REQUESTOR_UNKNOWN,
(paui32ServerFlags[i] & PVRSRV_CLIENT_SYNC_PRIM_OP_UPDATE) ? IMG_TRUE:IMG_FALSE,
IMG_NULL);
}
psServerCookie->bActive = IMG_TRUE;
return PVRSRV_OK;
}
/*!
******************************************************************************
@Function PVRSRVSaveRestoreLiveSegments
@Input pArena - the arena the segment was originally allocated from.
pbyBuffer - the system memory buffer set to null to get the size needed.
puiBufSize - size of system memory buffer.
bSave - IMG_TRUE if a save is required
@Description
Function to save or restore Resources Live segments
******************************************************************************/
PVRSRV_ERROR IMG_CALLCONV PVRSRVSaveRestoreLiveSegments(IMG_HANDLE hArena, IMG_PBYTE pbyBuffer,
IMG_SIZE_T *puiBufSize, IMG_BOOL bSave)
{
IMG_SIZE_T uiBytesSaved = 0;
IMG_PVOID pvLocalMemCPUVAddr;
RA_SEGMENT_DETAILS sSegDetails;
if (hArena == IMG_NULL)
{
return (PVRSRV_ERROR_INVALID_PARAMS);
}
sSegDetails.uiSize = 0;
sSegDetails.sCpuPhyAddr.uiAddr = 0;
sSegDetails.hSegment = 0;
/* walk the arena segments and write live one to the buffer */
while (RA_GetNextLiveSegment(hArena, &sSegDetails))
{
if (pbyBuffer == IMG_NULL)
{
/* calc buffer required */
uiBytesSaved += sizeof(sSegDetails.uiSize) + sSegDetails.uiSize;
}
else
{
if ((uiBytesSaved + sizeof(sSegDetails.uiSize) + sSegDetails.uiSize) > *puiBufSize)
{
return (PVRSRV_ERROR_OUT_OF_MEMORY);
}
PVR_DPF((
PVR_DBG_MESSAGE,
"PVRSRVSaveRestoreLiveSegments: Base " CPUPADDR_FMT " size %" SIZE_T_FMT_LEN "x",
sSegDetails.sCpuPhyAddr.uiAddr,
sSegDetails.uiSize));
/* Map the device's local memory area onto the host. */
pvLocalMemCPUVAddr = OSMapPhysToLin(sSegDetails.sCpuPhyAddr,
sSegDetails.uiSize,
PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
IMG_NULL);
if (pvLocalMemCPUVAddr == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVSaveRestoreLiveSegments: Failed to map local memory to host"));
return (PVRSRV_ERROR_OUT_OF_MEMORY);
}
if (bSave)
{
/* write segment size then segment data */
OSMemCopy(pbyBuffer, &sSegDetails.uiSize, sizeof(sSegDetails.uiSize));
pbyBuffer += sizeof(sSegDetails.uiSize);
OSMemCopy(pbyBuffer, pvLocalMemCPUVAddr, sSegDetails.uiSize);
pbyBuffer += sSegDetails.uiSize;
}
else
{
IMG_UINT32 uiSize;
/* reag segment size and validate */
OSMemCopy(&uiSize, pbyBuffer, sizeof(sSegDetails.uiSize));
if (uiSize != sSegDetails.uiSize)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVSaveRestoreLiveSegments: Segment size error"));
}
else
{
pbyBuffer += sizeof(sSegDetails.uiSize);
OSMemCopy(pvLocalMemCPUVAddr, pbyBuffer, sSegDetails.uiSize);
pbyBuffer += sSegDetails.uiSize;
}
}
uiBytesSaved += sizeof(sSegDetails.uiSize) + sSegDetails.uiSize;
OSUnMapPhysToLin(pvLocalMemCPUVAddr,
sSegDetails.uiSize,
PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
IMG_NULL);
}
}
if (pbyBuffer == IMG_NULL)
{
*puiBufSize = uiBytesSaved;
}
return (PVRSRV_OK);
}
enum PVRSRV_ERROR PVRSRVSaveRestoreLiveSegments(void *hArena, u8 *pbyBuffer,
u32 *puiBufSize, IMG_BOOL bSave)
{
u32 uiBytesSaved = 0;
void *pvLocalMemCPUVAddr;
struct RA_SEGMENT_DETAILS sSegDetails;
if (hArena == NULL)
return PVRSRV_ERROR_INVALID_PARAMS;
sSegDetails.uiSize = 0;
sSegDetails.sCpuPhyAddr.uiAddr = 0;
sSegDetails.hSegment = NULL;
while (RA_GetNextLiveSegment(hArena, &sSegDetails))
if (pbyBuffer == NULL) {
uiBytesSaved +=
sizeof(sSegDetails.uiSize) + sSegDetails.uiSize;
} else {
if ((uiBytesSaved + sizeof(sSegDetails.uiSize) +
sSegDetails.uiSize) > *puiBufSize)
return PVRSRV_ERROR_OUT_OF_MEMORY;
PVR_DPF(PVR_DBG_MESSAGE,
"PVRSRVSaveRestoreLiveSegments: "
"Base %08x size %08x",
sSegDetails.sCpuPhyAddr.uiAddr,
sSegDetails.uiSize);
pvLocalMemCPUVAddr = (void __force *)
OSMapPhysToLin(sSegDetails.sCpuPhyAddr,
sSegDetails.uiSize,
PVRSRV_HAP_KERNEL_ONLY |
PVRSRV_HAP_UNCACHED, NULL);
if (pvLocalMemCPUVAddr == NULL) {
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVSaveRestoreLiveSegments: "
"Failed to map local memory to host");
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
if (bSave) {
OSMemCopy(pbyBuffer, &sSegDetails.uiSize,
sizeof(sSegDetails.uiSize));
pbyBuffer += sizeof(sSegDetails.uiSize);
OSMemCopy(pbyBuffer, pvLocalMemCPUVAddr,
sSegDetails.uiSize);
pbyBuffer += sSegDetails.uiSize;
} else {
u32 uiSize;
OSMemCopy(&uiSize, pbyBuffer,
sizeof(sSegDetails.uiSize));
if (uiSize != sSegDetails.uiSize) {
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVSaveRestoreLiveSegments:"
" Segment size error");
} else {
pbyBuffer += sizeof(sSegDetails.uiSize);
OSMemCopy(pvLocalMemCPUVAddr, pbyBuffer,
sSegDetails.uiSize);
pbyBuffer += sSegDetails.uiSize;
}
}
uiBytesSaved +=
sizeof(sSegDetails.uiSize) + sSegDetails.uiSize;
OSUnMapPhysToLin((void __force __iomem *)
pvLocalMemCPUVAddr,
sSegDetails.uiSize,
PVRSRV_HAP_KERNEL_ONLY |
PVRSRV_HAP_UNCACHED, NULL);
}
if (pbyBuffer == NULL)
*puiBufSize = uiBytesSaved;
return PVRSRV_OK;
}
/*!
******************************************************************************
@Function ReallocHandleBlockArray
@Description Reallocate the handle block array
@Input psBase - Pointer to handle base structure
ui32NewCount - The new total number of handles
@Return Error code or PVRSRV_OK
******************************************************************************/
static PVRSRV_ERROR ReallocHandleBlockArray(HANDLE_IMPL_BASE *psBase,
IMG_UINT32 ui32NewCount)
{
HANDLE_BLOCK *psOldArray = psBase->psHandleBlockArray;
IMG_UINT32 ui32OldCount = psBase->ui32TotalHandCount;
HANDLE_BLOCK *psNewArray = IMG_NULL;
PVRSRV_ERROR eError = PVRSRV_OK;
IMG_UINT32 ui32Index;
if (ui32NewCount == ui32OldCount)
{
return PVRSRV_OK;
}
if (ui32NewCount != 0 &&
!psBase->bPurgingEnabled &&
ui32NewCount < ui32OldCount)
{
return PVRSRV_ERROR_INVALID_PARAMS;
}
if (((ui32OldCount % HANDLE_BLOCK_SIZE) != 0) ||
((ui32NewCount % HANDLE_BLOCK_SIZE) != 0))
{
PVR_ASSERT((ui32OldCount % HANDLE_BLOCK_SIZE) == 0);
PVR_ASSERT((ui32NewCount % HANDLE_BLOCK_SIZE) == 0);
return PVRSRV_ERROR_INVALID_PARAMS;
}
if (ui32NewCount != 0)
{
/* Allocate new handle array */
psNewArray = OSAllocMem(HANDLE_BLOCK_ARRAY_SIZE(ui32NewCount) * sizeof(HANDLE_BLOCK));
if (psNewArray == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "%s: Couldn't allocate new handle array", __FUNCTION__));
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto error;
}
if (ui32OldCount != 0)
{
OSMemCopy(psNewArray, psOldArray, HANDLE_BLOCK_ARRAY_SIZE(MIN(ui32NewCount, ui32OldCount)) * sizeof(HANDLE_BLOCK));
}
}
/*
* If the new handle array is smaller than the old one, free
* unused handle data structure arrays
*/
for (ui32Index = ui32NewCount; ui32Index < ui32OldCount; ui32Index += HANDLE_BLOCK_SIZE)
{
HANDLE_BLOCK *psHandleBlock = BLOCK_ARRAY_AND_INDEX_TO_HANDLE_BLOCK(psOldArray, ui32Index);
OSFreeMem(psHandleBlock->psHandleDataArray);
}
/*
* If the new handle array is bigger than the old one, allocate
* new handle data structure arrays
*/
for (ui32Index = ui32OldCount; ui32Index < ui32NewCount; ui32Index += HANDLE_BLOCK_SIZE)
{
/* PRQA S 0505 1 */ /* psNewArray is never NULL, see assert earlier */
HANDLE_BLOCK *psHandleBlock = BLOCK_ARRAY_AND_INDEX_TO_HANDLE_BLOCK(psNewArray, ui32Index);
psHandleBlock->psHandleDataArray = OSAllocMem(sizeof(HANDLE_IMPL_DATA) * HANDLE_BLOCK_SIZE);
if (psHandleBlock->psHandleDataArray != IMG_NULL)
{
IMG_UINT32 ui32SubIndex;
psHandleBlock->ui32FreeHandCount = HANDLE_BLOCK_SIZE;
for (ui32SubIndex = 0; ui32SubIndex < HANDLE_BLOCK_SIZE; ui32SubIndex++)
{
HANDLE_IMPL_DATA *psHandleData = psHandleBlock->psHandleDataArray + ui32SubIndex;
psHandleData->hHandle = INDEX_TO_HANDLE(ui32SubIndex + ui32Index);
psHandleData->pvData = IMG_NULL;
psHandleData->ui32NextIndexPlusOne = 0;
}
}
else
{
PVR_DPF((PVR_DBG_ERROR, "%s: Couldn't allocate handle structures", __FUNCTION__));
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
}
}
if (eError != PVRSRV_OK)
{
goto error;
}
#if defined(DEBUG_MAX_HANDLE_COUNT)
/* Force handle failure to test error exit code */
if (ui32NewCount > DEBUG_MAX_HANDLE_COUNT)
{
PVR_DPF((PVR_DBG_ERROR, "%s: Max handle count (%u) reached", __FUNCTION__, DEBUG_MAX_HANDLE_COUNT));
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto error;
}
#endif /* defined(DEBUG_MAX_HANDLE_COUNT) */
if (psOldArray != IMG_NULL)
{
/* Free old handle array */
OSFreeMem(psOldArray);
}
psBase->psHandleBlockArray = psNewArray;
psBase->ui32TotalHandCount = ui32NewCount;
if (ui32NewCount > ui32OldCount)
{
/* Check for wraparound */
PVR_ASSERT(psBase->ui32TotalFreeHandCount + (ui32NewCount - ui32OldCount) > psBase->ui32TotalFreeHandCount);
/* PRQA S 3382 1 */ /* ui32NewCount always > ui32OldCount */
psBase->ui32TotalFreeHandCount += (ui32NewCount - ui32OldCount);
/*
* If purging is enabled, there is no free handle list
* management, but as an optimization, when allocating
* new handles, we use ui32FirstFreeIndex to point to
* the first handle in a newly allocated block.
*/
if (psBase->ui32FirstFreeIndex == 0)
{
PVR_ASSERT(psBase->ui32LastFreeIndexPlusOne == 0);
psBase->ui32FirstFreeIndex = ui32OldCount;
}
else
{
if (!psBase->bPurgingEnabled)
{
PVR_ASSERT(psBase->ui32LastFreeIndexPlusOne != 0);
PVR_ASSERT(INDEX_TO_HANDLE_DATA(psBase, psBase->ui32LastFreeIndexPlusOne - 1)->ui32NextIndexPlusOne == 0);
INDEX_TO_HANDLE_DATA(psBase, psBase->ui32LastFreeIndexPlusOne - 1)->ui32NextIndexPlusOne = ui32OldCount + 1;
}
}
if (!psBase->bPurgingEnabled)
{
psBase->ui32LastFreeIndexPlusOne = ui32NewCount;
}
}
else
{
if (ui32NewCount == 0)
{
psBase->ui32TotalFreeHandCount = 0;
psBase->ui32FirstFreeIndex = 0;
psBase->ui32LastFreeIndexPlusOne = 0;
}
else
{
PVR_ASSERT(psBase->bPurgingEnabled);
PVR_ASSERT(psBase->ui32FirstFreeIndex <= ui32NewCount);
PVR_ASSERT(psBase->ui32TotalFreeHandCount - (ui32OldCount - ui32NewCount) < psBase->ui32TotalFreeHandCount);
/* PRQA S 3382 1 */ /* ui32OldCount always >= ui32NewCount */
psBase->ui32TotalFreeHandCount -= (ui32OldCount - ui32NewCount);
}
}
PVR_ASSERT(psBase->ui32FirstFreeIndex <= psBase->ui32TotalHandCount);
return PVRSRV_OK;
error:
PVR_ASSERT(eError != PVRSRV_OK);
if (psNewArray != IMG_NULL)
{
/* Free any new handle structures that were allocated */
for (ui32Index = ui32OldCount; ui32Index < ui32NewCount; ui32Index += HANDLE_BLOCK_SIZE)
{
HANDLE_BLOCK *psHandleBlock = BLOCK_ARRAY_AND_INDEX_TO_HANDLE_BLOCK(psNewArray, ui32Index);
if (psHandleBlock->psHandleDataArray != IMG_NULL)
{
OSFreeMem(psHandleBlock->psHandleDataArray);
}
}
/* Free new handle array */
OSFreeMem(psNewArray);
}
return eError;
}
