config.cpp

WinCE 3.0 BSP, 包含Inter SA1110, Intel_815E, Advantech_PCM9574 等

#include "precomp.h"
#include "mqmacro.h"
#include "modes.h"
#include "panels.h"
#include "registry.h"		//Registry string common to MQCONFIG

//#define	FLEX_PLL		//Use flexible PLL initialization mechanism
#include "plls.h"
#include "mqconfig.h"

//#ifdef	MIPS_TOS
//#include "TX39.h"
//#define	TX_REGS_SIZE	256
//#endif

//#include	"bcr.h"

//****************** Global variables - begin **************************
GPE *pGPE = (GPE *)NULL;

////OEM-specific data holder
OEM_INFO	OemInfo;
USHORT		usBPP;		//make DrvGetMasks happy

ULONG	ulMIU1, ulMIU2, ulMIU3, ulMIU4, ulMIU5;
ULONG	ulDC0, ulPLL2, ulPLL3;
float	fDC0, fPLL2, fPLL3;
BOOL	bMIUClkLow;			//HSU
ULONG	ulFBBase;

#ifdef MIPS_NEC
 typedef volatile BYTE   *PVBYTE;
 extern PVBYTE  v_pIoRegs;
 extern ULONG ulIORegs;
#endif // MIPS_NEC

BOOL		PowerPointOn = FALSE;

//******************  Global variables - end  **************************


//GPE_Zones: Start with Errors, warnings, and temporary messages
INSTANTIATE_GPE_ZONES(0x0003,"DDI Driver","unused1","unused2")
//INSTANTIATE_GPE_ZONES(0xffff,"DDI Driver","unused1","unused2")

//
//-----------------------------------------------------------------------
//
// The only exported DDI routine in display driver
//
// - Process Registry information
// - MQGC constructor is Not instantiated yet at the entry of the call
// - The only global data used is OemInfo (with data structure of OEM_INFO)
//
//-----------------------------------------------------------------------
BOOL APIENTRY
DrvEnableDriver(
	ULONG          iEngineVersion,
	ULONG          cj,
	DRVENABLEDATA *pded,
	PENGCALLBACKS  pEngCallbacks)
{

	//mainly used to interface with Registry access
	HKEY		hRegKey;
	ULONG		ulData, ulStatus, ulValType, ulValLen;

//   DEBUGMSG (GPE_ZONE_INIT,(TEXT("Build Date:%s Time:%s\r\n"),__DATE__,__TIME__));
	DEBUGMSG (GPE_ZONE_INIT,(TEXT("DrvEnablePDEV:\r\n")));

#if 1	//def MIPS_NEC		//HSU - clocks to be consistent
	fDC0 = 83.0F;
#else
	fDC0 = 40.0F;
#endif

	//Obtain configuration information from Registry

	ulStatus = DrvEnableDriverOpen( &hRegKey );

	if ( ulStatus == ERROR_SUCCESS )
	{
		ulValLen = sizeof(ULONG);

		//REG_ASSIGN( ulMIU1, tcMIU1, ulData, DEF_MIU1);
		REG_ASSIGN( ulMIU2, tcMIU2, ulData, DEF_MIU2);
		REG_ASSIGN( ulMIU3, tcMIU3, ulData, DEF_MIU3);
		REG_ASSIGN( ulMIU4, tcMIU4, ulData, DEF_MIU4);
		REG_ASSIGN( ulMIU5, tcMIU5, ulData, DEF_MIU5);
		REG_ASSIGN( ulDC0,  tcDC0,  ulData, DEF_DC0);
		if ( IS_REG_OK( tcPLL1FREQ ) )
			fDC0 = (float)(ulData >> 16)
					+ ( (float)(ulData & 0xFFFFUL) / 1000.0F );
	#ifndef REV_0X
		//Re-compute Memory Refresh periods for MIU_CONTROL2
		ulMIU2 &= ~0x3FFF000UL;
		ulMIU2 |= (( COMPUTE_REFRESH_PERIOD( fDC0 ) << 12) & 0x03FFF000UL);
	#endif

		//PLL2 and PLL3 Programming
		#if 0
		REG_ASSIGN( OemInfo.ulPLL2, tcPLL2, ulData, DEF_PLL2 );
		if ( IS_REG_OK( tcPLL2FREQ ) )
			fPLL2 = (float)(u >> 16)
					+ ( (float)(ulData & 0xFFFFUL) / 1000.0F );
		REG_ASSIGN( OemInfo.ulPLL3, tcPLL3, ulData, DEF_PLL3 );
		if ( IS_REG_OK( tcPLL3FREQ ) )
			fPLL3 = (float)(ulData >> 16)
					+ ( (float)(ulData & 0xFFFFUL) / 1000.0F );
		#endif
 
	#ifdef SUPPORT_ROTATE
		//Get Rotatiion information
		REG_ASSIGN( nRotate, tcROTATE, (USHORT)ulData, FALSE);
		if(nRotate)
			PowerPointOn = FALSE;
	#endif //SUPPORT_ROTATE

		//Desktop X and Y resolution
		REG_ASSIGN( OemInfo.usX, tcResoX, (USHORT)ulData, (USHORT)-1 );
		REG_ASSIGN( OemInfo.usY, tcResoY, (USHORT)ulData, (USHORT)-1 );
		if ( OemInfo.usX == (USHORT)-1 || OemInfo.usY == (USHORT)-1 )
		{
			OemInfo.usX = DEFAULT_X;
			OemInfo.usY = DEFAULT_Y;
		}

		// LCD Viewport X and Y resolution
		REG_ASSIGN( OemInfo.usVX, tcResoVX, (USHORT)ulData, OemInfo.usX );
		REG_ASSIGN( OemInfo.usVY, tcResoVY, (USHORT)ulData, OemInfo.usY );

		//CRT Viewport X and Y resolution
		REG_ASSIGN( OemInfo.usVXCrt, tcResoVXCrt, (USHORT)ulData, OemInfo.usX );
		REG_ASSIGN( OemInfo.usVYCrt, tcResoVYCrt, (USHORT)ulData, OemInfo.usY );

		//Color depth
		REG_ASSIGN( OemInfo.usBPP, tcBPP, (USHORT)ulData, DEFAULT_BPP );

		usBPP = OemInfo.usBPP;				//for DrvGetMasks entry

		//CRT refresh rate
		REG_ASSIGN( OemInfo.usFreqCrt, tcFreq, (USHORT)ulData, DEFAULT_FREQ );

		//LCD refresh rate
		OemInfo.usFreq = 60;				//until we have high-refresh LCD

		//Alternate Hori and Vert Window
		REG_ASSIGN( OemInfo.usAWX, tcAWX, (USHORT)ulData, DEF_AWX );
		REG_ASSIGN( OemInfo.usAWY, tcAWY, (USHORT)ulData, DEF_AWY );

		//Alternate Window Address
		REG_ASSIGN( OemInfo.usAWBPP, tcAWBPP, (USHORT)ulData, DEF_AWBPP );

		//OEM or run-time flag	
		//- this flag is a must !!!
		if ( IS_REG_OK( tcFlag ) )
			OemInfo.ulOEMFlag = ulData;
		else
			DEBUGMSG(GPE_ZONE_INIT,(TEXT("Fatal error: query flag!\n")));

		//Query OEM register-related data from Registry
		//Flat panel GPO and GPIO
		REG_ASSIGN( OemInfo.ulFPGPO, tcGPO, ulData, DEF_GPO );
		REG_ASSIGN( OemInfo.ulFPGPIO, tcGPIO, ulData, DEF_GPIO );

		//PWM Control
		REG_ASSIGN( OemInfo.ulPWMControl, tcPWM, ulData, DEF_PWM );
			
		//D1 State
		OemInfo.ulD1State = ( IS_REG_OK( tcD1 ) ) ?
				ulData : ( OemInfo.ulOEMFlag & USE_2GCs ) ?
											DEF_D1_2GCs : DEF_D1_GC1;

		//D2 State
		OemInfo.ulD2State = ( IS_REG_OK( tcD2 ) ) ?
				ulData : ( OemInfo.ulOEMFlag & USE_2GCs ) ?
											DEF_D2_2GCs : DEF_D2_GC1;
	
		// Frame buffer base address
		REG_ASSIGN( ulFBBase, tcFBBase, ulData, 0x0L );
		RegCloseKey(hRegKey);
	}

	//Hoang - Begin
	//OEM panel information

	USHORT usTemp;

	usTemp = (USHORT) (OemInfo.ulOEMFlag & 0xff); // Get panel type

	if (usTemp == 0) {
    	USHORT usHSize, usVSize, usPanelFreq;
		ULONG  ulPLLData;
		float fPLLFreq;

		ulStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, tcSubKey, 0, 0, &hRegKey);
	
		if ( ulStatus == ERROR_SUCCESS )
		{
			ulValLen = sizeof(ULONG);
			REG_ASSIGN(usHSize, tcOEMPanelX, (USHORT)ulData,(USHORT)-1 );
			REG_ASSIGN(usVSize, tcOEMPanelY, (USHORT)ulData,(USHORT)-1 );
		
			if ( usHSize == (USHORT)-1 || usVSize == (USHORT)-1 )
			{
				usHSize = DEFAULT_X;
				usVSize = DEFAULT_Y;
			}

        	FPControlData[0].usHoriSize = usHSize;
			FPControlData[0].usVertSize = usVSize;

			//OEM FP Control
			REG_ASSIGN( FPControlData[0].ulFPControl, tcOEMFPCtrl, ulData, DEF_FPCtrl );

			//OEM FPPin Control
			REG_ASSIGN( FPControlData[0].ulFPPinControl, tcOEMFPPinCtrl, ulData, DEF_FPPinCtrl );


			//OEM FPSTN Control
			REG_ASSIGN( FPControlData[0].ulSTNControl, tcOEMFPSTNCtrl, ulData, DEF_FPSTNCtrl );

			//OEM FP Freq
			REG_ASSIGN( usPanelFreq , tcOEMPanelFreq, (USHORT)ulData, DEFAULT_FREQ );

			//OEM Horz display control
			REG_ASSIGN( FPControlData[0].ulHD , tcOEMHd, ulData, DEF_HD );

			//OEM Vert display control
			REG_ASSIGN( FPControlData[0].ulVD , tcOEMVd, ulData, DEF_VD );

			//OEM Horz sync control
			REG_ASSIGN( FPControlData[0].ulHS , tcOEMHs, ulData, DEF_HS );

			//OEM Vert sync control
			REG_ASSIGN( FPControlData[0].ulVS , tcOEMVs, ulData, DEF_VS );

			//OEM PLL frequency
			if ( IS_REG_OK( tcOEMPLLFreq ) )
				fPLLFreq = (float)(ulData >> 16)
					+ ( (float)(ulData & 0xFFFFUL) / 1000.0F );
			else
				fPLLFreq = 0.0F;
	    	DEBUGMSG (GPE_ZONE_INIT, (TEXT("OEMPLLFreq = %x\r\n"), ulData));				
			DEBUGMSG (GPE_ZONE_INIT, (TEXT("fPLLFreq = %d.%d\r\n"),(int)(ulData >> 16),
		                    (int)((float)(ulData & 0xFFFFUL) /1000.F)));
        	FPControlData[0].fPLLFreq = fPLLFreq;							
       
			//OEM PLL data 
			REG_ASSIGN(ulPLLData , tcOEMPLLData, ulData, DEF_PLLData );

			if (fPLLFreq == 18.881F || fPLLFreq == 25.175F || fPLLFreq == 31.500F ||
		    	fPLLFreq == 36.000F || fPLLFreq == 40.000F || fPLLFreq == 49.500F ||
				fPLLFreq == 50.000F || fPLLFreq == 56.250F || fPLLFreq == 65.000F ||
				fPLLFreq == 75.000F || fPLLFreq == 78.750F || fPLLFreq == 83.000F ||
				fPLLFreq == 94.500F || fPLLFreq == 108.000F || fPLLFreq == 135.000F ||
				fPLLFreq == 157.500F)
				;
			else {
				MQPLLParam[0].fFreq = fPLLFreq;
				MQPLLParam[0].ulPLLData = ulPLLData;
			}
 			RegCloseKey(hRegKey);
		} // End of ulStatus == ERROR_SUCCESS
	} // End of if (usTemp == 0)
	//Hoang - End
  
	ulStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, tcSubKeyClr, 0, 0, &hRegKey);
	if ( ulStatus == ERROR_SUCCESS )
	{
		//Cursor color and Gamma Correction data
		ulValLen = sizeof(ULONG);
		REG_ASSIGN( OemInfo.usCursorColor, tcCursorC, (USHORT)ulData, 0 );
		ulValLen = sizeof(tcFileName);
		if (ERROR_SUCCESS == RegQueryValueEx (hRegKey, tcGammaStr, NULL,
											&ulValType, (PBYTE)tcFileName, &ulValLen))
			OemInfo.ulOEMFlag |= GAMMA_ENABLED;
		else
			OemInfo.ulOEMFlag &= ~GAMMA_ENABLED;
		RegCloseKey(hRegKey);
	}

	ulStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, tcSubKeyLCD, 0, 0, &hRegKey);
	if ( ulStatus == ERROR_SUCCESS )
	{
		//Contrast and Brightness levels
		ulValLen = sizeof(ULONG);
		REG_ASSIGN( OemInfo.usContrast, tcContrast, (USHORT)ulData,
														 DEF_CONTRAST );
		REG_ASSIGN( OemInfo.usBright, tcBright, (USHORT)ulData, DEF_BRIGHT );
		RegCloseKey(hRegKey);
	}
 	EmulInit();

	//HSU - begin
	bMIUClkLow = ( !(OemInfo.ulOEMFlag & USE_2GCs)
					&& (OemInfo.ulOEMFlag & LCD_ON)
					&& !(OemInfo.ulOEMFlag & CRT_ON) );
	//HSU - end

	return DrvEnableDriverDone( iEngineVersion, cj, pded, pEngCallbacks );
}

//Main entry point for a GPE-compliant driver
GPE *
GetGPE()
{
	if( !pGPE )
		pGPE = new MQGC();
	return pGPE;
}

MQGC::MQGC(int i)
{
	m_pFPControl = &FPControlData[3 - 1];
	m_fPLLs[FREQ_PLL1] = m_fPLLs[FREQ_PLL2] = m_fPLLs[FREQ_PLL3] = 0.0F;
}

MQGC::MQGC()
{
	BOOL	vcrc;
	USHORT	usTemp;
//#ifdef MIPS_TOS
//	DWORD	csr;
//#endif

	RETAILMSG (1, (L"MQGC::MQGC Contructor\r\n"));

	//Fill OEM-specific structure from Registry
	m_pOEMInfo = &OemInfo;
	m_nMQFlag = m_pOEMInfo->ulOEMFlag;

//	set_BCRVal ((1 << 1), NOMASK, FALSE);

	//Two memory blocks are mapped in the system address space,
	//
	// 1. Memory-mapped register space for mq100 (may be more than needed)
	// 2. Linear frame buffer address space (1MB for mq100)
	//
	if (MapPhysicalDevice())
	{
		// MapPhsicalDevice() Failed, just return
		return;
	}
	//Sleep(100);

//#ifdef MIPS_TOS
//    // Map the internal registers in TX39
//    m_pTXRegBase = (PBYTE)VirtualAlloc(0,
//				       TX_REGS_SIZE,
//				       MEM_RESERVE,
//				       PAGE_NOACCESS);
//    DEBUGMSG( GPE_ZONE_INIT,
//	     (TEXT("Virtual Address of TX39 Register is 0x%08x\r\n"),
//	      m_pTXRegBase ));
//
//    if ( !VirtualCopy(m_pTXRegBase,
//		      (LPVOID)SYSTEM_ASIC_REGS_BASE,
//		      TX_REGS_SIZE,
//		      PAGE_READWRITE|PAGE_NOCACHE) )
//
//    csr = READ_REGISTER_ULONG(m_pTXRegBase+OFF_BIU_MEM_CONFIG1);
//    csr = ((csr&~(BIU_MCS0ACCVAL1MASK|BIU_MCS0ACCVAL2MASK))|BIU_ENBCLK|
//	  	  BIU_MCS0WAIT | BIU_MCS0ACCVAL1(3)|BIU_MCS0ACCVAL2(3));
//	csr = csr | BIU_MCS0_32 |BIU_ENMCS0BE ;
//	csr = csr&~BIU_C48MPLLON;
//    WRITE_REGISTER_ULONG(m_pTXRegBase+OFF_BIU_MEM_CONFIG1, csr);
//
//	DEBUGMSG (GPE_ZONE_INIT, (TEXT("BIU_MEM_CONFIG1=%08x\r\n"),csr ));
//	
//#endif

#ifdef MIPS_NEC

   RETAILMSG (1, (L"Shouldn't execute this\n"));
	// To access NEC RTC ..
	v_pIoRegs = (UCHAR *)VirtualAlloc(
		0,
		IOREGS_SIZE,
		MEM_RESERVE,
		PAGE_NOACCESS);
		
	vcrc = VirtualCopy(
		(UCHAR *)v_pIoRegs,
		(LPVOID)ulIORegs,
		IOREGS_SIZE,
		PAGE_READWRITE|PAGE_NOCACHE);
#endif // MIPS_NEC

	// Alloc MMIO Space
	m_pMMIO = (UCHAR *)VirtualAlloc(
		0,
		m_nMMIOMemorySize,				//Size of MQ memory-mapped registers
		MEM_RESERVE,
		PAGE_NOACCESS );

	//This function binds a specific physical memory range to a virtual
	//memory range - CE-only api
	//Make sure to check the 512MB memory limitation
//	DEVMAP(if (m_nIOPhysical < 0x20000000UL))
//	{
//		vcrc = VirtualCopy(
//			m_pMMIO,
//			(LPVOID)(m_nIOPhysical),
//			m_nMMIOMemorySize,
//			PAGE_READWRITE|PAGE_NOCACHE);
//	}
//	else // Use special flag to allocate memory greater than 512MB
//	{
		vcrc = VirtualCopy(
			m_pMMIO,
			(LPVOID)(m_nIOPhysical >> 8),
			m_nMMIOMemorySize,
			PAGE_READWRITE|PAGE_NOCACHE|PAGE_PHYSICAL);
//	}

	// Print Virtual Copy Errors (If Any)
	DEBUGMSG (GPE_ZONE_INIT, (TEXT("MMIO=%08x, vcrc=%d\r\n"),
				m_nIOPhysical, vcrc));

	//Allocate Frame Buffer Space
	m_pLAW = (unsigned char *)VirtualAlloc(
		0,
		max (m_nVideoMemorySize, 2097152),
		MEM_RESERVE,
		PAGE_NOACCESS );

//	DEVMAP(if (m_nLAWPhysical < 0x20000000UL))
//	{
//		vcrc = VirtualCopy(
//			m_pLAW,
//			(LPVOID)(m_nLAWPhysical),
//			m_nVideoMemorySize,
//			PAGE_READWRITE|PAGE_NOCACHE);
//	}
//	else // Use special flag to allocate memory greater than 512MB
//	{
		vcrc = VirtualCopy(
			m_pLAW,
			(LPVOID)(m_nLAWPhysical >> 8),
			m_nVideoMemorySize,
			PAGE_READWRITE|PAGE_NOCACHE|PAGE_PHYSICAL);