ddc.ccp

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

		return TRUE;
}
//****************************************************************************
//
//
//****************************************************************************

#define	WAIT_SCL_HIGH	2000
//#define	WAIT_20_30ns	275

void Wait_20_30ns()
{
	int i=WAIT_COUNT;

	while(i)
	{
		 --i;
	}
	
}
//Max I2C protocal SCL <= 100K Hz.

BOOL I2COut(ULONG SCL, ULONG SDA)
{
//	ULONG	ulWait;
#ifdef MQ_CPP	
	pMQGC->I2COemOut(SCL,SDA);
#endif
// assume no pull down signal from monitor for now
#if 0
	if(SCL)	// if CLK high, we wait it go high
	{
		ulWait = WAIT_SCL_HIGH;

		while((ulWait--) && !pMQGC->I2COemCheckSCLHigh()){}
		if(!ulWait)
		{
////			DEBUGMSG(GPE_ZONE_INIT,(TEXT("I2COemOut Time out, waiting SCL to go High!\r\n"));
		}
	}

#endif
	//  20~30ns delay
		
	Wait_20_30ns();

	return TRUE;
}

#define	GPIO0_ENABLE_MASK	0x00000003
#define	GPIO1_ENABLE_MASK 0x0000000C
#define	GPIO2_ENABLE_MASK 0x00000030

#define	GPIO0_OUT_MASK		0x00010000
#define	GPIO1_OUT_MASK		0x00020000
#define	GPIO2_OUT_MASK		0x00040000

#define	GPIO0_IN_MASK		0x01000000
#define	GPIO1_IN_MASK		0x02000000
#define	GPIO2_IN_MASK		0x04000000

//====================================================
#define	I2C_RW_MASK			(GPIO0_ENABLE_MASK | GPIO0_OUT_MASK)
#define	SCL_ENABLE_MASK	GPIO1_ENABLE_MASK
#define	SCL_OUT_MASK		GPIO1_OUT_MASK
#define	SCL_IN_MASK			GPIO1_IN_MASK
#define	SDA_ENABLE_MASK	GPIO2_ENABLE_MASK
#define	SDA_OUT_MASK		GPIO2_OUT_MASK
#define	SDA_IN_MASK			GPIO2_IN_MASK


#define	GPIO0_OUT_LOW	0L
#define	GPIO1_OUT_LOW	0L
#define	GPIO2_OUT_LOW	0L

#define	I2C_WRITE		((ULONG)GPIO0_OUT | GPIO0_OUT_HIGH  )
#define	I2C_READ			((ULONG)GPIO0_OUT | GPIO0_OUT_LOW   )
#define	SCL_OUT_HIGH	((ULONG)GPIO1_OUT | GPIO1_OUT_HIGH  )
#define	SCL_OUT_LOW		((ULONG)GPIO1_OUT | GPIO1_OUT_LOW	)
#define	SDA_OUT_HIGH	((ULONG)GPIO2_OUT | GPIO2_OUT_HIGH	)
#define	SDA_OUT_LOW		((ULONG)GPIO2_OUT | GPIO2_OUT_LOW	)
//#define	SDA_IN_MASK		((ULONG)GPIO2_IN_HIGH)
//#define	SCL_IN_MASK		((ULONG)GPIO1_IN_HIGH)

#ifdef	MQ_CPP
void	MQGC::I2COemOut(ULONG SCL,ULONG SDA)
{

	ULONG	ulData;
	
	ulData = fpREAD(FP_GPIO_CONTROL);

#ifdef	OLD_DEVICE
	ulData &= ~(SCL_ENABLE_MASK | SCL_OUT_MASK | SDA_ENABLE_MASK | SDA_OUT_MASK | I2C_RW_MASK);
#else
	ulData &= ~(SCL_ENABLE_MASK | SCL_OUT_MASK | SDA_ENABLE_MASK | SDA_OUT_MASK);
#endif
	
	if(SCL)
		ulData = SCL_OUT_HIGH | (SDA ? SDA_OUT_HIGH : SDA_OUT_LOW);
	else
		ulData = SCL_OUT_LOW | (SDA ? SDA_OUT_HIGH : SDA_OUT_LOW);

#ifdef	OLD_DEVICE
	fpREG(FP_GPIO_CONTROL, I2C_WRITE | ulData );
#else
	fpREG(FP_GPIO_CONTROL, ulData );
#endif


}
#ifdef	SDB_GPIO
#define	GPIO012_INPUT	0xFFFF0000
ULONG	ReadGPIO()
{
	ULONG	ulData;
	

	DEBUGMSG(GPE_ZONE_INIT,(TEXT("ReadGPIO1\r\n")));
	ulData = fpREAD(FP_GPIO_CONTROL);
	
	DEBUGMSG(GPE_ZONE_INIT,(TEXT("ReadGPIO2\r\n")));
	ulData &= GPIO012_INPUT; 
	
	DEBUGMSG(GPE_ZONE_INIT,(TEXT("ReadGPIO3\r\n")));
	fpREG(FP_GPIO_CONTROL, ulData);
	
	DEBUGMSG(GPE_ZONE_INIT,(TEXT("ReadGPIO4\r\n")));
	ulData = fpREAD(FP_GPIO_CONTROL);

	DEBUGMSG(GPE_ZONE_INIT,(TEXT("GPIO Data=%%08x\r\n"), ulData));
	return ulData;
}
#endif // SDB_GPIO

BOOL	MQGC::I2COemInSDA()
{
	ULONG	ulData;
	ULONG ulTry=5;

////	I2COemOut(0, 0);	// SCL = 0, SDA = 0
	// don't screw up other bits
	ulData = fpREAD(FP_GPIO_CONTROL);

	Wait_20_30ns();
	
	ulData &= ~(SCL_ENABLE_MASK | SDA_ENABLE_MASK | I2C_RW_MASK);
	fpREG(FP_GPIO_CONTROL, ulData | I2C_READ);

	while(ulTry)
	{
		Wait_20_30ns();
		ulData = fpREAD(FP_GPIO_CONTROL);
		if(ulData & SCL_IN_MASK)	// check if monitor pull down the SCL
		{
			 // No pull down
			 break;
		}
////		DEBUGMSG(GPE_ZONE_INIT,(TEXT("Monitor no ready! Wait another 20ns\r\n")));
		// Monitor pull down the SCL, we need to wait.
		--ulTry;
	}
	if(!ulTry)
	{
////		DEBUGMSG(GPE_ZONE_INIT,(TEXT("Monitor no ready! I2COemInSDA time out\r\n")));
	}
	// Low the SCL again
////	I2COemOut(0, 0);	// SCL = 0, SDA = 0

	if(ulData & SDA_IN_MASK)
		return 1;
	else
		return 0;
}

BOOL	MQGC::I2COemCheckSCLHigh()
{

	ULONG	ulData;
	
	ulData = fpREAD(FP_GPIO_CONTROL);

	ulData &= ~(I2C_RW_MASK);
	fpREG(FP_GPIO_CONTROL, ulData | I2C_READ);

	ulData = fpREAD(FP_GPIO_CONTROL);

	if(ulData & SCL_IN_MASK)
		return 1;
	else
		return 0;

}

#endif
//****************************************************************************
//	I2CBitRead - Reads in 1 bit from SDA via the GIP 
//****************************************************************************
BOOL	I2CBitRead()
{
	BOOL	bData;

	I2COut(0,1);	// SCL = LOW,  SDA = HIGH
	I2COut(1,1);	// SCL = HIGH, SDA = HIGH
	
#ifdef MQ_CPP
	bData = pMQGC->I2COemInSDA();
#endif
#if 0
	if(bData)
		DEBUGMSG(GPE_ZONE_INIT,(TEXT("1\r\n")));
	else
		DEBUGMSG(GPE_ZONE_INIT,(TEXT("0\r\n")));
#endif
	I2COut(0,1);	// SCL = LOW,  SDA = HIGH

	return bData;

}
//****************************************************************************
//	I2CByteRead - Input a byte of information from the display. 
//****************************************************************************
BYTE I2CByteRead()
{
	UINT	i;
	BYTE	bData=0;
	BOOL	Bit=0;

	for(i=0; i< 8; ++i)
	{
		Bit = I2CBitRead();
		bData <<= 1;
		bData |= (BYTE)(Bit&0x01);
	}

	return bData;

}

//****************************************************************************
//	I2CBitWrite - Write one SDA bit to the i2c bus during a clock pulse. 
//****************************************************************************
BOOL I2CBitWrite(BOOL BitData)
{
	I2COut(0,BitData);	// SCL = LOW,  SDA = BitData
	I2COut(1,BitData);	// SCL = High, SDA = BitData
	I2COut(0,BitData);	// SCL = LOW,  SDA = BitData

	return TRUE;
}

//****************************************************************************
//	I2CByteWrite - Output a byte of information on the i2c bus to 
//	       the display. 
//****************************************************************************
BOOL I2CByteWrite(BYTE	bData)
{
	BYTE	bMask = 0x80;
	int		i;

	for(i =0; i< 8; i++)
	{
		I2CBitWrite((BOOL)(bMask & bData));
		bMask >>=1;
	}
#if 0
//Check Ack
	if(I2CBitRead())
	{
////		DEBUGMSG(GPE_ZONE_INIT,(TEXT("I2CByteWrite: ACK error\r\n")));
		return FALSE;
	}
	else
		return TRUE;
#endif
// Assume the monitor will responce well, such that we don't need to verify it.
// What we need to do is to generate a SCL .

	I2CBitWrite(0);

	return TRUE;
}

//****************************************************************************
//	I2CDataRequest - Setup Display to query EDID or VDIF information
//			 depending upon the offset given.
//****************************************************************************
BOOL I2CDataRequest(BYTE	bStartAddr, BYTE *pBuffer, BYTE bLength, BYTE bAction)
{
	BYTE	bData;
	BYTE	bCheckSum = 0;
	UINT	i;
	BOOL	bRet = TRUE;

		I2CStartService();
		
		I2CByteWrite(0xA0);			// Send Device address + Write

		D2_DELAY();

		I2CByteWrite(bStartAddr);	// Send Start address offset

		D2_DELAY();

		I2CStartService();
		
		I2CByteWrite(0xA1);			// Send Device address + Read

		D2_DELAY();

		if(bAction == Fun_Read)
		{
			for(i=0; i< bLength; i++,++pBuffer)
			{
				bData = I2CByteRead();
				if((i+1) == bLength)
					I2CNackWrite();
				else
					I2CAckWrite();
//				pBuffer[i++] = bData;
				*pBuffer = bData;
				bCheckSum += bData;
////				DumpHex(*pBuffer);
			}

			I2CStopService();

	//		if(bAction == Fun_VerifyCheckSum)
			{
				bRet = (bCheckSum ? FALSE: TRUE);
			}
		}

		return bRet;

}


//****************************************************************************
//	I2CAckWrite - Send acknowledgement when reading information. 
//****************************************************************************


void I2CAckWrite()
{
	I2CBitWrite(0);
	D2_DELAY();
}


//****************************************************************************
//
//	i2CNackWrite - Send Not acknowledgement when reading information.
//		       A NACK is DATA high during one clock pulse. 
//
//****************************************************************************

void I2CNackWrite()
{
	I2CBitWrite(1);
	D2_DELAY();
}

#define	MON_SENSE_LEVEL_MASK	0x0F000000
#define	MON_SENSE_LEVEL		0x00660000
//****************************************************************************
//
//	DetectMonitor - Turn on monitor sense circuit and send out constant output
//		       		 to Red, Green and Blue DAC.
//
//						 if an attached monitor is found, it return TRUE,
//						 otherwise, it return FALSE.
//****************************************************************************
#ifdef	MQ_CPP
BOOL	MQGC::DetectMonitor()
{
	DWORD	old_GC1_CONTROL;
	DWORD	old_GC1_CRT_CONTROL;
	DWORD	new_GC1_CRT_CONTROL;
	BOOL	bResult;

	old_GC1_CONTROL = gc1READ(GC1_CONTROL);
	old_GC1_CRT_CONTROL = gc1READ(GC1_CRT_CONTROL);

	gc1REG(GC1_CONTROL,       old_GC1_CONTROL |
									GC_ENABLE |
									GxRCLK_PLL1 );   /* OEM-dependent */

	new_GC1_CRT_CONTROL = old_GC1_CRT_CONTROL &
								(~SYNC_PED_ENABLE) &
								(~BLANK_PED_ENABLE);

	gc1REG(GC1_CRT_CONTROL,    new_GC1_CRT_CONTROL |
									CRT_BY_GC1 |
									MON_SENSE_ENABLE |
									CONST_OUT_ENABLE |
									MON_SENSE_LEVEL);

	// WaitResponse ();

	if(gc1READ(GC1_CRT_CONTROL) & MON_SENSE_LEVEL_MASK)
		bResult = FALSE;
	else
		bResult = TRUE;

	gc1REG(GC1_CONTROL, old_GC1_CONTROL);
	gc1REG(GC1_CRT_CONTROL, old_GC1_CRT_CONTROL);

	return bResult;
}
#else
BOOL	DetectMonitor()
{
	return TRUE;
}
#endif

void	D2_DELAY()
{
	 int i = D2_TIME;
	 while(i)
	 {
		  Wait_20_30ns();
		  --i;
	 }
}

void	D1_DELAY()
{
	 int i = D1_TIME;
	 while(i)
	 {
		  Wait_20_30ns();
		  --i;
	 }
}