queue.c

Lido PXA270平台开发板的最新BSP,包括源代码

	for(i = 0; i < ui32NumRegs; i++)
	{
		psRegData[i] = psRegs[i];
	}
	
	psRenderCmd->ui32RegCount = ui32NumRegs;

	PVRSRVUpdateQueue(psQueue, ui32CommandSize);
	
	return PVRSRVReleaseQueue(psQueue);
}


/*!
****************************************************************************
 @Function	: PVRSRVQueueBlt
    
 @Description	: Inserts a blit command into a Q

 @Input	:	psQueue			- pointer to queue information struct
 @Input	:	psDstSync 		- pointer to the Dest's Sync info structre
 @Input	:  	ui32NumSrcSyncs - How many sources are we synchronising with
 @Input	:  	apsSrcSync[] 	- Pointers to the SyncInfos within the source
 @Input	:	ui32DataSize 	- Size of the blit data stream in 4 byte units
 @Input	:	pui32BltData 	- Start of the blit data stream. Real array 
								  size is ui32DataCount
					
 @Return	: PVRSRV_ERROR_INVALID_PARAMS if too many SRCs
*****************************************************************************/
IMG_EXPORT
PVRSRV_ERROR PVRSRVQueueBlt(PVRSRV_QUEUE_INFO *psQueue, 
							PVRSRV_SYNC_INFO *psDstSync,
							IMG_UINT32 ui32NumSrcSyncs, 
							PVRSRV_SYNC_INFO *apsSrcSync[], 
							IMG_UINT32 ui32DataSize, 
							IMG_UINT32 *pui32BltData)
{
	PVRSRV_BLT_CMD_INFO	*psBltCmd;
	IMG_UINT32 ui32CommandSize;
	IMG_UINT32 i;

	if(ui32NumSrcSyncs > PVRSRV_MAX_BLT_SRC)
	{
		return PVRSRV_ERROR_INVALID_PARAMS;
	}

	ui32CommandSize = sizeof(PVRSRV_BLT_CMD_INFO) + (ui32DataSize * sizeof(IMG_UINT32)) - sizeof(IMG_UINT32);

	/*
		round to 4byte units
	*/
	ui32CommandSize =  (ui32CommandSize+3) & ~3L;
	
	psBltCmd = (PVRSRV_BLT_CMD_INFO *) PVRSRVGetQueueSpace(psQueue, ui32CommandSize);

	if(!psBltCmd)
	{
		PVR_DPF((PVR_DBG_ERROR,"Couldn't get space in queue"));
		return PVRSRV_ERROR_TIMEOUT;
	}

	psBltCmd->sCmdInfo.ui32CommandID = PVRSRV_CMD_ID_BLT;

	psBltCmd->sCmdInfo.ui32Size = ui32CommandSize;


	psBltCmd->ui32DstReadOpsPending = PVRSRVGetReadOpsPending(psDstSync, IMG_FALSE);
	psBltCmd->psDstSyncInfoKM = psDstSync->psKernSyncInfo;

	psDstSync->ui32BlitOpsPending++;
	
	for(i = 0; i < ui32NumSrcSyncs; i++)
	{
		psBltCmd->asSrcSyncInfo[i].ui32NextWriteOpVal = PVRSRVGetNextWriteOp(apsSrcSync[i], IMG_TRUE);

		PVRSRVGetReadOpsPending(apsSrcSync[i], IMG_TRUE);

		apsSrcSync[i]->ui32BlitOpsPending++;

		psBltCmd->asSrcSyncInfo[i].psSyncInfoKM = apsSrcSync[i]->psKernSyncInfo;
	}

	psBltCmd->ui32DstNextOpVal = PVRSRVGetNextWriteOp(psDstSync, IMG_FALSE);
	psBltCmd->ui32NumSrcSyncInfos = ui32NumSrcSyncs;

	for(i = 0; i < ui32DataSize; i++)
	{
		psBltCmd->aui32BltData[i] = pui32BltData[i];
	}

	psBltCmd->ui32DataCount = ui32DataSize;

	PVRSRVUpdateQueue(psQueue, ui32CommandSize);

	return PVRSRVReleaseQueue(psQueue);
}


/*!
****************************************************************************

 @Function : PVRSRVQueueFlip
    
 @Description	: Inserts a flip command into a Q

 @Input	:	psQueue			 - pointer to queue information struct
 @Input	:	psToSync 		 - pointer to "To"s Sync info structre
 @Input	:	psFromSync		 - pointer to "From"s Sync info structre
 @Input	:	bFlipOnVsync	 - If true - flip during vertical blanking
								   if false, flip immediately
 @Input	:	ui32FlipInterval - Minimum number of vsyncs to display the new
								   surface for (if bFlipOnVsync is true)
					
 @Return	: PVRSRV_ERROR_INVALID_PARAMS if too many SRCs
*****************************************************************************/
IMG_EXPORT
PVRSRV_ERROR PVRSRVQueueFlip(	PVRSRV_QUEUE_INFO *psQueue, 
								PVRSRV_SYNC_INFO *psToSync,
								PVRSRV_SYNC_INFO *psFromSync,
								PVRSRV_MEM_INFO *psFlipSurface,
								IMG_BOOL		 bFlipOnVsync,
								IMG_UINT32		 ui32FlipInterval)
{
	PVRSRV_FLIP_CMD_INFO	*psFlipCmd;
	IMG_UINT32 ui32CommandSize;
	
	ui32CommandSize = sizeof(PVRSRV_FLIP_CMD_INFO);

	/*
		round to 4byte units
	*/
	ui32CommandSize =  (ui32CommandSize+3) & ~3L;

	psFlipCmd = (PVRSRV_FLIP_CMD_INFO *) PVRSRVGetQueueSpace(psQueue, ui32CommandSize);

	if(!psFlipCmd)
	{
		PVR_DPF((PVR_DBG_ERROR,"Couldn't get space in queue"));
		return PVRSRV_ERROR_TIMEOUT;
	}

	psFlipCmd->sCmdInfo.ui32CommandID = PVRSRV_CMD_ID_FLIP;
	psFlipCmd->sCmdInfo.ui32Size = ui32CommandSize;

	psFlipCmd->psToSyncInfoKM = psToSync->psKernSyncInfo;	
	psFlipCmd->ui32ToNextOpVal = PVRSRVGetNextWriteOp(psToSync, IMG_TRUE);

	psFlipCmd->psFromSyncInfoKM = psFromSync->psKernSyncInfo;	
	psFlipCmd->ui32FromNextOpVal = PVRSRVGetNextWriteOp(psFromSync, IMG_TRUE);

	psFlipCmd->bFlipOnVsync=bFlipOnVsync;
	psFlipCmd->ui32FlipInterval=ui32FlipInterval; 
	psFlipCmd->ui32FlipPhysAddr=psFlipSurface->uiDevAddr.uiAddr;
	/* 
		view a flip as a read 
		- increment pending reads
		- increment reads complete when we flip
	*/
	PVRSRVGetReadOpsPending(psToSync, IMG_TRUE);
	PVRSRVGetReadOpsPending(psFromSync, IMG_TRUE);

	PVRSRVUpdateQueue(psQueue, ui32CommandSize);

	return PVRSRVReleaseQueue(psQueue);
}

/***********************************************************************************
 Function Name      : PVRSRVQueueOverlayFlip
 Inputs	:	    psQueue			      - pointer to queue information struct
				psToSync 		      - pointer to "To"s Sync info structre
				psFromSync		      - pointer to "From"s Sync info structure
				psFlipSurface         - pointer to flip surface
				bFlipOnVsync	      - If true - flip during vertical blanking
										if false, flip immediately
				ui32FlipInterval      - Minimum number of vsyncs to display the new
										surface for (if bFlipOnVsync is true)
				pui32OverlayConfig    - Buffer containing overlay register configuration
				ui32OverlayConfigSize - Size of overlay configuration buffer
 Outputs            : 
 Returns            : void
 Description        : Flip the overlay surface.
************************************************************************************/
IMG_EXPORT
PVRSRV_ERROR PVRSRVQueueOverlayFlip(PVRSRV_QUEUE_INFO *psQueue, 
									PVRSRV_SYNC_INFO *psToSync,
									PVRSRV_SYNC_INFO *psFromSync,
									PVRSRV_MEM_INFO *psFlipSurface,
									IMG_BOOL bFlipOnVsync,
									IMG_UINT32 ui32FlipInterval,
									IMG_UINT32* pui32OverlayConfig,
									IMG_UINT32 ui32OverlayConfigSize)
{
	PVRSRV_FLIP_OVERLAY_CMD_INFO	*psFlipCmd;
	IMG_UINT32 ui32CommandSize;
	
	ui32CommandSize = sizeof(PVRSRV_FLIP_OVERLAY_CMD_INFO);

	/*
		round to 4byte units
	*/
	ui32CommandSize =  (ui32CommandSize+3) & ~3L;

	psFlipCmd = (PVRSRV_FLIP_OVERLAY_CMD_INFO *) PVRSRVGetQueueSpace(psQueue, ui32CommandSize);

	if(!psFlipCmd)
	{
		PVR_DPF((PVR_DBG_ERROR,"Couldn't get space in queue"));
		return PVRSRV_ERROR_TIMEOUT;
	}

	psFlipCmd->sCmdInfo.ui32CommandID = PVRSRV_CMD_ID_FLIP_OVERLAY;
	psFlipCmd->sCmdInfo.ui32Size = ui32CommandSize;

	psFlipCmd->psToSyncInfoKM = psToSync->psKernSyncInfo;	
	psFlipCmd->ui32ToNextOpVal = PVRSRVGetNextWriteOp(psToSync, IMG_TRUE);

	psFlipCmd->psFromSyncInfoKM = psFromSync->psKernSyncInfo;	
	psFlipCmd->ui32FromNextOpVal = PVRSRVGetNextWriteOp(psFromSync, IMG_TRUE);

	psFlipCmd->bFlipOnVsync=bFlipOnVsync;
	psFlipCmd->ui32FlipInterval=ui32FlipInterval; 
	psFlipCmd->ui32FlipPhysAddr=psFlipSurface->uiDevAddr.uiAddr;
	
	psFlipCmd->pui32OverlayConfig = pui32OverlayConfig;
	psFlipCmd->ui32OverlayConfigSize = ui32OverlayConfigSize;

	/* 
		view a flip as a read 
		- increment pending reads
		- increment reads complete when we flip
	*/
	PVRSRVGetReadOpsPending(psToSync, IMG_TRUE);
	PVRSRVGetReadOpsPending(psFromSync, IMG_TRUE);

	PVRSRVUpdateQueue(psQueue, ui32CommandSize);

	return PVRSRVReleaseQueue(psQueue);
}

/*!
****************************************************************************

 @Function : QueueLock
    
 @Description	: Inserts a lock command into a Q

 @Input :	psQueue		- pointer to queue information struct
 @Input	:	psSync 		- pointer to the Dest's Sync info structre
 @Input	:	phWaitEventHandle - Handle for process to wait on
 @Input	:	bLockSurface - flag to denote locking\unlocking
 @Input	:	bPrimary	- Denotes primary surface
					
 @Return	: PVRSRV_ERROR_INVALID_PARAMS if too many SRCs
*****************************************************************************/
IMG_EXPORT
PVRSRV_ERROR PVRSRVQueueLock(	PVRSRV_QUEUE_INFO *psQueue, 
								PVRSRV_SYNC_INFO	*psSync,
								PVRSRV_MUTEX_HANDLE *phWaitEventHandle,
								IMG_BOOL			bLockSurface,
								IMG_BOOL			bPrimary)
{
	PVRSRV_LOCK_CMD_INFO *psLockCommand;
	IMG_UINT32			ui32CommandSize;

	/*! @todo add support for unlimited syncinfos */
	if(phWaitEventHandle == IMG_NULL)
	{
		return PVRSRV_ERROR_INVALID_PARAMS;
	}

	ui32CommandSize = sizeof(PVRSRV_LOCK_CMD_INFO);
	/*
		round to 4byte units
	*/
	ui32CommandSize =  (ui32CommandSize+3) & ~3L;

	psLockCommand = (PVRSRV_LOCK_CMD_INFO *) PVRSRVGetQueueSpace(psQueue, ui32CommandSize);

	if(!psLockCommand)
	{
		PVR_DPF((PVR_DBG_ERROR,"Couldn't get space in queue"));
		return PVRSRV_ERROR_TIMEOUT;
	}

	psLockCommand->sCmdInfo.ui32CommandID = PVRSRV_CMD_ID_LOCK;
	psLockCommand->sCmdInfo.ui32Size = ui32CommandSize;
	psLockCommand->psSyncInfoKM = psSync->psKernSyncInfo;
	psLockCommand->bLockSurface = bLockSurface;
	psLockCommand->bPrimary		= bPrimary;

	/* Store unique ID for event name */
	psLockCommand->hWaitEventHandle = *phWaitEventHandle;

	if(bLockSurface)
	{
		psLockCommand->ui32NextWriteOpVal = PVRSRVGetNextWriteOp(psSync, IMG_FALSE);
		psLockCommand->ui32ReadOpsPending = PVRSRVGetReadOpsPending(psSync, IMG_FALSE);
		/*
			Obtain Lock wait handle
		*/
		HostCreateEvent(phWaitEventHandle);
	}
	else
	{
		/* Open event to obtain Lock wait handle */
		HostOpenEvent(phWaitEventHandle);
	}

	PVRSRVUpdateQueue(psQueue, ui32CommandSize);

	return PVRSRVReleaseQueue(psQueue);
}


/*!
****************************************************************************

 @Function : PVRSRVQueueUpdateDisplay
    
 @Description	: Inserts an update command into a Q

 @Input	:	psQueue			 - pointer to queue information struct
 @Input	:	psToSync 		 - pointer to "To"s Sync info structre
 @Input	:	psFromSync		 - pointer to "From"s Sync info structre
					
 @Return	: PVRSRV_ERROR_INVALID_PARAMS if too many SRCs
*****************************************************************************/
IMG_EXPORT
PVRSRV_ERROR PVRSRVQueueUpdateDisplay(	PVRSRV_QUEUE_INFO *psQueue, 
										PVRSRV_SYNC_INFO *psDestSync
)
{
	PVRSRV_UPDATE_CMD_INFO	*psUpdateCmd;
	IMG_UINT32 ui32CommandSize;
	
	ui32CommandSize = sizeof(PVRSRV_UPDATE_CMD_INFO);

	/*
		round to 4byte units
	*/
	ui32CommandSize =  (ui32CommandSize+3) & ~3L;

	psUpdateCmd = (PVRSRV_UPDATE_CMD_INFO *) PVRSRVGetQueueSpace(psQueue, ui32CommandSize);
	
	if(!psUpdateCmd)
	{
		PVR_DPF((PVR_DBG_ERROR,"Couldn't get space in queue"));
		return PVRSRV_ERROR_TIMEOUT;
	}