void rtcDateSet
    (
    int year,
    int month,
    int dayOfMonth,
    int dayOfWeek
    )

    {
    /*040322 james changed*/
    #if 0
    rtc_Year = year%100;
   #else
   if(year<CENTURY)
   	rtc_Year = year%100;
   else
   	rtc_Year = (year-CENTURY)%100;
  #endif
  
    rtc_Month = month;
    rtc_DayOfMonth = dayOfMonth;
    rtc_DayOfWeek = dayOfWeek;

    /*
     * evaluate distance to last leap year (don't pay attention to full
     * century rule, because only 3 year differences can be stored)
     */

    rtc_LeapYearDist = 4 - (year % 4);

    rtc_DayOfYear = dayOfYear (month, dayOfMonth);

    rtcSpIoctl (SET_DATE, FALSE);
    }

/*******************************************************************************
*
* rtcDateGet - get the date
*
* RETURNS: N/A.
*/

void rtcDateGet (void)

    {
    rtcSpIoctl (GET_DATE, TRUE);
    }

/*******************************************************************************
*
* rtcTimeSet - set the time
*
* RETURNS: N/A.
*/

void rtcTimeSet
    (
    int hour,
    int minute,
    int second
    )

    {
    rtc_Hour = hour;
    rtc_Minute = minute;
    rtc_Second = second;

    rtcSpIoctl (SET_TIME, FALSE);
    }

/*******************************************************************************
*
* rtcTimeGet - get the time
*
* RETURNS: N/A.
*/

void rtcTimeGet (void)

    {
    rtcSpIoctl (GET_TIME, TRUE);
    }

/*******************************************************************************
*
* rtcModeSet - set the mode
*
* RETURNS: OK or ERROR, if incorrect mode.
*/

STATUS rtcModeSet
    (
    int mode
    )

    {
    switch (mode)
        {
        case 12:    
            rtcSpIoctl (MODE_12HOUR, FALSE);
            return (OK);
        case 24:    
            rtcSpIoctl (MODE_24HOUR, FALSE);
            return (OK);
        default:
            return (ERROR);
        }
    }

/*******************************************************************************
*
* i2cReset() - Reset I2C BUS
*
*  This function should be called in initialization, to ensure that I2C bus is free.
*/


void i2cReset()
{
    rtcSpIoctl (I2C_RESET, FALSE);
}

/*******************************************************************************
*
* rtcSpIoctl - special device control routine
*
* This routine must be called by the user to access the driver ioctl routine
* correctly.
*
* NOMANUAL
*/

void rtcSpIoctl
    (
    int request,    /* request code */
    BOOL print      /* print if TRUE, else only set structure */
    )

    {
    int fd;

    fd = open (RTC_DEVICE, 0, 0);
 
    if(fd <= 0)
    	{
		printf(" open RTC error \n");
		return ;
	}
	else
	{
		printf("\r\nopen RTC ok \r\n");	
	}
    ioctl (fd, request, print);

    close (fd);
    }

/*******************************************************************************
*
* rtcIoctl - special device control
*
* This driver responds to the ioctl calls described in the header.
*/

STATUS rtcIoctl
    (
    FAST RTC_DEV *pRtcDv,   /* device to control */
    FAST int request,       /* request code */
    BOOL print              /* print if TRUE, else only set structure */
    )

    {
    STATUS state = OK;      /* state of the ioctl calls */
   unsigned char data;    	
#if 1
    switch (request)
        {
        case SET_DATE:
            if (rtc_DayOfWeek < 0 || rtc_DayOfWeek > 6)
                {
                printErr ("Invalid day of week: %d\n", rtc_DayOfWeek);
                break;
                }
            if (rtc_Month < 1 || rtc_Month > 12)
                {
                printErr ("Invalid month: %d\n", rtc_Month);
                break;
                }
 
		 m41t11_Write(3, toBCD (rtc_DayOfWeek+1));
		 m41t11_Write(4, toBCD (rtc_DayOfMonth));
		 m41t11_Write(5, toBCD (rtc_Month));
		 m41t11_Write(6, toBCD (rtc_Year));
				

            break;

        case GET_DATE:
            m41t11_Read(3,&data);
	     rtc_DayOfWeek = 	fromBCD(data&0x07) -1;
		 
	     m41t11_Read(4,&data);
	     rtc_DayOfMonth = 	fromBCD(data&0x3f);
		 
	     m41t11_Read(5,&data);
	     rtc_Month = 	fromBCD(data&0x1f);
		 
	     m41t11_Read(6,&data);
	     rtc_Year  = 	fromBCD(data);
		 

            /* print out */

            if (print)
                {
                if (rtc_DayOfWeek < 0 || rtc_DayOfWeek > 6)
                    {
                    printErr ("Invalid day of week: %d\n", rtc_DayOfWeek);
                    break;
                    }
                if (rtc_Month < 1 || rtc_Month > 12)
                    {
                    printErr ("Invalid month: %d\n", rtc_Month);
                    break;
                    }
                printf ("Date: %s, %02d-%s-%4d.\n",
                    dayTable [rtc_DayOfWeek],
                    rtc_DayOfMonth,
                    monthTable [rtc_Month - 1],
                    CENTURY + rtc_Year);
                }

            break;

        case SET_TIME:
           
	        m41t11_Write(0, toBCD (rtc_Second));
	        m41t11_Write(1, toBCD (rtc_Minute));
		 m41t11_Write(2, toBCD (rtc_Hour));
            break;

        case GET_TIME:

	     m41t11_Read(0,&data);
	     rtc_Second = 	fromBCD(data&0x7f);
	     m41t11_Read(1,&data);
	     rtc_Minute = 	fromBCD(data&0x7f);
	     m41t11_Read(2,&data);
	     rtc_Hour = 	fromBCD(data&0x3f);

	
            if (print)
                {
                if (mode == 12)
                    {
                    
                    }
                else
                    {
                  
                    printf ("Time: %02d:%02d:%02d.\n",
                        rtc_Hour, rtc_Minute, rtc_Second);
                    }
                }
            break;
			
        case I2C_RESET:
              I2C_Init();
		break;
		
        case MODE_24HOUR:
            mode = 24;

            break;

        case MODE_12HOUR:
            mode = 12;

            break;

        default:
            state = S_ioLib_UNKNOWN_REQUEST;
            break;
        }
#endif
    return (state);
    }

/*******************************************************************************
*
* toBCD - convert to binary coded decimal
*/

int toBCD
    (
    int intValue
    )

    {
    int bcdValue;

    bcdValue = intValue%10;
    intValue /= 10;
    intValue *= 0x10;
    bcdValue += intValue;

    return (bcdValue);
    }

/*******************************************************************************
*
* fromBCD - convert from binary coded decimal
*/

int fromBCD
    (
    int bcdValue
    )

    {
    int intValue;

    intValue = bcdValue&0xf;
    intValue += ((bcdValue&0xf0)/0x10)*10;

    return (intValue);
    }

/*******************************************************************************
*
* dayOfYear - evaluate day of the year
*/

int dayOfYear
    (
    int month,
    int day
    )

    {
    int currentDay = 0;

    switch (month)
        {
        case 12:
            currentDay += 30;
        case 11:
            currentDay += 31;
        case 10:
            currentDay += 30;
        case 9:
            currentDay += 31;
        case 8:
            currentDay += 31;
        case 7:
            currentDay += 30;
        case 6:
            currentDay += 31;
        case 5:
            currentDay += 30;
        case 4:
            currentDay += 31;
        case 3:
            if (rtc_LeapYearDist == 0)
                currentDay += 29;
            else
                currentDay += 28;
        case 2:
            currentDay += 31;
        case 1:
            currentDay += day;
        }

    return (currentDay);
    }

/*##################################*/
/*##################################*/

STATUS sysPrintTime()
{
	struct tm	Date;
	time_t	tod;
	/*extern time_t	   time (time_t *_tod);*/
	time(&tod);
	localtime_r(&tod, &Date);
	printf("%d-%02d-%02d %02d:%02d:%02d \n",
		 			Date.tm_year+1900,  /*year*/
		 			Date.tm_mon+1,      /*month*/
		 			Date.tm_mday,        /*day*/
		   			 Date.tm_hour,		/* hour */
		   			 Date.tm_min,		/* minute */
		   			 Date.tm_sec
		   			 );

	return OK;
}

STATUS sysSetTime(char *str)
{
	struct timespec setTime;
	struct tm	Date;
	time_t	tod;
	time_t timeL;
	char *p;
	int tmp;

	p = str;
		
	/*get current time*/
	time(&tod);
	localtime_r(&tod, &Date);

	if (p == NULL )
		return ERROR ;
	while (*p == ' ')
		p ++;
	tmp = atoi(p);
	if(tmp >= 1970)
	{
		Date.tm_year = tmp - 1900;
	}	
	else
	{
		printf("invalid year %d\n",tmp);
		return ERROR;
	}
	while( isdigit(*p))
		p ++;
	p ++;
	if(!isdigit(*p))
	{
		goto sysSetTimeStrError;
	}
	tmp = atoi(p);
	if( ( tmp <= 12 ) && (tmp >=1) )
	{
		Date.tm_mon =tmp -1 ;
	}
	else
	{
		goto sysSetTimeStrError;
	}
	while( isdigit(*p))
		p ++;
	p ++;
	if(!isdigit(*p))
	{
		goto sysSetTimeStrError;
	}
	tmp = atoi(p);
	if( ( tmp <= 31 ) && (tmp >=1) )
	{
		Date.tm_mday =tmp;
	}
	else
	{
		goto sysSetTimeStrError;
	}
	while( isdigit(*p))
		p ++;
	p ++;
	while (*p == ' ')
		p ++;

	/*hour*/
	if(!isdigit(*p))
	{
		goto sysSetTimeStrError;
	}
	tmp = atoi(p);
	if( ( tmp <= 24 ) && (tmp >=0) )
	{
		Date.tm_hour =tmp;
	}
	else
	{
		goto sysSetTimeStrError;
	}
	while( isdigit(*p))
		p ++;
	p ++;
	/*tm_min*/
	if(!isdigit(*p))
	{
		goto sysSetTimeStrError;
	}
	tmp = atoi(p);
	if( ( tmp <= 59 ) && (tmp >=0) )
	{
		Date.tm_min =tmp;
	}
	else
	{
		goto sysSetTimeStrError;
	}
	while( isdigit(*p))
		p ++;
	p ++;
	/*tm_sec*/
	if(!isdigit(*p))
	{
		goto sysSetTimeStrError;
	}
	tmp = atoi(p);
	if( ( tmp <= 59 ) && (tmp >=0) )
	{
		Date.tm_sec =tmp;
	}
	else
	{
		goto sysSetTimeStrError;
	}

	printf("Set %d-%02d-%02d %02d:%02d:%02d \n",
		 			Date.tm_year+1900,  /*year*/
		 			Date.tm_mon+1,      /*month*/
		 			Date.tm_mday,        /*day*/
		   			 Date.tm_hour,		/* hour */
		   			 Date.tm_min,		/* minute */
		   			 Date.tm_sec
		   			 );
	timeL = mktime(&Date);
	setTime.tv_sec =  timeL;
	setTime.tv_nsec = 0;

	rtcDateSet(Date.tm_year-70, Date.tm_mon+1,Date.tm_mday,1/*??*/);
	rtcTimeSet(Date.tm_hour,Date.tm_min,Date.tm_sec);

	clock_settime(0,&setTime);
	sysSyncRtcToOs();
	return OK;
sysSetTimeStrError:
	printf("incalid format:%s\n",p);
	return ERROR;
}


STATUS sysSyncRtcToOs(void)
{
	struct tm	Date;
	struct timespec setTime;
	time_t timeTmp;
	rtcSpIoctl (GET_DATE, FALSE);
	rtcSpIoctl (GET_TIME, FALSE);
	Date.tm_year = 70 + rtc_Year;
	Date.tm_mon = rtc_Month -1 ;
	Date.tm_mday = rtc_DayOfMonth ;
	Date.tm_hour = rtc_Hour;
	Date.tm_min = rtc_Minute;
	Date.tm_sec = rtc_Second;
	timeTmp =  mktime(&Date);
	if (timeTmp > 0 )
	{
		setTime.tv_sec =  timeTmp;
		setTime.tv_nsec = 0;
		clock_settime(0,&setTime);
	}
	else
	{
		/* set RTC to 2004-3-25,12:0:0*/
		rtcDateSet(2004,3,25,1/*??*/);
		rtcTimeSet(12,0,0);
	}
	return OK;
}