hwverify.cpp

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

			}
		}
	}
	else
	{	
		/* Now do each row */
		for (lYIdx = ulY-1; lYIdx >= 0; lYIdx--)
		{
			PVOID	   pvCurPix=(PVOID)((PBYTE)pvData + (lYIdx * ulStride));
			ULONG	   ulLinPadding;		
			RGBTRIPLE *psWritePix = psLineStore;

			for (ulXIdx=0; ulXIdx < ulX; ulXIdx++, psWritePix++)
			{
				switch (ulBpp)
				{
					case 16 :
					{
						PWORD	pwPix=(PWORD)pvCurPix;
						
						psWritePix->rgbtBlue  = (BYTE)MBXReplicate((*pwPix << 3), 0xF8, 5, 1);
						psWritePix->rgbtGreen = (BYTE)MBXReplicate((*pwPix >> 3), 0xFC, 6, 1);
						psWritePix->rgbtRed   = (BYTE)MBXReplicate((*pwPix >> 8), 0xF8, 5, 1);
						pvCurPix = (PVOID)(((PWORD)pvCurPix)+1);
						break;
					}
					case 24 :
					{
						PBYTE	pbyPix=(PBYTE)pvCurPix;
						
						psWritePix->rgbtBlue  = *pbyPix;
						psWritePix->rgbtGreen = *(pbyPix+1);
						psWritePix->rgbtRed   = *(pbyPix+2);
						pvCurPix=(PVOID)(((PBYTE)pvCurPix)+3);
						break;
					}
					case 32 :
					{
						PBYTE	pbyPix = (PBYTE)pvCurPix;
						
						psWritePix->rgbtBlue  = *pbyPix;
						psWritePix->rgbtGreen = *(pbyPix+1);
						psWritePix->rgbtRed   = *(pbyPix+2);
						pvCurPix=(PVOID)(((PBYTE)pvCurPix)+4);
						break;
					}
					default :
					{
						DPFINFO((L"CreateBmp : a bit depth of %ld is not supported", ulBpp));
						DebugBreak();
						FreeSharedMem(psLineStore);
						CloseHandle(hFile);
						return (FALSE);
					}
				}
			}

			/* Each line of pixels needs to be a multiple DWORD in size */
			if (((ulX * sizeof(RGBTRIPLE)) % 4) != 0)
			{
				ulLinPadding = sizeof(ULONG) - ((ulX * sizeof(RGBTRIPLE)) % 4);
			}
			else
			{
				ulLinPadding = 0;
			}
			
			/* Now write out line of pixels and padding */
			if (WriteFile(hFile, psLineStore, (ulX * sizeof(RGBTRIPLE)) + ulLinPadding, &ulBytesWritten, NULL) == FALSE)
			{
				DPFERROR((L"CreateBmp : Failed to write pixel"));
				FreeSharedMem(psLineStore);
				CloseHandle(hFile);
				return (FALSE);
			}
		}
	}

	/* Close file */
	CloseHandle(hFile);

	/* Free mem */
	FreeSharedMem(psLineStore);

	return (TRUE);
}



/**************************************************************************
 * Function Name  : CopySurface
 * Inputs         : pbySrc - ptr to source surface
 *				  : ulSrcDx - X size of source surface
 *				  : ulSrcDy - Y size of source surface
 *				  : ulSrcStride - Stride of source surface
 *                : pbyDst - ptr to destination surface
 *				  : ulDstStride - Stride of destination surface
 *				  : ulBPP - Bits per pixel 
 * Outputs        : None
 * Returns        : None
 * Description    : Copy src suface to dst surface
**************************************************************************/
void CopySurface(PBYTE pbySrc, ULONG ulSrcDx, ULONG ulSrcDy, ULONG ulSrcStride, PBYTE pbyDst, ULONG ulDstStride, ULONG ulBPP)
{
	PBYTE	pbyCurDst = pbyDst;
	PBYTE	pbyCurSrc = pbySrc;
	ULONG	ulScanLines;
	ULONG	ulLineLength = (ulSrcDx * ulBPP) / 8;

	/* Assumes surface to copy is at 0,0 in source surface */
	if (ulLineLength == ulDstStride && ulDstStride == ulSrcStride)
	{
		memcpy(pbyCurDst, pbyCurSrc, ulLineLength * ulSrcDy);
	}
	else
	{
		for (ulScanLines = 0; ulScanLines < ulSrcDy; ulScanLines++)
		{
			memcpy(pbyCurDst, pbyCurSrc, ulLineLength);
			pbyCurDst += ulDstStride;
			pbyCurSrc += ulSrcStride;
		}
	}

	return;
}

#endif // HW_VERIFY


/***********************************************************************************
 Function Name	: DrvEscapeHWVerify
 Inputs			: 
 Outputs		: 
 Returns		: 
 Globals Used	: 
 Description	: 
************************************************************************************/
void CHWVerify::DrvEscapeHWVerify(PDRVESC_HWVERIFY_PARAMS psHwVerIn, PDRVESC_HWVERIFY_PARAMS psHwVerOut)
{
	if (psHwVerIn->dwFlags & DRVESC_HWVERIFY_FLAG_GET)
	{
		memset(psHwVerOut,0,sizeof(DRVESC_HWVERIFY_PARAMS));
		psHwVerOut->bEnabled = m_bEnabled;
		psHwVerOut->bPDumpFailures = m_bPDumpFailures;
		psHwVerOut->bUnattendedMode = m_bUnattendedMode;

		switch (m_eVerDst)
		{
			case VERDST_RECT:
				psHwVerOut->eVerDst = HWVERIFY_DST_RECT;
				break;
			case VERDST_RECT_PLUS:
				psHwVerOut->eVerDst = HWVERIFY_DST_RECT_PLUS;
				break;
			case VERDST_ALL:
				psHwVerOut->eVerDst = HWVERIFY_DST_ALL;
				break;
		}
	}
	
	if (psHwVerIn->dwFlags & DRVESC_HWVERIFY_FLAG_SET)
	{
		m_bEnabled = psHwVerIn->bEnabled;
		m_bPDumpFailures = psHwVerIn->bPDumpFailures;
		m_bUnattendedMode = psHwVerIn->bUnattendedMode;

		switch (psHwVerIn->eVerDst)
		{
			case HWVERIFY_DST_RECT:
				m_eVerDst = VERDST_RECT;
				break;

			case HWVERIFY_DST_RECT_PLUS:
				m_eVerDst = VERDST_RECT_PLUS;
				break;

			case HWVERIFY_DST_ALL:
				m_eVerDst = VERDST_ALL;
				break;
		}
	}
}


/***********************************************************************************
 Function Name	: CHWVerify::Enable
 Inputs			: bPDumpFailures, bUnattendedMode, eVerDst
 Outputs		: None
 Returns		: void
 Globals Used	: None
 Description	: Enables hardware verification
************************************************************************************/
void CHWVerify::Enable(BOOL bPDumpFailures, BOOL bUnattendedMode, VERDST eVerDst)
{
	m_bEnabled = TRUE;
	m_bPDumpFailures = bPDumpFailures;
	m_bUnattendedMode = bUnattendedMode;
	m_eVerDst = eVerDst;
}
// Default overload
void CHWVerify::Enable()
{
	// Default
	Enable(TRUE, FALSE, VERDST_RECT);
#if PDUMP
	PDumpStart();
#endif
}


/***********************************************************************************
 Function Name	: CHWVerify::Disable()
 Inputs			: None
 Outputs		: None
 Returns		: Error code
 Globals Used	: None
 Description	: Disables hardware verification
************************************************************************************/
void CHWVerify::Disable()
{
	m_bEnabled = FALSE;
#if PDUMP
	PDumpStop();
#endif
}


/*****************************************************************************
 FunctionName   : BuildPrmFile
 Inputs         : PEBltParms *psParms
 Outputs        : creates out.prm
 Returns        : none
 Globals used   : none
 Description    : Creates a binary file of all the input bitmaps
*****************************************************************************/
void CHWVerify::BuildPrmFile(GPEBltParms *psParms)
{
	TCHAR		tszBuf[128];
	HANDLE		hFile;
	ULONG		ulImagePos = 0;


	wcscpy(tszBuf, m_tszHWVerPath);
	wcscat(tszBuf, L"\\out.prm");

	/* Open file */
	hFile = CreateFile(tszBuf, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH, 0);
	if (hFile == INVALID_HANDLE_VALUE)
	{
		DPFERROR((L"BuildPrmFile : Failed to create file %s", tszBuf));
		return;
	}

	if (m_bPDumpFailures == TRUE)
	{
		ULONG	ulBytesWritten;
		CHAR	szBuffer[64];

		strcpy(m_szLDBList, "-- FB setup\r\n");

		if (WriteFile(hFile,
					  m_pvDestPDumpCopy,
					  psParms->pDst->Stride() * psParms->pDst->Height(),
					  &ulBytesWritten,
					  NULL) == FALSE)
		{
			DPFERROR((L"AppendGPEBM : Failed to write bitmap"));
			return;
		}

		if (ulBytesWritten)
		{
			sprintf((CHAR *)&szBuffer,
					(CHAR *)"LDB :FB:%8.8lX %8.8lX %8.8lX %%0%%.prm\r\n",
					((MBXSurf*)psParms->pDst)->GetPhysAddr(),	/* relative to base */
					ulImagePos,
					ulBytesWritten);

			strcat((CHAR *)&m_szLDBList, (CHAR *)&szBuffer);

			ulImagePos += ulBytesWritten;
		}
	}

	// Note that xPositive and yPositive will be wrong for rotated blts.
	if ((psParms->xPositive && psParms->yPositive) &&
		(psParms->pSrc != psParms->pDst))
	{
		/* no overlap */
		AppendBM("Src Bitmap", hFile, &ulImagePos, (MBXSurf *)psParms->pSrc, (PRECT)psParms->prclSrc);
	}

	AppendBM("Brush", hFile, &ulImagePos, (MBXSurf *)psParms->pBrush, (PRECT)psParms->pptlBrush);
	AppendBM("Mask",  hFile, &ulImagePos, (MBXSurf *)psParms->pMask,  (PRECT)psParms->prclMask);

	if (psParms->pLookup)
	{
		AppendVidMem ( "Pat palette",
						hFile,
						&ulImagePos,
						m_psPalInfo->prgbqPatPalette,
						m_psPalInfo->ulPatPalettePhys,
						m_psPalInfo->ulPatPaletteSize);
		AppendVidMem ( "Src palette",
						hFile,
						&ulImagePos,
						m_psPalInfo->prgbqSrcPalette,
						m_psPalInfo->ulSrcPalettePhys,
						m_psPalInfo->ulSrcPaletteSize);
	}

	if (m_nBufInfoIndex)
	{
		int nStart = m_nBufInfoIndex - (NUM_OF_STRIPED_BUFFERS);

		if (nStart < 0)
		{
			nStart = 0;
		}

		for (int cnt = nStart; cnt < m_nBufInfoIndex; cnt++)
		{
			AppendVidMem("Stripe",
						 hFile,
						 &ulImagePos,
						 m_VidBuffInfo[cnt].pvLinAddr,
						 m_VidBuffInfo[cnt].ulPhysBase,
						 m_VidBuffInfo[cnt].ulStride * m_VidBuffInfo[cnt].ulHeight);
		}
	}

	/* Close file */
	CloseHandle(hFile);

	return;
}


void CHWVerify::AppendBM(PCHAR pszCaption, HANDLE hFile, ULONG *pulImagePos, MBXSurf *psSurface, PRECT psRect)
{
	if (psSurface && psSurface->InVideoMemory())
	{
		ULONG	ulHeight = psSurface->Height();
		ULONG	ulBytesWritten;
		CHAR	szBuffer[64];

		if (ulHeight == 0)
		{
			ulHeight = RectHeight(psRect);
		}

		if (WriteFile(hFile,
					  psSurface->Buffer(),
					  psSurface->Stride() * ulHeight,
					  &ulBytesWritten,
					  NULL) == FALSE)
		{
			DPFERROR((L"AppendBM : Failed to write bitmap"));
			return;
		}

		if (ulBytesWritten)
		{
			sprintf(szBuffer, "-- %s\r\nLDB :FB:%8.8lX %8.8lX %8.8lX %%0%%.prm\r\n",
					pszCaption,
					psSurface->GetPhysAddr(),	/* relative to base */
					*pulImagePos,
					ulBytesWritten);

			strcat(m_szLDBList, szBuffer);

			*pulImagePos += ulBytesWritten;
		}
	}
}


void CHWVerify::AppendVidMem(PCHAR pszCaption, HANDLE hFile, ULONG *pulImagePos, VOID *pvMem, ULONG ulPhyMem, ULONG ulSize)
{
	ULONG	ulBytesWritten;
	CHAR	szBuffer[64];

	if (WriteFile(hFile,
				  pvMem,
				  ulSize,
				  &ulBytesWritten,
				  NULL) == FALSE)
	{
		DPFERROR((L"AppendBM : Failed to write bitmap"));
		return;
	}

	if (ulBytesWritten)
	{
		sprintf(szBuffer, "-- %s\r\nLDB :FB:%8.8lX %8.8lX %8.8lX %%0%%.prm\r\n",
				pszCaption,
				ulPhyMem,	/* relative to base */
				*pulImagePos,
				ulBytesWritten);

		strcat(m_szLDBList, szBuffer);

		*pulImagePos += ulBytesWritten;
	}
}


 /******************************************************************************
 * Function Name: HwReplicate
 *
 * Inputs       : ULONG ulData, ulMask, ulShift, ulCount
 * Outputs      : -
 * Returns      : ULONG ulData
 * Globals Used : -
 *
 * Description  : Given a mask will relicate data shifted by n bit m times
 * Pre-condition:
 *****************************************************************************/
ULONG HwReplicate(ULONG ulData, ULONG ulMask, ULONG ulShift, int nCount)
{
	ULONG ulBits;
	int   nCnt;

	ulBits = ulData & ulMask;
	ulData = 0;

	for (nCnt=0; nCnt <= nCount; nCnt++)
	{
		ulData = ulData | (ulBits >> (ulShift * nCnt));
	}

	return ulData;
}


/******************************************************************************
 * Function Name: HwDestToABGR
 *
 * Inputs       : - EGPEFormat eFormat, ULONG ulPixel
 * Outputs      : - ULONG ABGR
 * Returns      : -
 * Globals Used : -
 *
 * Description  : Hardware Verify version of Convert pixel/palette to ABGR 888
 * Pre-condition:
 *****************************************************************************/
static ULONG HwDestToABGR(EGPEFormat eFormat, ULONG ulPixel)
{
	ULONG ulR = 0, ulG = 0, ulB = 0, ulA = 0;

	switch (eFormat)
	{
		case gpe8Bpp:
			ulB = HwReplicate( ulPixel,       0xE0, 3, 2);
			ulG = HwReplicate((ulPixel << 3), 0xE0, 3, 2);
			ulR = HwReplicate((ulPixel << 6), 0xC0, 2, 3);
			break;

		case gpe16Bpp:
			ulB = HwReplicate((ulPixel >> 8), 0xF8, 5, 1);
			ulG = HwReplicate((ulPixel >> 3), 0xFC, 6, 1);
			ulR = HwReplicate((ulPixel << 3), 0xF8, 5, 1);
			break;

		case gpe32Bpp:
			ulA = ((ulPixel >> 24) & 0xFF);

		case gpe24Bpp:
			ulB = ((ulPixel >> 16) & 0xFF);
			ulG = ((ulPixel >>  8) & 0xFF);
			ulR = ((ulPixel >>  0) & 0xFF);
			break;
	}

	return (ulA<<24 | ulB<<16 | ulG<<8 | ulR);
}


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