realtimeclock.c

ebd9307开发板wince bsp源码,包括cs8900,lcd,nand,serial,touch,usb,gpio,wd等驱动

    DEBUGMSG(DEBUG_ALARM, (_T("OEMSetAlarmTime: CurTime: ST(%02d/%02d/%04d  %02d:%02d:%02d)\r\n"),
             stCurTime.wMonth, stCurTime.wDay,    stCurTime.wYear,
             stCurTime.wHour,  stCurTime.wMinute, stCurTime.wSecond ));
    DEBUGMSG(DEBUG_ALARM, (_T("OEMSetAlarmTime:   Alarm: ST(%02d/%02d/%04d  %02d:%02d:%02d)\r\n"),
             lpst->wMonth, lpst->wDay,    lpst->wYear,
             lpst->wHour,  lpst->wMinute, lpst->wSecond ));
    DEBUGMSG(DEBUG_ALARM, (_T("OEMSetAlarmTime:   gliLastCurTicks(0x%08X:0x%08X)\r\n"),
             gliLastCurTicks.HighPart, gliLastCurTicks.LowPart ));

    uliCurFTime.LowPart  = gftLastFileTime.dwLowDateTime;
    uliCurFTime.HighPart = gftLastFileTime.dwHighDateTime;

    // Convert the SYSTEMTIME alarmTime to FILETIME
    KSystemTimeToFileTime( lpst, &ftAlarmTime );
    // now to ULARGE_INTEGER
    uliAlarmFTime.LowPart  = ftAlarmTime.dwLowDateTime;
    uliAlarmFTime.HighPart = ftAlarmTime.dwHighDateTime;

    DEBUGMSG(DEBUG_ALARM, (_T("OEMSetAlarmTime:   uliCurFTime(0x%08X:0x%08X) uliAlarmFTime(0x%08X:0x%08X)\r\n"),
             uliCurFTime.HighPart,   uliCurFTime.LowPart,
             uliAlarmFTime.HighPart, uliAlarmFTime.LowPart ));

    // Compare the current time with the alarm time
    // to make sure that the alarm is in the future.
    if (uliAlarmFTime.QuadPart > uliCurFTime.QuadPart)
    {
#if (1 == DEBUG_ALARM)
        unsigned __int64 ui64RealTime;

        // The alarm time is in the future, so
        // we now need to figure out the TICK count
        // to look for.
        // Find the difference in NANO chunks...
        uliAlarmFTime.QuadPart -= uliCurFTime.QuadPart;
        // now we need to convert NANO chunks to TICKS
        ui64RealTime  = (unsigned __int64) uliAlarmFTime.HighPart << 32;
        ui64RealTime += uliAlarmFTime.LowPart;
        NANO_CHUNKS_TO_TICKS( ui64RealTime );

        // Add the current ticks back to get desired the alarm ticks...
        ui64RealTime += (unsigned __int64) gliLastCurTicks.QuadPart;

        // Save it back into uliAlarmFTime (now in TICKS)
        uliAlarmFTime.HighPart  = (DWORD) (ui64RealTime >> 32);
        uliAlarmFTime.LowPart   = (DWORD) ui64RealTime;

        DEBUGMSG(TRUE, (_T("OEMSetAlarmTime:   uliAlarmFTime(0x%08X:0x%08X)\r\n"),
                 uliAlarmFTime.HighPart, uliAlarmFTime.LowPart ));
#endif  // ( DEBUG_ALARM )

        gliRTCAlarmTicks.QuadPart = uliAlarmFTime.QuadPart;

#if (1 == DEBUG_ALARM )
    // Test the alarm date & time to see if it is close to what
    // was wanted...
{        
    LARGE_INTEGER    tmpCurTicks = gliRTCAlarmTicks;
    LARGE_INTEGER    liTimeDelta;
    FILETIME         ftDelta;
    FILETIME         ftCurFTime;
    SYSTEMTIME       stTime;
    unsigned __int64 ui64Delta;

    // Calculate the current diference
    //
    liTimeDelta.QuadPart = 
        tmpCurTicks.QuadPart - gliLastCurTicks.QuadPart;

    ui64Delta = (unsigned __int64) liTimeDelta.QuadPart;
    TICKS_TO_NANO_CHUNKS( ui64Delta ); // convert to nano chunks

    // setup to add in the nano chunk time difference
    ftDelta.dwLowDateTime  = (DWORD)  ui64Delta;
    ftDelta.dwHighDateTime = (DWORD) (ui64Delta >> 32);

    // Add the delta to the last known time...
    //
    add64_64_64(  &gftLastFileTime , &ftDelta, &ftCurFTime );

    // convert the answer to a system time format
    //
    KFileTimeToSystemTime( &ftCurFTime, &stTime );

    DEBUGMSG( DEBUG_ALARM, (_T("OEMSetAlarmTime: Converted alarmTime: ST(%02d/%02d/%04d  %02d:%02d:%02d)\r\n"),
              stTime.wMonth, stTime.wDay,    stTime.wYear,
              stTime.wHour,  stTime.wMinute, stTime.wSecond ) );
    // Write out to the debug serial port that we
    // are enabling the alarm...
    //OEMWriteDebugByte('S');
}
#endif  //  ( DEBUG_ALARM )

        gfRTCAlarm = TRUE;

        // clear interrupts, write the comparator, and enable interrupts
        OEMInterruptEnable( SYSINTR_RTC_ALARM, NULL, 0 );
        bResult = TRUE;
    }
    else
    {
        DEBUGMSG( TRUE, 
                  (_T("OEMSetAlarmTime: alarm occurs before current time!\r\n") ) );
        bResult = FALSE;
    }
    return( bResult );
}


static INT ReadI2CReg(UCHAR ucRegAddr, UCHAR *buffer, INT nbytes)
{
	ULONG uiVal, uiDDR;
	UCHAR ucData, ucBit;
	ULONG ulTimeout;
	INT j;

	WriteI2CReg(ucRegAddr, (void*)0,0);
	DelayInuSec(20);
	
	uiVal = *GPIO_PGDR;
	uiDDR = *GPIO_PGDDR;

	uiVal |= (GPIOG_EEDAT | GPIOG_EECLK);
	*GPIO_PGDR = uiVal;

	DelayInuSec(EE_DELAY_USEC);

	uiDDR |= (GPIOG_EEDAT | GPIOG_EECLK);
	*GPIO_PGDDR = uiDDR;

	DelayInuSec(EE_DELAY_USEC);

	uiVal &= ~GPIOG_EEDAT;
	*GPIO_PGDR = uiVal;

	DelayInuSec(EE_DELAY_USEC);

	uiVal &= ~GPIOG_EECLK;
	*GPIO_PGDR = uiVal;

	DelayInuSec(EE_DELAY_USEC);

	ucData = (UCHAR)READ_ADDRESS;
	for(ucBit = 0; ucBit < 8; ucBit++)
	{
		if(ucData & 0x80)
			uiVal |= GPIOG_EEDAT;
		else
			uiVal &= ~GPIOG_EEDAT;
		*GPIO_PGDR = uiVal;
		DelayInuSec(EE_DELAY_USEC);

		*GPIO_PGDR = uiVal | GPIOG_EECLK;
		DelayInuSec(EE_DELAY_USEC);

		*GPIO_PGDR = uiVal;
		DelayInuSec(EE_DELAY_USEC);

		ucData <<= 1;
	}
	uiDDR &= ~GPIOG_EEDAT;
	*GPIO_PGDDR = uiDDR;

	DelayInuSec(EE_DELAY_USEC);

	*GPIO_PGDR = uiVal | GPIOG_EECLK;
	DelayInuSec(EE_DELAY_USEC);

	ulTimeout =0;

	while((*GPIO_PGDR) & GPIOG_EEDAT)
	{
		DelayInuSec(EE_DELAY_USEC);
		ulTimeout++;
		if(ulTimeout > EE_READ_TIMEOUT)
		{
			return 1;
		}	
	}

	*GPIO_PGDR = uiVal;
	DelayInuSec(EE_DELAY_USEC);

	j = 0;
	while(nbytes--)
	{
		for( ucBit = 0; ucBit < 8; ucBit++)
		{
			*GPIO_PGDR = uiVal | GPIOG_EECLK;
			DelayInuSec(EE_DELAY_USEC);

			ucData = ((ucData << 1) | (UCHAR)((*GPIO_PGDR)>>1));
			*GPIO_PGDR = uiVal;
			DelayInuSec(EE_DELAY_USEC);
		}
		buffer[j] = ucData;
		uiDDR |= GPIOG_EEDAT;
		*GPIO_PGDDR = uiDDR;
		if(nbytes == 0)
		{
			*GPIO_PGDR = uiVal | GPIOG_EEDAT;
			*GPIO_PGDR = uiVal | GPIOG_EECLK;
			DelayInuSec(EE_DELAY_USEC);

			*GPIO_PGDR = uiVal;
			DelayInuSec(EE_DELAY_USEC);
		}
		else
		{
			*GPIO_PGDR = uiVal & (~GPIOG_EEDAT);
			*GPIO_PGDR = uiVal | GPIOG_EECLK;

			DelayInuSec(EE_DELAY_USEC);

			*GPIO_PGDR = uiVal;
			DelayInuSec(EE_DELAY_USEC);
		}
		uiDDR &= ~GPIOG_EEDAT;
		*GPIO_PGDDR = uiDDR;
		j++;
	}

	uiDDR |= GPIOG_EEDAT;
	*GPIO_PGDDR = uiDDR;

	uiVal &= ~GPIOG_EEDAT;
	*GPIO_PGDR = uiVal;

	DelayInuSec(EE_DELAY_USEC);

	uiVal |= GPIOG_EECLK;
	*GPIO_PGDR = uiVal;

	DelayInuSec(EE_DELAY_USEC);

	uiVal |= GPIOG_EEDAT;
	*GPIO_PGDR = uiVal;

	DelayInuSec(EE_DELAY_USEC);

	return 0;
}


static INT WriteI2CReg(UCHAR ucRegAddr, UCHAR *ucRegValue, INT nbytes)
{
	ULONG uiVal, uiDDR;
	UCHAR ucData, ucIdx, ucBit;
	ULONG ulTimeout;

	uiVal = *GPIO_PGDR;
	uiDDR = *GPIO_PGDDR;

	uiVal |= (GPIOG_EEDAT | GPIOG_EECLK);
	*GPIO_PGDR = uiVal;
	DelayInuSec(EE_DELAY_USEC);

	uiDDR |= GPIOG_EEDAT | GPIOG_EECLK;
	*GPIO_PGDDR = uiDDR;

	DelayInuSec(EE_DELAY_USEC);

	uiVal &= ~GPIOG_EEDAT;
	*GPIO_PGDR = uiVal;

	DelayInuSec(EE_DELAY_USEC);

	uiVal &= ~GPIOG_EECLK;
	*GPIO_PGDR = uiVal;
	DelayInuSec(EE_DELAY_USEC);

	for(ucIdx = 0; ucIdx < (2 + nbytes); ucIdx++)
	{
		if(ucIdx == 0)
			ucData = (UCHAR)WRITE_ADDRESS;
		else if (ucIdx == 1)
			ucData= ucRegAddr;
		else
			ucData = ucRegValue[ucIdx - 2];

		for(ucBit = 0; ucBit < 8; ucBit++)
		{
			if(ucData & 0x80)
				uiVal |= GPIOG_EEDAT;
			else
				uiVal &= ~GPIOG_EEDAT;
			*GPIO_PGDR = uiVal;
			DelayInuSec(EE_DELAY_USEC);

			*GPIO_PGDR = uiVal | GPIOG_EECLK;
			DelayInuSec(EE_DELAY_USEC);

			*GPIO_PGDR = uiVal;
			DelayInuSec(EE_DELAY_USEC);

			ucData <<= 1;
		}
		uiDDR &= ~GPIOG_EEDAT;
		*GPIO_PGDDR = uiDDR;
		DelayInuSec(EE_DELAY_USEC);

		*GPIO_PGDR = uiVal | GPIOG_EECLK;
		DelayInuSec(EE_DELAY_USEC);

		ulTimeout = 0;
		while( (*GPIO_PGDR) & GPIOG_EEDAT)
		{
			DelayInuSec(EE_DELAY_USEC);
			ulTimeout++;
			if( ulTimeout > EE_READ_TIMEOUT)
			{
				return 1;
			}
		}

		*GPIO_PGDR = uiVal;
		DelayInuSec(EE_DELAY_USEC);

		uiDDR |= GPIOG_EEDAT;
		*GPIO_PGDDR = uiDDR;
		DelayInuSec(EE_DELAY_USEC);
	}

	uiVal &= ~GPIOG_EEDAT;
	*GPIO_PGDR = uiVal;
	DelayInuSec(EE_DELAY_USEC);

	uiVal |= GPIOG_EECLK;
	*GPIO_PGDR = uiVal;

	DelayInuSec(EE_DELAY_USEC);

	uiVal |= GPIOG_EEDAT;
	*GPIO_PGDR = uiVal;
	DelayInuSec(EE_DELAY_USEC);

	return 0;
}


UINT BcdToHex(UINT uiBcdValue)
{
	UINT uiHexValue;
	UINT uiTemp;
	uiTemp = uiBcdValue >> 4;
	uiHexValue = uiTemp * 10;
	uiTemp = uiBcdValue & 0x0f;
	uiHexValue += uiTemp;
	return uiHexValue;
}


UINT HexToBcd(UINT uiHexValue)
{
	UINT uiBcdValue;
	UINT uiTemp;
	uiTemp = uiHexValue / 10;
	uiBcdValue = uiTemp << 4;
	uiTemp = uiHexValue % 10;
	uiBcdValue += uiTemp;
	return uiBcdValue;
}





/* EOF timex20t.c */