spfuncs.cpp

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

	SlavePortWrite(
		(((SHORT)rclClip.right  << MBX2D_CLIP_XMAX_SHIFT) & MBX2D_CLIP_XMAX_MASK) |
		(((SHORT)rclClip.left   << MBX2D_CLIP_XMIN_SHIFT) & MBX2D_CLIP_XMIN_MASK) 
		);
	SlavePortWrite(
		(((SHORT)rclClip.top    << MBX2D_CLIP_YMIN_SHIFT) & MBX2D_CLIP_YMIN_MASK) |
		(((SHORT)rclClip.bottom << MBX2D_CLIP_YMAX_SHIFT) & MBX2D_CLIP_YMAX_MASK)
		);

#else
	SlavePortWrite( MBX2D_CLIP_BH |
					((1<<MBX2D_CLIPCOUNT_SHIFT) &
						MBX2D_CLIPCOUNT_MASK) );

	/* Write Clip rectangles to the slave port */
	SlavePortWrite(
		(((SHORT)prclClip->right  << MBX2D_CLIP_XMAX_SHIFT) & MBX2D_CLIP_XMAX_MASK) |
		(((SHORT)prclClip->left   << MBX2D_CLIP_XMIN_SHIFT) & MBX2D_CLIP_XMIN_MASK) 
		);
	SlavePortWrite(
		(((SHORT)prclClip->top    << MBX2D_CLIP_YMIN_SHIFT) & MBX2D_CLIP_YMIN_MASK) |
		(((SHORT)prclClip->bottom << MBX2D_CLIP_YMAX_SHIFT) & MBX2D_CLIP_YMAX_MASK)
		);
#endif
}


BOOL MBX::CanCreateMaskSurf ( GPEBltParms *psParms )
{
	BOOL bRtn = FALSE;

	ASSERT ((psParms->pMask->Format() == gpe1Bpp) || (psParms->pMask->Format() == gpe4Bpp));


	if (!psParms->pMask->InVideoMemory())
	{
		ULONG ulMskWidth ;
		RECTL rclMsk = *psParms->prclMask;
		ULONG ulMskHeight = rclMsk.bottom - rclMsk.top;
		ULONG ulBufferSize = m_ulMaskBufferSize;

		if (psParms->pMask->Format() == gpe1Bpp)
		{
			ulMskWidth = ((rclMsk.right - (rclMsk.left & 0xFFFFFFF8) + 7) >> 3);
		}
		else
		{
			ulMskWidth = ((rclMsk.right - (rclMsk.left & 0xFFFFFFFE) + 1) >> 1);
		}

		/* round up to DWORD alignment */
		ulMskWidth = (ulMskWidth+3) & 0xFFFFFFFC;

		if (m_ulSurfsPresent == (MASK_PRESENT | FILL_PRESENT)) /* eg Text */
		{
			ulBufferSize = m_ulStripeSize;
		}

		if ( ulBufferSize &&
			((ulMskWidth * ulMskHeight) <= ulBufferSize))
		{
			bRtn = TRUE;
		}
	}
	else
	{
		bRtn = TRUE;
	}

	return (bRtn);
}

 
void MBX::SetMaskSurf( GPEBltParms *psParms )
{
	RECTL      rclMsk = *psParms->prclMask;
	ULONG      ulMskHeight, ulMskWidth;
	ULONG      ulMaskBufPhys;
	unsigned char *pbyMsk = (unsigned char *)psParms->pMask->Buffer();
	unsigned char *pbyMskBufLin;
	ULONG      ulMskStride = psParms->pMask->Stride();
	ULONG      ulCnt;

	ASSERT (psParms->pMask->Format() == gpe1Bpp);

	/* Process Mask first as this has to be present unstriped */
	ulMskWidth = (((rclMsk.right - (rclMsk.left & 0xFFFFFFF8)) + 7) >> 3);

	/* round up to DWORD alignment */
	ulMskWidth = (ulMskWidth+3) & 0xFFFFFFFC;
	ulMskHeight = rclMsk.bottom - rclMsk.top;

	pbyMsk += (rclMsk.top * ulMskStride) + (rclMsk.left >> 3);

	if (psParms->pMask->InVideoMemory())
	{
		ulMaskBufPhys = ((MBXSurf*)psParms->pMask)->GetPhysAddr();
	}
	else
	{
		ASSERT (m_pulMaskBufLin);

		/* can use scratch buffer */
		pbyMskBufLin = (BYTE *)m_pulMaskBufLin;

	#if HW_VERIFY
		BUFINFO MaskInfo;

		MaskInfo.ulWidth = rclMsk.right - (rclMsk.left & 0xFFFFFFF8);
		MaskInfo.ulHeight = ulMskHeight;
		MaskInfo.ulStride = ulMskWidth;
		MaskInfo.pvLinAddr = (PVOID)pbyMskBufLin;
		MaskInfo.ulPhysBase = m_ulMaskBufPhys;

		m_clHwVer.UpdateMaskBufInfo(&MaskInfo);
	#endif

		for (ulCnt = 0; ulCnt < ulMskHeight; ulCnt++)
		{
			memcpy (pbyMskBufLin, pbyMsk, ulMskWidth);
			pbyMsk += ulMskStride;
			pbyMskBufLin += ulMskWidth;
		}

		ulMaskBufPhys = m_ulMaskBufPhys;
	}

	/* specify mask, x,y */
	SlavePortWrite(MBX2D_MASK_OFF_BH |
					((rclMsk.left & 0x7)<<MBX2D_MASKOFF_XSTART_SHIFT) & MBX2D_MASKOFF_XSTART_MASK );

	SlavePortWrite(MBX2D_MASK_SIZE_BH |
					(((rclMsk.right - (rclMsk.left & 0xFFFFFFF8)) << MBX2D_MASK_WIDTH_SHIFT) & MBX2D_MASK_WIDTH_MASK) |
					((ulMskHeight << MBX2D_MASK_HEIGHT_SHIFT) & MBX2D_MASK_HEIGHT_MASK) );

	SlavePortWrite(MBX2D_MASK_CTRL_BH |
					MBX2D_MASK_FBMEM |
					(ulMskWidth<<MBX2D_MASK_STRIDE_SHIFT) &
					MBX2D_MASK_STRIDE_MASK );

	SlavePortWrite(((ulMaskBufPhys
					>>	MBX2D_MASK_ADDR_ALIGNSHIFT)
					<<	MBX2D_MASK_ADDR_SHIFT)
					&	MBX2D_MASK_ADDR_MASK );

}


BOOL MBX::SetPatSurf( GPEBltParms *pParms )
{
	GPESurf *pPat = pParms->pBrush;
	ULONG    ulMemType, ulHWPatAddr;
	ULONG    ulWidth = pPat->Width();
	BYTE    *pbyPatBuffer = (BYTE *)pPat->Buffer();
	ULONG    ulStride = abs(pPat->Stride()); /* make +ve always */
	ULONG    ulHeight = pPat->Height();
	ULONG    ulHWFormat;

#ifdef CACHE_SURFACES
	if ( (pbyPatBuffer != m_s2DContext.pvPatLinAddr) ||
		 (!pPat->InVideoMemory()))
	{
		/* set-up details in the 2DContext */
		m_s2DContext.pvPatLinAddr = pbyPatBuffer;
#endif
		#ifdef PDUMP
		PDumpScript("-- PAT surface attributes");
		#endif

		/* can we support the pattern */
		if( (ulWidth > MAX_BRUSH_SIZE) || (ulHeight > MAX_BRUSH_SIZE))
		{
			return (FALSE);
		}

		EGPEFormat ePatFmt = pPat->Format();

		if ((pParms->pDst->Format() == gpe8Bpp) &&	/* 332RGB */
			(ePatFmt == gpe8Bpp) &&					/* 332RGB or PAL */
			(pParms->pLookup == NULL))				/* treat as 332RGB */
		{
			ulHWFormat = MBX2D_SRC_332RGB;
		}
		else
		{
			ulHWFormat = EGPEFormatToSrcHW[ePatFmt];

			/* set-up the palette? */
			if (ePatFmt <= gpe8Bpp)
			{
				/*
				 * Should we enable 24 bit MBX palette traslations for this case too ?
				 * HWVerify will tell us, until then the fifth param will be 0.
				 */

				if (!SetMBXPalette( pParms, ePatFmt, ePatPalette) )
				{
					return (FALSE);
				}
			}
		}

		if (!pPat->InVideoMemory())
		{
			ulMemType   = MBX2D_PAT_FBMEM;

			if ((ulStride * ulHeight) > m_ulPatternBufSize)
			{
				return (FALSE);
			}
			
			ulHWPatAddr = (ULONG) m_ulPatternFBMemPhys;

			if (pPat->Stride() < 0)
			{
				BYTE *pbyDstPat = m_pbyPatternFBMem;

				/* -ve stride */
				for (ULONG ulLine = 0; ulLine < ulHeight; ulLine++)
				{
					memcpy(pbyDstPat, pbyPatBuffer, ulStride);
					pbyDstPat += ulStride;
					pbyPatBuffer -= ulStride;
				}
			}
			else
			{
				memcpy(m_pbyPatternFBMem, pbyPatBuffer, ulStride * ulHeight);
			}
		}
		else
		{
			ulMemType   = MBX2D_PAT_FBMEM;
			ulHWPatAddr = ((MBXSurf*)pPat)->GetPhysAddr();
		}

		SlavePortWrite(MBX2D_PAT_CTRL_BH
					|  ulMemType
					|  ulHWFormat
					|  ((ulStride << MBX2D_PAT_STRIDE_SHIFT)
						& MBX2D_PAT_STRIDE_MASK) );

		SlavePortWrite(((ulHWPatAddr
					>>	MBX2D_PAT_ADDR_ALIGNSHIFT)
					<<	MBX2D_PAT_ADDR_SHIFT)
					&	MBX2D_PAT_ADDR_MASK );


#ifdef CACHE_SURFACES
	}
#endif
	
	return (TRUE);
} /* SetPatSurf */


VOID MBX::SetPatHotspot (GPEBltParms *pParms )
{
	RECTL   *prclDst = pParms->prclDst;
	GPESurf *pPat = pParms->pBrush;
	ULONG    ulWidth = pPat->Width();
	ULONG    ulHeight = pPat->Height();
	ULONG    ulHWOriginX, ulHWOriginY;
	POINTL  *BrushOrigin = pParms->pptlBrush;

	/*
	 * we have to fiddle the HW just a little bit here:
	 * the HW maps the pattern origin to the rectangle origin
	 * but GDI expects the origin to map to surface origin
	 */
	if (prclDst)
	{
		ulHWOriginX = (prclDst->left + ulWidth - BrushOrigin->x) % ulWidth;
		ulHWOriginY = (prclDst->top + ulHeight - BrushOrigin->y) % ulHeight;
	}
	else
	{
		/* assume top left is 0,0 */
		ulHWOriginX = (ulWidth  - BrushOrigin->x) % ulWidth;
		ulHWOriginY = (ulHeight - BrushOrigin->y) % ulHeight;
	}

	/* specify pattern hotspot, w, h */
	SlavePortWrite(MBX2D_PAT_BH
				|  ((ulWidth     << MBX2D_PAT_WIDTH_SHIFT) & MBX2D_PAT_WIDTH_MASK)
				|  ((ulHeight    << MBX2D_PAT_HEIGHT_SHIFT) & MBX2D_PAT_HEIGHT_MASK)
				|  ((ulHWOriginX << MBX2D_PAT_XSTART_SHIFT) & MBX2D_PAT_XSTART_MASK)
				|  ((ulHWOriginY << MBX2D_PAT_YSTART_SHIFT) & MBX2D_PAT_YSTART_MASK) );
}


BOOL MBX::CheckSrcPalette (GPEBltParms *psParms)
{
	BOOL bRtn = TRUE;

	EGPEFormat eSrcFmt = psParms->pSrc->Format();

	/* set-up the palette */
	if ((eSrcFmt <= gpe8Bpp) &&
		!SetMBXPalette(psParms, eSrcFmt, eSrcPalette))
	{
		bRtn = FALSE;
	}

	return (bRtn);
}


void MBX::SlavePortWrite(ULONG ulValue)
{
	m_ulaSlavePort[m_ulSlavePortIdx++] = ulValue;

	if (m_ulSlavePortIdx == MAX_SP_ENTRIES)
	{
		ACQUIRE_2D_FIFOSPACE(m_ulSlavePortIdx);
		SLAVEPORT_WRITE2DDW_REPEAT(m_ulaSlavePort, m_ulSlavePortIdx);
		m_ulSlavePortIdx = 0;
	}
}


void MBX::SlavePortFencedWrites(void)
{
	SlavePortWrite(MBX2D_FENCE_BH);

	ACQUIRE_2D_FIFOSPACE(m_ulSlavePortIdx);
	SLAVEPORT_WRITE2DDW_REPEAT(m_ulaSlavePort, m_ulSlavePortIdx);
	m_ulSlavePortIdx = 0;
}


void MBX::SlavePortFlushWrites(void)
{
	if (m_ulSlavePortIdx)
	{
		ACQUIRE_2D_FIFOSPACE(m_ulSlavePortIdx);
		SLAVEPORT_WRITE2DDW_REPEAT(m_ulaSlavePort, m_ulSlavePortIdx);
		m_ulSlavePortIdx = 0;
	}
}


void MBX::SlavePortInitWrites(void)
{
	m_ulSlavePortIdx = 0;
}


/********************************** end of file ******************************/