rtc.c

来自「该BSP是基于PXA270+WINCE的BSP」· C语言 代码 · 共 505 行 · 第 1/2 页

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
//------------------------------------------------------------------------------
//
//  Module: rtc.c
//
//  Real-time clock (RTC) routines for the Intel Bulverde processor.
//
#include <windows.h>
#include <nkintr.h>
#include <oal.h>
#include <bulverde.h>


//----------------------------------------------------------------------
#include "xllp_defs.h"
#include "xllp_gpio.h"
#include "xllp_i2c.h"

#define FROM_BCD(n)		((((n) >> 4) * 10) + ((n) & 0xf))
#define TO_BCD(n)		((((n)/10)*16)+((n)%10))

extern XLLP_BOOL_T XllpI2cInit(
		P_XLLP_I2C_T 	I2C_regs, 
		P_XLLP_GPIO_T 	gpio, 
		P_XLLP_CLKMGR_T clkMgr, 
		XLLP_UINT32_T 	dev_id);

extern XLLP_BOOL_T XllpI2CWrite(
		P_XLLP_I2C_T 		I2C_regs, 
		XLLP_OST_T 		   *pOSTRegs, 
		XLLP_UINT8_T 		slaveAddr, 
		const XLLP_UINT8_T *bytesBuf, 
		XLLP_UINT32_T 		bytesCount, 
		XLLP_BOOL_T 		bSendStop);

extern XLLP_BOOL_T XllpI2CRead(	
		P_XLLP_I2C_T 	I2C_regs, 
		XLLP_OST_T 		*pOSTRegs, 
		XLLP_UINT8_T 	slaveAddr, 
		XLLP_UINT8_T 	*bytesBuf, 
		XLLP_UINT32_T 	bytesCount, 
		XLLP_BOOL_T 	bSendStop);

typedef struct {
    WORD wSecond;
    WORD wMinute;
    WORD wHour;
    WORD wDayOfWeek;
    WORD wDay;
    WORD wMonth;	
    WORD wYear;
    WORD wControl;
} MYTIME, *PMYTIME;
MYTIME mytime;

//----------------------------------------------------------------------


//------------------------------------------------------------------------------
// Unions to make it easier to extract bit fields from the 32 bit registers
//
typedef union DAY_REGISTER 
{
    UINT32 value;
    struct
    {
        unsigned seconds    : 6;
        unsigned minutes    : 6;
        unsigned hours      : 5;
        unsigned dayOfWeek  : 3;
        unsigned weekOfMonth: 3;
        unsigned reserved   : 9;
    };
} DayRegister;

typedef union YEAR_REGISTER
{
    UINT32 value;
    struct 
    {
        unsigned dayOfMonth : 5;
        unsigned month      : 4;
        unsigned year       : 12;
        unsigned reserved   : 11;
    };
} YearRegister;

//------------------------------------------------------------------------------
// Internal function to check the validity of the SYSTEMTIME structure before
// setting the RTC or the Alarm time.
static BOOL IsSystemTimeStructValid(LPSYSTEMTIME systemTime);
static BOOL IsLeapYear(WORD wYear);


//==============================================================================================
void M41T00GetRealtime(LPSYSTEMTIME pTime)
{
	volatile XLLP_I2C_T 	*sbsv_pI2C	;
	volatile XLLP_GPIO_T  	*sbsv_pGPIORegs ;
	volatile XLLP_CLKMGR_T	*sbsv_pClkRegs ;
	volatile XLLP_OST_T  	*sbsv_pOSTRegs	;

	unsigned char Rbytearray[8];
//	RETAILMSG(TRUE,(TEXT("G> ")));

	sbsv_pI2C 		= (volatile XLLP_I2C_T *)     OALPAtoVA(BULVERDE_BASE_REG_PA_I2C, FALSE);
	sbsv_pGPIORegs 	= (volatile XLLP_GPIO_T *)      OALPAtoVA(BULVERDE_BASE_REG_PA_GPIO, FALSE);
	sbsv_pClkRegs  	= (volatile XLLP_CLKMGR_T *) 	OALPAtoVA(BULVERDE_BASE_REG_PA_CLKMGR, FALSE);
	sbsv_pOSTRegs 	= (volatile XLLP_OST_T *)  	OALPAtoVA(BULVERDE_BASE_REG_PA_OST, FALSE);

	XllpI2cInit((P_XLLP_I2C_T)sbsv_pI2C, (P_XLLP_GPIO_T)sbsv_pGPIORegs, (P_XLLP_CLKMGR_T) sbsv_pClkRegs, (XLLP_UINT32_T) 0x0);
	XllpI2CRead((P_XLLP_I2C_T)sbsv_pI2C, (XLLP_OST_T *)sbsv_pOSTRegs, 0xd0, Rbytearray, 8, 1);

	pTime->wSecond		= (UCHAR)FROM_BCD(Rbytearray[0]& 0x7f);
	pTime->wMinute 		= (UCHAR)FROM_BCD(Rbytearray[1]& 0x7f);
	pTime->wHour   		= (UCHAR)FROM_BCD(Rbytearray[2]& 0x3f);
	pTime->wDayOfWeek 	= (UCHAR)FROM_BCD(Rbytearray[3]& 0x7);
	pTime->wDay	 		= (UCHAR)FROM_BCD(Rbytearray[4]& 0x3f);
	pTime->wMonth 		= (UCHAR)FROM_BCD(Rbytearray[5]& 0x1f);
	pTime->wYear 		= (UCHAR)FROM_BCD(Rbytearray[6]& 0xff);
	if(pTime->wYear<80)	pTime->wYear=2000 + pTime->wYear;
	else				pTime->wYear=1900 + pTime->wYear;

	if(pTime->wYear < 1980)						pTime->wYear = 2007;
	if((pTime->wMonth<1)||(pTime->wMonth>12))	pTime->wMonth = 1;	
	if((pTime->wDay < 1)||(pTime->wDay > 31))	pTime->wDay = 1;	
	if((pTime->wHour< 0)||(pTime->wHour> 23))	pTime->wHour = 0;
	if((pTime->wMinute<0)||(pTime->wMinute>59))	pTime->wMinute = 0;
	if((pTime->wSecond<0)||(pTime->wSecond>59))	pTime->wSecond = 0;

/*
RETAILMSG(1,(TEXT("aft wSecond[0]:   %d\r\n"),mmytime.wSecond)); 
RETAILMSG(1,(TEXT("SBS wMinute[1]:   %d\r\n"),mmytime.wMinute)); 
RETAILMSG(1,(TEXT("SBS wHour[2]:     %d\r\n"),mmytime.wHour  )); 
RETAILMSG(1,(TEXT("SBS wDayOfWeek[3]:%d\r\n"),mmytime.wDayOfWeek)); 
RETAILMSG(1,(TEXT("SBS wDay[4]:      %d\r\n"),mmytime.wDay)); 
RETAILMSG(1,(TEXT("SBS wMonth[5]:    %d\r\n"),mmytime.wMonth)); 
RETAILMSG(1,(TEXT("SBS wYear[6]:     %d\r\n"),mmytime.wYear)); 
RETAILMSG(1,(TEXT("--------------------------------------\r\n"))); 
RETAILMSG(1,(TEXT("\r\n"))); 
*/
}

//==============================================================================================
void M41T00SetRealtime(LPSYSTEMTIME pTime)
{
	volatile XLLP_I2C_T 	*sbsv_pI2C	;
	volatile XLLP_GPIO_T  	*sbsv_pGPIORegs ;
	volatile XLLP_CLKMGR_T	*sbsv_pClkRegs ;
	volatile XLLP_OST_T  	*sbsv_pOSTRegs	;
	
	unsigned char bytearray[8];
	
	sbsv_pI2C 		= (volatile XLLP_I2C_T *)     OALPAtoVA(BULVERDE_BASE_REG_PA_I2C, FALSE);
	sbsv_pGPIORegs 	= (volatile XLLP_GPIO_T *)      OALPAtoVA(BULVERDE_BASE_REG_PA_GPIO, FALSE);
	sbsv_pClkRegs  	= (volatile XLLP_CLKMGR_T *) 	OALPAtoVA(BULVERDE_BASE_REG_PA_CLKMGR, FALSE);
	sbsv_pOSTRegs 	= (volatile XLLP_OST_T *)  	OALPAtoVA(BULVERDE_BASE_REG_PA_OST, FALSE);
/*
	if(pTime->wYear<80)	pTime->wYear=2000 + pTime->wYear;
	else				pTime->wYear=1900 + pTime->wYear;

	if(pTime->wYear < 2000)						pTime->wYear = 2007;
	if((pTime->wMonth<1)||(pTime->wMonth>12))		pTime->wMonth = 1;	
	if((pTime->wDay < 1)||(pTime->wDay > 31))		pTime->wDay = 1;	
	if((pTime->wHour< 0)||(pTime->wHour> 23))		pTime->wHour = 0;
	if((pTime->wMinute<0)||(pTime->wMinute>59))	pTime->wMinute = 0;
	if((pTime->wSecond<0)||(pTime->wSecond>59))	pTime->wSecond = 0;
*/
	bytearray[0]= (UCHAR)0xD0;	
	bytearray[1]= (UCHAR)TO_BCD((pTime->wSecond));		//s
	bytearray[2]= (UCHAR)TO_BCD((pTime->wMinute));		//m
	bytearray[3]= (UCHAR)TO_BCD((pTime->wHour));		//h
	bytearray[4]= (UCHAR)TO_BCD((pTime->wDayOfWeek));	//date
	bytearray[5]= (UCHAR)TO_BCD((pTime->wDay));			//day
	bytearray[6]= (UCHAR)TO_BCD((pTime->wMonth));		//month
	bytearray[7]= (UCHAR)TO_BCD((pTime->wYear-2000));	//year

	XllpI2cInit((P_XLLP_I2C_T)sbsv_pI2C, (P_XLLP_GPIO_T)sbsv_pGPIORegs, (P_XLLP_CLKMGR_T) sbsv_pClkRegs, (XLLP_UINT32_T) 0x0);
	XllpI2CWrite((P_XLLP_I2C_T)sbsv_pI2C, (XLLP_OST_T *)sbsv_pOSTRegs, 0xd0, bytearray, 8, 1);

}
//==============================================================================================

//------------------------------------------------------------------------------
//
//  Function:  OEMGetRealTime
//
//  Reads the current RTC value and returns a system time.
//
BOOL OEMGetRealTime(LPSYSTEMTIME pTime)
{
    volatile BULVERDE_RTC_REG *pRTCRegs = (volatile BULVERDE_RTC_REG *) OALPAtoVA(BULVERDE_BASE_REG_PA_RTC, FALSE);
    DayRegister  dayReg;
    YearRegister yearReg;
    BOOL     retVal  = FALSE;
    WORD     seconds = 0;

    OALMSG(OAL_RTC&&OAL_FUNC, (L"+OEMGetRealTime(pTime = 0x%x)\r\n", pTime));
    if (!pTime) goto Done;

    do
    {
        // Get register values
        dayReg.value  = (UINT32)pRTCRegs->rdcr;
        seconds = dayReg.seconds;
        yearReg.value = (UINT32)pRTCRegs->rycr; 
    } while (seconds != (pRTCRegs->rdcr & 0x3F));

    // Fill in the SYSTEMTIME structure with the appropriate values
    pTime->wYear      = yearReg.year;
    pTime->wMonth     = yearReg.month;
    pTime->wDay       = yearReg.dayOfMonth;
    pTime->wDayOfWeek = dayReg.dayOfWeek - 1;   // Hardware is [1,7] Structure is [0,6]
    pTime->wHour      = dayReg.hours;
    pTime->wMinute    = dayReg.minutes;
    pTime->wSecond    = dayReg.seconds;
    pTime->wMilliseconds = 0;
    retVal = TRUE;

Done:
    OALMSG(OAL_RTC&&OAL_FUNC, (L"-OEMGetRealTime(retVal = %d)\r\n", retVal));
    return(retVal);
}

//------------------------------------------------------------------------------
//
//  Function:  OEMSetRealTime
//
//  Updates the RTC with the specified system time.
//
BOOL OEMSetRealTime(LPSYSTEMTIME pTime) 
{
    volatile BULVERDE_RTC_REG *pRTCRegs = (volatile BULVERDE_RTC_REG *) OALPAtoVA(BULVERDE_BASE_REG_PA_RTC, FALSE);
    BOOL         retVal = FALSE;
    DayRegister  dayReg;
    YearRegister yearReg;
    BOOL enabled;

    if (!pTime) goto Done;

    OALMSG(OAL_RTC&&OAL_FUNC, (
        L"+OEMSetRealTime(%d/%d/%d %d:%d:%d.%03d)\r\n", 
        pTime->wYear, pTime->wMonth, pTime->wDay, pTime->wHour, pTime->wMinute,
        pTime->wSecond, pTime->wMilliseconds