hxfslaveport.c

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

/* ************************************************************************* *\
**
**    INTEL Corporation Proprietary Information
**
**    This listing is supplied under the terms of a license
**    agreement with INTEL Corporation and may not be copied
**    nor disclosed except in accordance with the terms of
**    that agreement.
**
**    Copyright (c) 2003 Intel Corporation.
**    All Rights Reserved.
**
** ************************************************************************* **
**	FILE: HXFSlaveport.c
**	DESCRIPTION: Manages access to the Marathon Slaveport
**
**	AUTHOR: Cian Montgomery
**	CREATED: December 06, 2003
**
\* ************************************************************************* */
#include "MRL.h"
#include "HXFProfiler.h"

#ifndef HXF_HARNESS

#include "Context.h"
#include "SysConfig.h"
#include "mbx1defs.h"

/* ************************************************************************* *\
	Slaveport interface procs
\* ************************************************************************* */
#ifdef USE_TERMINATE_WORD
	// Marathon does not support this.
	#pragma error("Using Terminate control word\n")
#else
	#pragma message("!!!!NOT Using Terminate control word!!!!\n")
#endif

#ifdef PDUMP
	#pragma message("!!!!PDUMPING!!!!\n")
#endif

extern void* HXFSPWrite5(void* pSP, void* pVtx0);
extern void* HXFSPWrite6(void* pSP, void* pVtx0);
extern void* HXFSPWrite7(void* pSP, void* pVtx0);
extern void* HXFSPWrite8(void* pSP, void* pVtx0);
extern void* HXFSPWrite9(void* pSP, void* pVtx0);
extern void* HXFSPWrite10(void* pSP, void* pVtx0);


void* HXFSP5Proc_C  ( void* pSP, void* pVtx0, void* pVtx1, void* pVtx2 );
void* HXFSP6Proc_C  ( void* pSP, void* pVtx0, void* pVtx1, void* pVtx2 );
void* HXFSP7Proc_C  ( void* pSP, void* pVtx0, void* pVtx1, void* pVtx2 );
void* HXFSP8Proc_C  ( void* pSP, void* pVtx0, void* pVtx1, void* pVtx2 );
void* HXFSP9Proc_C  ( void* pSP, void* pVtx0, void* pVtx1, void* pVtx2 );
void* HXFSP10Proc_C ( void* pSP, void* pVtx0, void* pVtx1, void* pVtx2 );

HXFSPProc s_SPProcs[] =
{
	NULL, // 0 Words
	NULL, // 1 Words
	NULL, // 2 Words
	NULL, // 3 Words
	NULL, // 4 Words // All prior formats not valid
	HXFSP5Proc_C, // 5 Words
	HXFSP6Proc_C, // 6 Words
	HXFSP7Proc_C, // 7 Words
	HXFSP8Proc_C, // 8 Words
	HXFSP9Proc_C, // 9 Words
	HXFSP10Proc_C, // 10 Words  XYZW(4), D(1), S(1), T1(2), T2(2)
};


/* ************************************************************************* *\
	FUNCTION: HXFBeginClippedTriList
	DESCRIPTION:
\* ************************************************************************* */
void* HXFBeginClippedTriList( void* pvContext )
   {
   MRLState* pState = (MRLState*)pvContext;
   HUINT32 PrimHdr = pState->PrimitiveHeader;
   HUINT32 pSP = pState->SPAddr;
   HUINT32 pSPBaseAddr = pState->SPBaseAddr;
   HUINT32 SPSpace = pState->SPReservedSpace;

   while(SPSpace < 4)
      {
      if(PVRSRVAcquire3DFifoSpace(	
         pState->pHWState->ps3DDevData->psDevInfoUM,
         pState->pHWState->psHWInfo,
         &SPSpace ) != PVRSRV_OK)
         {
         SPSpace = 0;
         return pState;
         }
      }

   if(((pSP + 4) - pSPBaseAddr) >= MBX_TA_SP_DATA_RANGE)
      {
      pSP = pSPBaseAddr;
      }

   PrimHdr = PrimHdr & MBX1_TAOBJTYPE_TYPECLRMASK;
   PrimHdr = PrimHdr & MBX1_TAPRIM_CULLMODECLRMASK;
   PrimHdr |= (MBX1_TAOBJTYPE_VERTEXFACELIST | MBX1_TAPRIM_CULLMODENONE);
   *((HUINT32*)pSP) = PrimHdr;

   PVRSRVRelease3DFifoSpace( pState->pHWState->ps3DDevData->psDevInfoUM, 4 );

   pState->SPReservedSpace = SPSpace - 4;
   pState->SPAddr = pSP + 8;

   return pState;

   }  /* HXFBeginClippedTriList */


/* ************************************************************************* *\
	FUNCTION: HXFBeginClippedLineList
	DESCRIPTION:
\* ************************************************************************* */
void* HXFBeginClippedLineList( void* pvContext )
   {
   MRLState* pState = (MRLState*)pvContext;
   HUINT32 PrimHdr = pState->PrimitiveHeader;
   HUINT32 pSP = pState->SPAddr;
   HUINT32 pSPBaseAddr = pState->SPBaseAddr;
   HUINT32 SPSpace = pState->SPReservedSpace;

   while(SPSpace < 8)
      {
      if( PVRSRVAcquire3DFifoSpace(
         pState->pHWState->ps3DDevData->psDevInfoUM,
         pState->pHWState->psHWInfo,
         &SPSpace ) != PVRSRV_OK)
         {
         SPSpace = 0;
         return pState;
         }
      }

   if(((pSP + 8) - pSPBaseAddr) >= MBX_TA_SP_DATA_RANGE)
      {
      pSP = pSPBaseAddr;
      }

   PrimHdr =  (PrimHdr & MBX1_TAOBJTYPE_TYPECLRMASK) | MBX1_TAOBJTYPE_VERTEXLINESTRIP;
   *((HUINT32*)(pSP)) = PrimHdr;
   *((float*)(pSP+4)) = pState->PrimitiveSize;

   PVRSRVRelease3DFifoSpace( pState->pHWState->ps3DDevData->psDevInfoUM, 8 );

   pState->SPReservedSpace = SPSpace - 8;
   pState->SPAddr = pSP + 8;

   return pState;

   }  /* HXFBeginClippedLineList */


/* ************************************************************************* *\
	FUNCTION: HXFBeginPrimitiveList
	DESCRIPTION:
	stripDirection:
		0: no effect
		1: CCW
	    Anything else: CW
\* ************************************************************************* */
void* HXFBeginPrimitiveList( void* pvContext, void* pVtx1, void* pVtx2, 
      CTLU32 u32StripDirection )
   {
   MRLState* pState      = (MRLState*)pvContext;
   HUINT32   pSP         = pState->SPAddr;
   HUINT32   pSPBaseAddr = pState->SPBaseAddr;
   HUINT32   SPSpace     = pState->SPReservedSpace;
   HUINT32   PrimHdr     = pState->PrimitiveHeader;
   HUINT32   SpaceNeeded = 4;

   if( pState->Flags & HXF_HAS_PRIMITIVE_SIZE )
      {
      SpaceNeeded += 4;
      }  // if

   while( SPSpace < SpaceNeeded )
      {
      if( PVRSRVAcquire3DFifoSpace(
         pState->pHWState->ps3DDevData->psDevInfoUM,
         pState->pHWState->psHWInfo,
         &SPSpace ) != PVRSRV_OK )
         {
         SPSpace = 0;
         return pState;
         }  // if
      }  // while

   if((( pSP + SpaceNeeded ) - pSPBaseAddr ) >= MBX_TA_SP_DATA_RANGE )
      {
      pSP = pSPBaseAddr;
      }  // if

   if( u32StripDirection && !(( pState->Flags & HXF_CULL_MASK ) == HXF_CULL_NONE ))
      {
      PrimHdr &= MBX1_TAPRIM_CULLMODECLRMASK;
      if( u32StripDirection == 1 )
         {
         PrimHdr |= MBX1_TAPRIM_CULLMODECCW;
         }  // if
      else
         {
         PrimHdr |= MBX1_TAPRIM_CULLMODECW;
         }  // else
      }  // if

   *((HUINT32*)(pSP)) = PrimHdr;
   if(pState->Flags & HXF_HAS_PRIMITIVE_SIZE)
      {
      *((float*)(pSP+4)) = pState->PrimitiveSize;
      }  // if

   PVRSRVRelease3DFifoSpace( pState->pHWState->ps3DDevData->psDevInfoUM, SpaceNeeded );

   pState->SPReservedSpace = SPSpace - SpaceNeeded;
   pState->SPAddr = pSP + 8;

   if( pVtx1 )
      {
      return pState->pSPProc( pState, pVtx1, pVtx2, NULL );
      }  // if

   return pState;

   }  /* HXFBeginPrimitiveList */


/* ************************************************************************* *\
	FUNCTION:
	DESCRIPTION:
\* ************************************************************************* */
void* HXFEndPrimitiveList( void* pvContext )
   {
   MRLState* pState  = (MRLState*)pvContext;
   HUINT32   pSPTerm = pState->SPTermAddr;
   HUINT32   SPSpace = pState->SPReservedSpace;

   while( SPSpace < 4 )
      {
      if( PVRSRVAcquire3DFifoSpace( 
         pState->pHWState->ps3DDevData->psDevInfoUM,
         pState->pHWState->psHWInfo,
         &SPSpace ) != PVRSRV_OK )
         {
         SPSpace = 0;
         return pState;
         }  // if
      }  // while

   *((HUINT32*)(pSPTerm)) = 1;

   pState->SPReservedSpace = SPSpace - 4;

   PVRSRVRelease3DFifoSpace( pState->pHWState->ps3DDevData->psDevInfoUM, 4 );

   return pState;

   }  /* HXFEndPrimitiveList */


/* ************************************************************************* *\

\* ************************************************************************* */
void* HXFSP5Proc_C(void* pvContext, void* pVtx0, void* pVtx1, void* pVtx2)
{
#define OVS (5*4)
   MRLState* pState  = (MRLState*)pvContext;
	HUINT32* pSP = (HUINT32*)pState->SPAddr;
	HUINT32 pSPBase = pState->SPBaseAddr;
	HUINT32 SPSpace = pState->SPReservedSpace;
	HUINT32 DataToWrite = 0;
	HUINT32* pSrc = 0;

	HXF_PROFILER_TRANSITION(HXFPROFILE_DRAW_SLAVEPORT);

	DataToWrite = OVS;
	if(pVtx1)
	{
		DataToWrite += OVS;
	}

	if(pVtx2)
	{
		DataToWrite += OVS;
	}

	HXF_PROFILER_INC_COUNTER( HXFPROFILE_COUNTER_SP_BYTES, DataToWrite);

	while(SPSpace < DataToWrite)
	{
		if( PVRSRVAcquire3DFifoSpace(
         pState->pHWState->ps3DDevData->psDevInfoUM,
         pState->pHWState->psHWInfo,
         &SPSpace ) != PVRSRV_OK)
		{
			SPSpace = 0;
			return pState;
		}
	}

	 if(((((HUINT32)pSP) + (DataToWrite + 12)) - pSPBase) >= MBX_TA_SP_DATA_RANGE)
	 {
		pSP = (HUINT32*)pSPBase;
	 }

	// Vertex 0
	pSP = HXFSPWrite5(pSP, pVtx0);

	// Vertex 1
	if(pVtx1)
	{
		pSP = HXFSPWrite5(pSP, pVtx1);
	}

	// Vertex 2
	if(pVtx2)
	{
		pSP = HXFSPWrite5(pSP, pVtx2);
	}

	// Managed reserved space.
	PVRSRVRelease3DFifoSpace( pState->pHWState->ps3DDevData->psDevInfoUM, DataToWrite );
	pState->SPAddr = (HUINT32)pSP;
	SPSpace -= DataToWrite;
	pState->SPReservedSpace = SPSpace;

	HXF_PROFILER_TRANSITION(HXFPROFILE_DRAW_ASSEMBLE);
	return pState;

#undef OVS
}

void* HXFSP6Proc_C(void* pvContext, void* pVtx0, void* pVtx1, void* pVtx2)
{
#define OVS (6*4)
   MRLState* pState  = (MRLState*)pvContext;
	HUINT32* pSP = (HUINT32*)pState->SPAddr;
	HUINT32 pSPBase = pState->SPBaseAddr;
	HUINT32 SPSpace = pState->SPReservedSpace;
	HUINT32 DataToWrite = 0;
	HUINT32* pSrc = 0;