services_calls.c

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

			{
				HostWaitus(1000);
				gc->sHWContext.ps3DDevData->psDevInfoUM->sDeviceSpecific.s3D.bTAStreamErrorInterrupt = IMG_FALSE;
				gc->sHWContext.ps3DDevData->psDevInfoUM->sDeviceSpecific.s3D.bLastContextStreamError = IMG_FALSE;
			}
#endif
		}

		gc->sHWContext.ui32TAControland3DState |=	MBX1_TASTATEPRES_ISPCTL				|
													MBX1_TASTATEPRES_TSPCTL				|
													MBX1_TASTATEPRES_LAYER0CTL			|
													MBX1_TASTATEPRES_LAYER1CTL			|
													MBX1_TASTATEPRES_REGIONCLIP			|
													MBX1_TASTATEPRES_FP_INPUTFORMAT;


#if defined(SUPPORT_VGP) || defined(SUPPORT_VGP_LITE)
		gc->sHWContext.ui32TAControland3DState |=	MBX1_TASTATEPRES_VGP_IFDEFINITION	|
													MBX1_TASTATEPRES_VGP_VIEWPORTTRANS	|	
													MBX1_TASTATEPRES_VGP_WCLAMPVAL;
#endif

		SendRegionClipControl(gc);

#if defined(SUPPORT_VGP) || defined(SUPPORT_VGP_LITE)
		LoadVGPProgram(gc);
		LoadAllVGPSectionDefinitions(gc);
#endif

		gc->ui32DirtyMask = 0xFFFFFFFF;
		gc->ui32DirtyConstantMask = 0xFFFFFFFF;

	}

	return IMG_TRUE;
}

/***********************************************************************************
 Function Name      : GLESReleaseTA
 Inputs             : gc, bIsTerminate
 Outputs            : 
 Returns            : success
 Description        : Releases the TA and its slaveport
************************************************************************************/

IMG_BOOL GLESReleaseTA(GLESContext *gc, IMG_BOOL bIsTerminate)
{
	gc->sHWContext.ui32FifoSpace = 0;

	if(PVRSRVReleaseSlavePort(gc->sHWContext.ps3DDevData->psDevInfoUM, PVRSRV_SLAVEPORT_3D) != PVRSRV_OK)
	{
		DPF((DBG_ERROR,"Couldn't release the slaveport"));
		return IMG_FALSE;
	}

	if(PVRSRVReleaseTA(	gc->sHWContext.ps3DDevData->psDevInfoUM, bIsTerminate) != PVRSRV_OK)
	{
		DPF((DBG_ERROR,"Couldn't release the TA"));
		return IMG_FALSE;
	}

	return IMG_TRUE;
}

/***********************************************************************************
 Function Name      : GLESCreateDepthBuffer
 Inputs             : gc
 Outputs            : -
 Returns            : success
 Description        : Creates a depth buffer.
************************************************************************************/

IMG_BOOL GLESCreateDepthBuffer(GLESContext *gc)
{
#if !defined (FIX_HW_PRN_36)
	GLESRenderSurface *psRenderSurface = gc->psRenderSurface;
	PVR3DIF_SHAREDDATA *psSharedData = psRenderSurface->psTARenderInfo->psSharedData;
	DEVICE3D *ps3D = &gc->sHWContext.ps3DDevData->psDevInfoUM->sDeviceSpecific.s3D;
	IMG_UINT32 ui32PixelWidth, ui32PixelHeight, ui32Size; 
	IMG_UINT32 i;
	IMG_UINT32 *pui32DepthBuffer;

	ui32PixelWidth = psSharedData->ui32XTilesPerMT * psSharedData->ui32MTilesX * ps3D->ui32PixelsInTileX;
	ui32PixelHeight = psSharedData->ui32YTilesPerMT * psSharedData->ui32MTilesY * ps3D->ui32PixelsInTileY;

	/* Assumes 32 bit depth pixel size */
	ui32Size = ui32PixelWidth * sizeof(IMG_UINT32) * ui32PixelHeight;

	if(!GLESAllocateDeviceMemory(gc, ui32Size, MBX1_ZBASEADDR_ALIGNSIZE, &psRenderSurface->psZBufferMemInfo))
	{
		DPF((DBG_ERROR,"Couldn't allocate memory for Z buffer"));
		return IMG_FALSE;
	}

	/* 
	 * This depth buffer initialisation could take place in the servces - pass in a special flag to allocdevicemem.
	 * This would allow the initialisation to be accelerated by the 2D core.
	 */
	pui32DepthBuffer = (IMG_UINT32 *)psRenderSurface->psZBufferMemInfo->pvLinAddr;

	/* Initialise the depth buffer so that the first ZLoad will get a valid depth and viewport value */
	for(i=0; i < ui32PixelWidth * ui32PixelHeight; i++)
	{
		pui32DepthBuffer[i] = 0x00000001;
	}
#endif
	return IMG_TRUE;
}

/***********************************************************************************
 Function Name      : GLESDestroyDepthBuffer
 Inputs             : psSysContext, psRenderSurface
 Outputs            : -
 Returns            : success
 Description        : Destroys a depth buffer.
************************************************************************************/

IMG_BOOL GLESDestroyDepthBuffer(GLESSysContext *psSysContext, GLESRenderSurface *psRenderSurface)
{
	if(PVRSRVFreeDeviceMem (&psSysContext->s3D, psRenderSurface->psZBufferMemInfo) != PVRSRV_OK)
	{
		DPF((DBG_ERROR,"Couldn't free device memory"));
		return IMG_FALSE;
	}

	return IMG_TRUE;
}

/***********************************************************************************
 Function Name      : GLESServicesInit
 Inputs             : psSysContext
 Outputs            : -
 Returns            : success
 Description        : Initialises the services and fills in the system context.
************************************************************************************/

IMG_BOOL GLESServicesInit(GLESSysContext *psSysContext)
{
	IMG_UINT32 ui32NumDevices, i;
	PVRSRV_DEVICE_IDENTIFIER asDeviceID[PVRSRV_MAX_DEVICES];

#if DEBUG
	DebugInit(DBGPRIV_WARNING);
#elif TIMING || METRIC
	DebugInit(DBGPRIV_MESSAGE);
#endif

	if(GLESServicesConnect(&psSysContext->hServices) != PVRSRV_OK)
	{
		DPF((DBG_ERROR,"Couldn't connect to services"));
		return IMG_FALSE;
	}	

	if(PVRSRVEnumerateDevices(psSysContext->hServices, &ui32NumDevices, asDeviceID) != PVRSRV_OK)
	{
		DPF((DBG_ERROR,"Couldn't enumerate devices"));
		return IMG_FALSE;
	}

	for(i=0; i < ui32NumDevices; i++)
	{
		if(asDeviceID[i].eDeviceClass == PVRSRV_DEVICE_CLASS_3D)
		{
			if(PVRSRVAcquireDeviceData(	psSysContext->hServices, 
										asDeviceID[i].ui32DeviceIndex, 
										&psSysContext->s3D, 
										PVRSRV_DEVICE_TYPE_UNKNOWN)				!= PVRSRV_OK)
			{
				DPF((DBG_ERROR,"Couldn't get device info for 3D device"));
				return IMG_FALSE;
			}
		}
		
		if(asDeviceID[i].eDeviceClass == PVRSRV_DEVICE_CLASS_DISPLAY)
		{
			if(PVRSRVAcquireDeviceData(	psSysContext->hServices, 
										asDeviceID[i].ui32DeviceIndex, 
										&psSysContext->sDisplay,
										PVRSRV_DEVICE_TYPE_UNKNOWN)				!= PVRSRV_OK)
			{
				DPF((DBG_ERROR,"Couldn't get device info for 3D device"));
				return IMG_FALSE;
			}
		}
	}

	if(PVRSRVGetHWInfo(	&psSysContext->s3D, &psSysContext->sHWInfo) != PVRSRV_OK)
	{
		DPF((DBG_ERROR,"Couldn't get HW info"));
		return IMG_FALSE;
	}

	return IMG_TRUE;
}

/***********************************************************************************
 Function Name      : GLESServicesDeInit
 Inputs             : psSysContext
 Outputs            : -
 Returns            : success
 Description        : DeInitialises the services.
************************************************************************************/
IMG_BOOL GLESServicesDeInit(GLESSysContext *psSysContext)
{
	if(PVRSRVReleaseHWInfo(	&psSysContext->s3D, &psSysContext->sHWInfo) != PVRSRV_OK)
	{
		DPF((DBG_ERROR,"Couldn't get HW info"));
		return IMG_FALSE;
	}

	if(PVRSRVReleaseDeviceData(&psSysContext->s3D) != PVRSRV_OK)
	{
		DPF((DBG_ERROR,"Couldn't release 3D device data"));
		return IMG_FALSE;
	}

	if(PVRSRVReleaseDeviceData(&psSysContext->sDisplay) != PVRSRV_OK)
	{
		DPF((DBG_ERROR,"Couldn't release display device data"));
		return IMG_FALSE;
	}

	if(PVRSRVDisconnect(psSysContext->hServices) != PVRSRV_OK)
	{
		DPF((DBG_ERROR,"Couldn't disconnect from services"));
		return IMG_FALSE;
	}

	return IMG_TRUE;
}

/***********************************************************************************
 Function Name      : GLESInitRegs
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        : Sets up some registers.
************************************************************************************/

IMG_VOID GLESInitRegs(GLESContext *gc)
{
	IMG_UINT32 ui32Config, ui32GlobListCtl, ui32ScreenSize, ui32XClip, ui32YClip;
	IMG_UINT32 ui32NumTilesX, ui32NumTilesY, ui32FBCtrl, ui32PixSample, ui32DepthBufferBase, ui32ZLoadStore;
	IMG_FLOAT fClamp = 1.0e-5f;
	IMG_FLOAT fPerp = 1.0e-20f;
	PVRSRV_HWREG *psTARegs = gc->sHWContext.sRegisters.psTARegs;
	PVRSRV_HWREG *ps3DRegs = gc->sHWContext.sRegisters.ps3DRegs;
	PVR3DIF_SHAREDDATA *psSharedData = gc->psRenderSurface->psTARenderInfo->psSharedData;

	ui32NumTilesX = psSharedData->ui32TilesX - 1;
	ui32NumTilesY = psSharedData->ui32TilesY - 1;

	ui32Config = ((ui32NumTilesX << MBX1_TACONFIG_RENDERWIDTHSHIFT) & ~MBX1_TACONFIG_RENDERWIDTHCLRMASK) |
				 (ui32NumTilesY << MBX1_TACONFIG_RENDERHEIGHTSHIFT);

	ui32Config |=	MBX1_TACONFIG_COMPLETEONTERM | 
					MBX1_TACONFIG_PIXELCENTRE | 
					MBX1_TACONFIG_SMALLOBJCULL | 
					MBX1_TACONFIG_INVERTOFFSETALPHA |
					MBX1_TACONFIG_ZLOAD;
	
	ui32GlobListCtl = MBX1_TA_GLOBAL_LIST_CTRL_MAXOBJS_MASK | 4;
	ui32ScreenSize =	(ui32NumTilesX << MBX1_3DSCREENSIZE_RENDER_WIDTH_SHIFT) | 
						(ui32NumTilesY << MBX1_3DSCREENSIZE_RENDER_HEIGHT_SHIFT);
	
	ui32XClip = (gc->sDrawableParams.ui32Width << MBX1_TA_XCLIPMAXSHIFT) | (0 << MBX1_TA_XCLIPMINSHIFT);
	ui32YClip = (gc->sDrawableParams.ui32Height << MBX1_TA_YCLIPMAXSHIFT) | (0 << MBX1_TA_YCLIPMINSHIFT);
	
	GLES_SET_TAREG(psTARegs, TAILPTRBASE, psSharedData->TailPtrDevVAddr.uiAddr);
	GLES_SET_TAREG(psTARegs, REGION_BASE, psSharedData->asRgnHeaderDevVAddr[psSharedData->ui32CurrentRenderData].uiAddr);
	GLES_SET_TAREG(psTARegs, XCLIP, ui32XClip);
	GLES_SET_TAREG(psTARegs, YCLIP, ui32YClip);
	GLES_SET_TAREG(psTARegs, RHWCLAMP, FLOAT_TO_LONG(fClamp));
	GLES_SET_TAREG(psTARegs, RHWCOMP, FLOAT_TO_LONG(fClamp));
	GLES_SET_TAREG(psTARegs, CONFIG, ui32Config);
	GLES_SET_TAREG(psTARegs, GLOBAL_LIST_CTRL, ui32GlobListCtl);
	GLES_SET_TAREG(psTARegs, START, 1);

	ui32PixSample = MBX1_PIXSAMP_FPUPIXEL | MBX1_PIXSAMP_TSPPIXEL | MBX1_PIXSAMP_TSPTEXEL | MBX1_PIXSAMP_DCALCTILEXY;

	switch(gc->psMode->ePixelFormat)
	{
		case PVRSRV_PIXEL_FORMAT_ARGB8888:
			ui32FBCtrl = MBX1_FBCTL_PACKMODE8888;
			break;
		case PVRSRV_PIXEL_FORMAT_RGB565:
			ui32FBCtrl = MBX1_FBCTL_PACKMODE565;
			break;
		case PVRSRV_PIXEL_FORMAT_ARGB1555:
			ui32FBCtrl = MBX1_FBCTL_PACKMODE1555;
			break;
		default:
			DPF((DBG_ERROR,"Unknown pixel format %d, can't set 3D packmode", gc->psMode->ePixelFormat));
			ui32FBCtrl = 0;
			break;
	}
	
	if(gc->psRenderSurface->psZBufferMemInfo)
	{
		IMG_UINT32 ui32Stride;

		ui32DepthBufferBase = gc->psRenderSurface->psZBufferMemInfo->uiDevAddr.uiAddr;
		ui32Stride = (psSharedData->ui32XTilesPerMT * psSharedData->ui32MTilesX) - 1;
		ui32ZLoadStore = MBX1_ZLOADSTORE_ZFORMAT_28F_1M | (ui32Stride << MBX1_ZLOADSTORE_XEXTENTSHIFT);
	}
	else
	{
		/* This will clear depth fullscreen, whether scissor is set or not. This is incorrect, but we don't have
		 * a defined behaviour for accumulating depth without an external depth buffer 
		 */

		ui32DepthBufferBase = 0;
		ui32ZLoadStore = MBX1_ZLOADSTORE_ZFORMAT_NO_EXT_Z | MBX1_ZLOADSTORE_ZLOAD;
	}

	GLES_SET_3DREG(ps3DRegs, ZLOADSTORE, ui32ZLoadStore);
	GLES_SET_3DREG(ps3DRegs, FPUPERPVAL, FLOAT_TO_LONG(fPerp));
	GLES_SET_3DREG(ps3DRegs, FPUCULLVAL, FLOAT_TO_LONG(fPerp));
	GLES_SET_3DREG(ps3DRegs, 3DPIXSAMP, ui32PixSample);
	GLES_SET_3DREG(ps3DRegs, SCALERCTL, 0);
	GLES_SET_3DREG(ps3DRegs, BLENDCTL, MBX1_3DBLENDCONTROL_SUB128);
	GLES_SET_3DREG(ps3DRegs, ARGBSUM, MBX1_ARGBSUM_ADD_RGB);
	GLES_SET_3DREG(ps3DRegs, FBCTL, ui32FBCtrl);
	GLES_SET_3DREG(ps3DRegs, FBSTART, gc->sDrawableParams.ui32HWSurfaceAddress);
	GLES_SET_3DREG(ps3DRegs, FBXCLIP, (gc->sDrawableParams.ui32Width - 1) << MBX1_FBXCLIPMAXSHIFT);
	GLES_SET_3DREG(ps3DRegs, FBYCLIP, (gc->sDrawableParams.ui32Height - 1) << MBX1_FBYCLIPMAXSHIFT);
	GLES_SET_3DREG(ps3DRegs, FBLINESTRIDE, gc->sDrawableParams.ui32Stride >> 2);
	GLES_SET_3DREG(ps3DRegs, ZBASEADDR, ui32DepthBufferBase);
	GLES_SET_3DREG(ps3DRegs, 3DFLATSHADEDCS, 1);
	GLES_SET_3DREG(ps3DRegs, 3D_ZL_BACKGROUND_DEPTH, 0x00000001);
	GLES_SET_3DREG(ps3DRegs, 3DSCREENSIZE, ui32ScreenSize);
	GLES_SET_3DREG(ps3DRegs, OBJBASE, psSharedData->ParamBuffDevVAddr.uiAddr);
	GLES_SET_3DREG(ps3DRegs, STARTRENDER, 1);

}