rtc.c

OMAP1030 处理器的ARM 侧硬件测试代码 OMAP1030 是TI的双核处理器

//----------------------------------------------------------------------------
void RTC_InitDdate(UWORD8 day, UWORD8 month,
                    UWORD8 year, UWORD8 week )
{
  day   = RTC_ConvBcd(day);
  month = RTC_ConvBcd(month);
  year  = RTC_ConvBcd(year);
  week  = RTC_ConvBcd(week);

  while (RTC_TEST_BUSY != 0);
  RTC_DAYS_REG   = day;
  RTC_MONTHS_REG = month;
  RTC_YEARS_REG  = year;
  RTC_WEEK_REG   = week;
}


//-------------------------------------------------------
//  NAME 	: RTC_InitDate
//  DESCRIPTION	: Initialize the date
//  RETURN VALUE: none
//  PARAMETERS	: values used to store in the differents registers
//  LIMITATIONS	:
//------------------------------------------------------
void RTC_InitDate(struct rtc_tm *const rtctime )
{
UWORD8 sec;
UWORD8 min;
UWORD8 hour;
UWORD8 day;
UWORD8 mon;
UWORD8 year;
UWORD8 wday;

  sec = RTC_ConvBcd(rtctime->rtc_sec);
  min = RTC_ConvBcd(rtctime->rtc_min);
  if ((rtctime->rtc_hour) > 12 || (rtctime->rtc_1224md) == 0)
  {
      RTC_CTRL_REG &= ~RTC_MODE_12_24;
      hour = RTC_ConvBcd(rtctime->rtc_hour);
  } else
  {
      RTC_CTRL_REG |= RTC_MODE_12_24;
      hour = RTC_ConvBcd(rtctime->rtc_hour) | (rtctime->rtc_PM << 7);
  }

  day  = RTC_ConvBcd(rtctime->rtc_day);
  mon  = RTC_ConvBcd(rtctime->rtc_mon);
  year = RTC_ConvBcd(rtctime->rtc_year);
  wday = RTC_ConvBcd(rtctime->rtc_wday);

  while (RTC_TEST_BUSY != 0);
  RTC_DAYS_REG    = day;
  RTC_MONTHS_REG  = mon;
  RTC_YEARS_REG   = year;
  RTC_WEEK_REG    = wday;
  RTC_SECONDS_REG = sec;
  RTC_MINUTES_REG = min;
  RTC_HOURS_REG   = hour;
}


//------------------------------------------------------------------------
// NAME        : RTC_SetAlarm
// DESCRIPTION : Set the alarm registers
// RETURN VALUE: none
// PARAMETERS  : values used to store in the differents registers
//----------------------------------------------------------------------
void RTC_SetAlarm(struct rtc_tm *rtctime )
{
UWORD8 sec;
UWORD8 min;
UWORD8 hour;
UWORD8 day;
UWORD8 mon;
UWORD8 year;
UWORD8 wday;

  sec = RTC_ConvBcd(rtctime->rtc_sec);
  min = RTC_ConvBcd(rtctime->rtc_min);

  if ( (rtctime->rtc_hour) > 12 || (rtctime->rtc_1224md) == 0 )
  {
     hour = RTC_ConvBcd(rtctime->rtc_hour);
  }

  else
  {
     hour = RTC_ConvBcd(rtctime->rtc_hour) | (rtctime->rtc_PM << 7);
  }//endif

  day  = RTC_ConvBcd(rtctime->rtc_day);
  mon  = RTC_ConvBcd(rtctime->rtc_mon);
  year = RTC_ConvBcd(rtctime->rtc_year);
  wday = RTC_ConvBcd(rtctime->rtc_wday);

  while (RTC_TEST_BUSY != 0);

  RTC_ALARM_DAYS_REG    = day;
  RTC_ALARM_MONTHS_REG  = mon;
  RTC_ALARM_YEARS_REG   = year;
  RTC_ALARM_SECONDS_REG = sec;
  RTC_ALARM_MINUTES_REG = min;
  RTC_ALARM_HOURS_REG   = hour;
}


//--------------------------------------------------------------------
//  NAME        : RTC_SetMode1224
//  DESCRIPTION : Set the mode 12_24 0=>24 hours mode
//  RETURN VALUE: None
//  PARAMETERS  : 12 or 24 hours mode
//  LIMITATIONS :
//-------------------------------------------------------------------------
void RTC_SetMode1224(const UWORD8 mode)
{
  if ( mode == RTC_12_MODE)
      RTC_CTRL_REG |= mode << 3;
  else
      RTC_CTRL_REG &= 0xfff7;
}


//--------------------------------------------------------------------
//  NAME 	: RTC_GetSec
//  DESCRIPTION	: Return the RTC seconds register
//  RETURN VALUE: value store in the RTC SECOND register
//  PARAMETERS	: none
//  LIMITATIONS	:
//--------------------------------------------------------------------
UWORD8 RTC_GetSec(void)
{
  while (RTC_TEST_BUSY != 0);
  return RTC_ConvBin(RTC_SECONDS_REG);
}



//--------------------------------------------------------------
//  NAME 	: RTC_GetMin
//  DESCRIPTION	: Return the RTC minutes register
//  RETURN VALUE	: value store in the RTC MINUTE register
//  PARAMETERS	: none
//---------------------------------------------------------------
UWORD8 RTC_GetMin(void)
{
  while (RTC_TEST_BUSY != 0);
  return RTC_ConvBin(RTC_MINUTES_REG);
}


//--------------------------------------------------------------
// NAME 	: RTC_GetHrs
// DESCRIPTION	: Return the RTC hours register
// RETURN VALUE	: value store in the RTC HOUR register
// PARAMETERS	: none
//-------------------------------------------------------------
UWORD8 RTC_GetHrs(void)
{
  while (RTC_TEST_BUSY != 0);
  return RTC_ConvBin(0x7f & RTC_HOURS_REG);
}

//-----------------------------------------------------------------
// NAME 	: RTC_GetPMnAM
// DESCRIPTION	: Return the PM_AM mode AM=>0 PM=>1
// RETURN VALUE	: Return if it's the morning or the afternoon.
// PARAMETERS	: none
//-----------------------------------------------------------------
UWORD8 RTC_GetPMnAM(void)
{
   while (RTC_TEST_BUSY != 0);
   return( (RTC_HOURS_REG & 0x80) >> 7);
}


//-------------------------------------------------------------
// NAME 		: RTC_GetMode12_24
// DESCRIPTION	: Return the mode 12_24 0=>24 hours mode
// RETURN VALUE	: mode actually used => 12 or 24 hours mode
// PARAMETERS	: none
// LIMITATIONS	:
//-------------------------------------------------------------
UWORD8 RTC_GetMode12_24(void)
{
  return((RTC_CTRL_REG & RTC_MODE_12_24 )>>3);
}


//-------------------------------------------------------------
// NAME 	: RTC_GetDay
// DESCRIPTION	: Return the RTC days register
// RETURN VALUE	: value store in the RTC DAY register
// PARAMETERS	: none
// LIMITATIONS	:
//-------------------------------------------------------------
UWORD8 RTC_GetDay(void)
{
  while (RTC_TEST_BUSY != 0);
  return RTC_ConvBin(RTC_DAYS_REG);
}


//------------------------------------------------------------
// NAME 	: RTC_GetMon
// DESCRIPTION	: Return the RTC months register
// RETURN VALUE	: value store in the RTC MONTH register
// PARAMETERS	: none
// LIMITATIONS	:
//------------------------------------------------------------
UWORD8 RTC_GetMon(void)
{
  while (RTC_TEST_BUSY != 0);
  return RTC_ConvBin(RTC_MONTHS_REG);
}


//-----------------------------------------------------------
// NAME 	: RTC_GetYear
// DESCRIPTION	: Return the RTC years register
// RETURN VALUE	: value store in the RTC YEAR register
// PARAMETERS	: none
//-----------------------------------------------------------
UWORD8 RTC_GetYear(void)
{
  while (RTC_TEST_BUSY != 0);
  return RTC_ConvBin(RTC_YEARS_REG);
}


//----------------------------------------------------------------
// NAME 	: RTC_GetWeek
// DESCRIPTION	: Return the RTC week register
// RETURN VALUE	: value store in the RTC WEEK register
// PARAMETERS	: none
//----------------------------------------------------------------
UWORD8 RTC_GetWeek(void)
{
  while (RTC_TEST_BUSY != 0);
  return RTC_ConvBin(RTC_WEEK_REG);
}

//--------------------------------------------------------
// NAME 	: RTC_GetDate
// DESCRIPTION	: Get the date
// RETURN VALUE	: Actual date.
// PARAMETERS	: strcture on the RTC registers
//--------------------------------------------------------
void RTC_GetDate(struct rtc_tm *rtctime )
{
UWORD8 sec;
UWORD8 min;
UWORD8 hour;
UWORD8 day;
UWORD8 mon;
UWORD8 year;
UWORD8 wday;
UWORD8 hr_reg;

  while (RTC_TEST_BUSY != 0);
  sec    = RTC_SECONDS_REG;
  min    = RTC_MINUTES_REG;
  hr_reg = RTC_HOURS_REG;
  hour   = (0x7f & hr_reg);
  day    = RTC_DAYS_REG;
  mon    = RTC_MONTHS_REG;
  year   = RTC_YEARS_REG;
  wday   = RTC_WEEK_REG;

  rtctime->rtc_sec = RTC_ConvBin(sec);
  rtctime->rtc_min = RTC_ConvBin(min);
  rtctime->rtc_hour = RTC_ConvBin(hour);

  if (   RTC_ConvBin(hour) > 12
      || ((RTC_CTRL_REG & RTC_MODE_12_24) >> 3) == 0)
  {
	  rtctime->rtc_1224md = 0;
	  rtctime->rtc_PM = 0;
  }

  else
  {
	  rtctime->rtc_1224md = 1;
	  if (((hr_reg & 0x80)>>7) == RTC_AM)
	  	rtctime->rtc_PM = RTC_AM;
	  else
		rtctime->rtc_PM = RTC_PM;
  }

  rtctime->rtc_day = RTC_ConvBin(day);
  rtctime->rtc_mon = RTC_ConvBin(mon);
  rtctime->rtc_year = RTC_ConvBin(year);
  rtctime->rtc_wday = RTC_ConvBin(wday);
}


//------------------------------------------------------------------------
//  NAME 	: RTC_Rounding30s
//  DESCRIPTION : Rounding to the closest minute,
//                       by setting ROUND_30S bit of the control register.
//  PARAMETERS  : none
//  RETURN VALUE: none
//  LIMITATIONS : None
//------------------------------------------------------------------------
void RTC_Rounding30s(void)
{
  RTC_CTRL_REG |= RTC_ROUND_30S;
}


//------------------------------------------------------------------------
//  NAME 	: RTC_WaitUnitClk
//  DESCRIPTION : Waiting routine : ~2400 clk unit
//  PARAMETERS  : none
//  RETURN VALUE: none
//  LIMITATIONS : None
//------------------------------------------------------------------------
void RTC_WaitUnitClk (void)
{
int i;
// for (i=0;i<98;){i++;}
//  for (i=0;i<49;){i++;} // for Ulysse
//for (i=0;i<25;){i++;}
for (i=0;i<20;){i++;}
}


//-----------------------------------------------------------------------------
// RTC_TestRegisters
//-----------------------------------------------------------------------------
UWORD16 RTC_TestRegisters(void)
{
UWORD16 err=RES_OK;

	// TC Registers

	if ( RTC_SECONDS_REG != 0x00 )
	{
	  RES_Set(ERR_RTC_SEC);
	  err = RES_OK;
	}

	if ( RTC_MINUTES_REG != 0x00 )
	{
	  RES_Set(ERR_RTC_MIN);
	  err = RES_OK;
	}

	if ( RTC_HOURS_REG != 0x00 )
	{
	  RES_Set(ERR_RTC_HRS);
	  err = RES_OK;
	}

	if ( RTC_DAYS_REG != 0x01 )
	{
	  RES_Set(ERR_RTC_DAY);
	  err = RES_OK;
	}

	if ( RTC_MONTHS_REG != 0x01 )
	{
	  RES_Set(ERR_RTC_MON);
	  err = RES_OK;
	}

	if ( RTC_YEARS_REG != 0X00 )
	{
	  RES_Set(ERR_RTC_YEAR);
	  err = RES_OK;
	}

	if ( RTC_WEEK_REG != 0x00 )
	{
	  RES_Set(ERR_RTC_WDAY);
	  err = RES_OK;
	}

	// TC Alarm registers

	if ( RTC_ALARM_SECONDS_REG != 0x00 )
	{
	  RES_Set(ERR_RTC_ALARM_SEC);
	  err = RES_OK;
	}

	if ( RTC_ALARM_MINUTES_REG != 0x00 )
	{
	  RES_Set(ERR_RTC_ALARM_MIN);
	  err = RES_OK;
	}

	if ( RTC_ALARM_HOURS_REG != 0x00 )
	{
	  RES_Set(ERR_RTC_ALARM_HRS);
	  err = RES_OK;
	}

	if ( RTC_ALARM_DAYS_REG != 0x01 )
	{
	  RES_Set(ERR_RTC_ALARM_DAY);
	  err = RES_OK;
	}

	if ( RTC_ALARM_MONTHS_REG != 0x01 )
	{
	  RES_Set(ERR_RTC_ALARM_MON);
	  err = RES_OK;
	}

	if ( RTC_ALARM_YEARS_REG != 0x00 )
	{
	  RES_Set(ERR_RTC_ALARM_YEAR);
	  err = RES_OK;
	}

	// General registers

	if ( RTC_CTRL_REG != 0x00 )
	{
	  RES_Set(ERR_RTC_CTRL_REG);
	  err = RES_OK;
	}

	if ( RTC_INTERRUPTS_REG != 0x00 )
	{
	  RES_Set(ERR_RTC_INTERRUPTS_REG);
	  err = RES_OK;
	}

	if ( RTC_STATUS_REG != 0x80 )
	{
	  RES_Set(ERR_RTC_STATUS_REG);
	  err = RES_OK;
	}

	RTC_STATUS_REG = 0x80;

	if ( RTC_STATUS_REG != 0x00 )
	{
	  RES_Set(ERR_RTC_STATUS_REG);
	  err = RES_OK;
	}

	// Compensation registers

	if ( RTC_COMP_MSB_REG != 0x00 )
	{
	  RES_Set(ERR_RTC_COMP_MSB_REG);
	  err = RES_OK;
	}

	if ( RTC_COMP_LSB_REG != 0x00 )
	{
	  RES_Set(ERR_RTC_COMP_LSB_REG);
	  err = RES_OK;
	}

 	return err;
}