rtc.c

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

//-----------------------------------------------------------------------------
//            TEXAS INSTRUMENTS INCORPORATED PROPRIETARY INFORMATION
//
//   Property of Texas Instruments -- For  Unrestricted  Internal  Use  Only
//   Unauthorized reproduction and/or distribution is strictly prohibited.  This
//   product  is  protected  under  copyright  law  and  trade  secret law as an
//   unpublished work.  Created 1987, (C) Copyright 2000 Texas Instruments.  All
//   rights reserved.
//   Filename    : rtc.c
//   Description : Set of function to test RTC module
//   Project     : Samson
//   Author      : Sylvain Munsch
//                 Adapt to samson by Francois Reygagne Francois REYGAGNE
//                 Adapted for Helen by Jean-Philippe ULPIANO
//---------------------------------------------------------------------------

#include "test.h"
#include "global_types.h"
#include "result.h"
#include "intvecs.h"
#include "rtc.h"
#include "result.h"
#include "reset.h"
#include "errorcodes.h"



void RTC_TestResetValue(void)
{

  TEST_FIELD_RESET_VALUE(RTC_SECONDS_REG,SEC0);
  TEST_FIELD_RESET_VALUE(RTC_SECONDS_REG,SEC1);

  TEST_FIELD_RESET_VALUE(RTC_MINUTES_REG,MIN0);
  TEST_FIELD_RESET_VALUE(RTC_MINUTES_REG,MIN1);

  TEST_FIELD_RESET_VALUE(RTC_HOURS_REG,HOUR0);
  TEST_FIELD_RESET_VALUE(RTC_HOURS_REG,HOUR1);
  TEST_FIELD_RESET_VALUE(RTC_HOURS_REG,PM_nAM);

  TEST_FIELD_RESET_VALUE(RTC_DAYS_REG,DAY0);
  TEST_FIELD_RESET_VALUE(RTC_DAYS_REG,DAY1);

  TEST_FIELD_RESET_VALUE(RTC_MONTHS_REG,MONTH0);
  TEST_FIELD_RESET_VALUE(RTC_MONTHS_REG,MONTH1);

  TEST_FIELD_RESET_VALUE(RTC_YEARS_REG,YEAR0);
  TEST_FIELD_RESET_VALUE(RTC_YEARS_REG,YEAR1);

  TEST_FIELD_RESET_VALUE(RTC_WEEK_REG,WEEK);

  TEST_FIELD_RESET_VALUE(RTC_ALARM_SECONDS_REG,ALRM_SEC0);
  TEST_FIELD_RESET_VALUE(RTC_ALARM_SECONDS_REG,ALRM_SEC1);

  TEST_FIELD_RESET_VALUE(RTC_ALARM_MINUTES_REG,ALRM_MIN0);
  TEST_FIELD_RESET_VALUE(RTC_ALARM_MINUTES_REG,ALRM_MIN1);

  TEST_FIELD_RESET_VALUE(RTC_ALARM_HOURS_REG,ALRM_HOUR0);
  TEST_FIELD_RESET_VALUE(RTC_ALARM_HOURS_REG,ALRM_HOUR1);
  TEST_FIELD_RESET_VALUE(RTC_ALARM_HOURS_REG,ALRM_PM_nAM);

  TEST_FIELD_RESET_VALUE(RTC_ALARM_DAYS_REG,ALRM_DAY0);
  TEST_FIELD_RESET_VALUE(RTC_ALARM_DAYS_REG,ALRM_DAY1);

  TEST_FIELD_RESET_VALUE(RTC_ALARM_MONTHS_REG,ALRM_MONTH0);
  TEST_FIELD_RESET_VALUE(RTC_ALARM_MONTHS_REG,ALRM_MONTH1);

  TEST_FIELD_RESET_VALUE(RTC_ALARM_YEARS_REG,ALRM_YEAR0);
  TEST_FIELD_RESET_VALUE(RTC_ALARM_YEARS_REG,ALRM_YEAR1);

  TEST_FIELD_RESET_VALUE(RTC_CTRL_REG,STOP_RTC);
  TEST_FIELD_RESET_VALUE(RTC_CTRL_REG,RND30S);
  TEST_FIELD_RESET_VALUE(RTC_CTRL_REG,AUTOCOMP);
  TEST_FIELD_RESET_VALUE(RTC_CTRL_REG,MODE1224);
  TEST_FIELD_RESET_VALUE(RTC_CTRL_REG,TESTMODE);
  TEST_FIELD_RESET_VALUE(RTC_CTRL_REG,SET32CT);

  TEST_FIELD_RESET_VALUE(RTC_STATUS_REG,BUSY);
  TEST_FIELD_RESET_VALUE(RTC_STATUS_REG,RUN);
  TEST_FIELD_RESET_VALUE(RTC_STATUS_REG,F1SEVT);
  TEST_FIELD_RESET_VALUE(RTC_STATUS_REG,F1MEVT);
  TEST_FIELD_RESET_VALUE(RTC_STATUS_REG,F1HEVT);
  TEST_FIELD_RESET_VALUE(RTC_STATUS_REG,F1DEVT);
  TEST_FIELD_RESET_VALUE(RTC_STATUS_REG,ALRM);
  TEST_FIELD_RESET_VALUE(RTC_STATUS_REG,PWRUP);

  TEST_FIELD_RESET_VALUE(RTC_INTERRUPTS_REG,EVERY);
  TEST_FIELD_RESET_VALUE(RTC_INTERRUPTS_REG,ITTIMER);
  TEST_FIELD_RESET_VALUE(RTC_INTERRUPTS_REG,ITALRM);

  TEST_REGISTER_RESET_VALUE(RTC_COMP_LSB_REG);
  TEST_REGISTER_RESET_VALUE(RTC_COMP_MSB_REG);

  ARE_RESET_VALUES_OK();
}

void RTC_TestRegistersAccess(void)
{

  MODIFY_FIELD_RESET_VALUE16(RTC_SECONDS_REG,SEC0);
  MODIFY_FIELD_RESET_VALUE16(RTC_SECONDS_REG,SEC1);

  MODIFY_FIELD_RESET_VALUE16(RTC_MINUTES_REG,MIN0);
  MODIFY_FIELD_RESET_VALUE16(RTC_MINUTES_REG,MIN1);

  MODIFY_FIELD_RESET_VALUE16(RTC_HOURS_REG,HOUR0);
  MODIFY_FIELD_RESET_VALUE16(RTC_HOURS_REG,HOUR1);
  MODIFY_FIELD_RESET_VALUE16(RTC_HOURS_REG,PM_nAM);

  MODIFY_FIELD_RESET_VALUE16(RTC_DAYS_REG,DAY0);
  MODIFY_FIELD_RESET_VALUE16(RTC_DAYS_REG,DAY1);

  MODIFY_FIELD_RESET_VALUE16(RTC_MONTHS_REG,MONTH0);
  MODIFY_FIELD_RESET_VALUE16(RTC_MONTHS_REG,MONTH1);

  MODIFY_FIELD_RESET_VALUE16(RTC_YEARS_REG,YEAR0);
  MODIFY_FIELD_RESET_VALUE16(RTC_YEARS_REG,YEAR1);

  MODIFY_FIELD_RESET_VALUE16(RTC_WEEK_REG,WEEK);

  MODIFY_FIELD_RESET_VALUE16(RTC_ALARM_SECONDS_REG,ALRM_SEC0);
  MODIFY_FIELD_RESET_VALUE16(RTC_ALARM_SECONDS_REG,ALRM_SEC1);

  MODIFY_FIELD_RESET_VALUE16(RTC_ALARM_MINUTES_REG,ALRM_MIN0);
  MODIFY_FIELD_RESET_VALUE16(RTC_ALARM_MINUTES_REG,ALRM_MIN1);

  MODIFY_FIELD_RESET_VALUE16(RTC_ALARM_HOURS_REG,ALRM_HOUR0);
  MODIFY_FIELD_RESET_VALUE16(RTC_ALARM_HOURS_REG,ALRM_HOUR1);
  MODIFY_FIELD_RESET_VALUE16(RTC_ALARM_HOURS_REG,ALRM_PM_nAM);

  MODIFY_FIELD_RESET_VALUE16(RTC_ALARM_DAYS_REG,ALRM_DAY0);
  MODIFY_FIELD_RESET_VALUE16(RTC_ALARM_DAYS_REG,ALRM_DAY1);

  MODIFY_FIELD_RESET_VALUE16(RTC_ALARM_MONTHS_REG,ALRM_MONTH0);
  MODIFY_FIELD_RESET_VALUE16(RTC_ALARM_MONTHS_REG,ALRM_MONTH1);

  MODIFY_FIELD_RESET_VALUE16(RTC_ALARM_YEARS_REG,ALRM_YEAR0);
  MODIFY_FIELD_RESET_VALUE16(RTC_ALARM_YEARS_REG,ALRM_YEAR1);

  MODIFY_FIELD_RESET_VALUE16(RTC_CTRL_REG,STOP_RTC);
  MODIFY_FIELD_RESET_VALUE16(RTC_CTRL_REG,RND30S);
  MODIFY_FIELD_RESET_VALUE16(RTC_CTRL_REG,AUTOCOMP);
  MODIFY_FIELD_RESET_VALUE16(RTC_CTRL_REG,MODE1224);
  MODIFY_FIELD_RESET_VALUE16(RTC_CTRL_REG,TESTMODE);
  MODIFY_FIELD_RESET_VALUE16(RTC_CTRL_REG,SET32CT);

  MODIFY_FIELD_RESET_VALUE16(RTC_STATUS_REG,ALRM);
  MODIFY_FIELD_RESET_VALUE16(RTC_STATUS_REG,PWRUP);

  MODIFY_FIELD_RESET_VALUE16(RTC_INTERRUPTS_REG,EVERY);
  MODIFY_FIELD_RESET_VALUE16(RTC_INTERRUPTS_REG,ITTIMER);
  MODIFY_FIELD_RESET_VALUE16(RTC_INTERRUPTS_REG,ITALRM);

  MODIFY_REGISTER_RESET_VALUE16(RTC_COMP_LSB_REG);
  MODIFY_REGISTER_RESET_VALUE16(RTC_COMP_MSB_REG);

  ARE_RESET_VALUES_OK();
}

//---------------------------------------------------------------------------
//  NAME 	: RTC_NumDays
//  DESCRIPTION	: Numbers of days since year 00, Year 00 is a leap year
//  RETURN VALUE:
//  PARAMETERS	:
//  LIMITATIONS	:
//--------------------------------------------------------------------------
int RTC_NumDays(struct rtc_tm *time)
{
int cpt=0;
int cpt_feb;
int nbj = time->rtc_day - 1;

  if ( !(time->rtc_year%4))
  {
    cpt_feb = 29;
  }
  else {
    cpt_feb = 28;
  }

  switch(time->rtc_mon) {
    case 1 : cpt = nbj;
             break;
    case 2 : cpt = 31 + nbj ;
             break;
    case 3 : cpt = 31 + cpt_feb + nbj;
             break;
    case 4 : cpt = 31 + cpt_feb + 31 + nbj;
             break;
    case 5 : cpt = 31 + cpt_feb + 31 + 30 + nbj;
             break;
    case 6 : cpt = 31 + cpt_feb + 31 + 30 + 31 + nbj;
             break;
    case 7 : cpt = 31 + cpt_feb + 31 + 30 + 31 + 30 + nbj;
             break;
    case 8 : cpt = 31 + cpt_feb + 31 + 30 + 31 + 30 + 31 + nbj;
             break;
    case 9 : cpt = 31 + cpt_feb + 31 + 30 + 31 + 30 + 31 + 31 + nbj;
             break;
    case 10: cpt = 31 + cpt_feb + 31 + 30 + 31 + 30 + 31 + 31 + 30 + nbj;
             break;
    case 11: cpt = 31 + cpt_feb + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + nbj;
             break;
    case 12: cpt = 31 + cpt_feb + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 +
                   nbj;
             break;
  }

  return ( cpt + time->rtc_year * 365 + ((time->rtc_year - 1)/4) );

}

//-------------------------------------------------------------------------
// NAME 	: RTC_int num_sec
// DESCRIPTION	: Numbers of seconds since year 00,Year 00 is a leap year
// RETURN VALUE	:
// PARAMETERS	: structure on the RTC register.
// LIMITATIONS	:
//------------------------------------------------------------------
unsigned int RTC_NumSec(struct rtc_tm *time)
{
unsigned int nb_sec=0;
int nb_day=0;
int nb_hrs=0;

  nb_day = RTC_NumDays(time);

  if (time->rtc_1224md == 0)
  	{
    	nb_hrs=time->rtc_hour;
  	}
  else if (time->rtc_PM == 0)
	{ /* AM */
    	if (time->rtc_hour == 12)
    		{
      		nb_hrs=0;
    		}
    	else
    		{
      		nb_hrs=time->rtc_hour;
    		}
  	}
  else if (time->rtc_hour == 12)
	{
    	nb_hrs=12;
  	}
  else
  	{
    	nb_hrs=time->rtc_hour + 12;
  	}

  nb_sec = time->rtc_sec + 60*(time->rtc_min) + 3600*nb_hrs + 24*3600*nb_day ;

  return nb_sec;

}

//------------------------------------------------------------
// NAME 	: RTC_ConvBin
// DESCRIPTION	: BCD to binary conversion function
// PARAMETERS	: value in BCD
// RETURN VALUE	: value in in binary
//-----------------------------------------------------------
UWORD8  RTC_ConvBin(const UWORD8 value)
{
  return ( 10 * (value>>4) + (value & 0x0f) );
}

//----------------------------------------------------------------
// NAME 	: RTC_ConvBcd
// DESCRIPTION	: Binary to BCD conversion function
// RETURN VALUE	: value in BCD
// PARAMETERS	: value in binary
//----------------------------------------------------------------
UWORD8  RTC_ConvBcd(const UWORD8 value)
{
  return ( (value%10) | ((value/10)<<4) );
}


//----------------------------------------------------
// NAME       : RTC_BusyFallingEdge
// DESCRIPTION: Detect a busy falling edge
// RETURN VALUE	: none
// PARAMETERS	: none
// LIMITATIONS	:
//----------------------------------------------------
void RTC_BusyFallingEdge(void)
{
  while (RTC_TEST_BUSY != 1) {};
  while (RTC_TEST_BUSY == 1) {};
}


//-----------------------------------------------------------------------
//  NAME 	: RTC_InitSec
//  DESCRIPTION	: Initialize the RTC seconds register
//  RETURN VALUE: none
//  PARAMETERS	: value to store in the RTC SECOND register
//  LIMITATIONS	:
//-----------------------------------------------------------------------
void RTC_InitSec(const UWORD8 value)
{
UWORD8 second;

 second = RTC_ConvBcd(value);

 while (RTC_TEST_BUSY != 0) {};

 RTC_SECONDS_REG = second;
}

//---------------------------------------------------------------------------
// NAME 	: RTC_InitMin
// DESCRIPTION  : Initialize the RTC minutes register
// RETURN VALUE : none
// PARAMETERS   : value to store in the RTC MINUTE register
// LIMITATIONS  : none
//--------------------------------------------------------------------------
void RTC_InitMin(const UWORD8 value)
{
UWORD8 minute;
  minute = RTC_ConvBcd(value);
  while (RTC_TEST_BUSY != 0);
  RTC_MINUTES_REG = minute;
}


//-------------------------------------------------------------------------
//  NAME 	: RTC_InitHrs
//  DESCRIPTION	: Initialize the RTC hours register
// RETURN VALUE	: none
// PARAMETERS	:
//   mode12 = 1 => PM-AM mode
//   pm     = 1 => PM (Only usued in PM_AM mode)
// LIMITATIONS	:
//-----------------------------------------------------------------------
void RTC_InitHrs(const UWORD8 value, const char mode12, const char pm)
{
UWORD8 hour;
  if (value > 12 || mode12 == 0)
  {
     RTC_CTRL_REG &= ~RTC_MODE_12_24;
     hour = RTC_ConvBcd(value);
  }
  else
  {
      RTC_CTRL_REG |= RTC_MODE_12_24;
      hour = RTC_ConvBcd(value) | (pm << 7);
  }

  while (RTC_TEST_BUSY != 0);
  RTC_HOURS_REG = hour;
}


//---------------------------------------------------------------
//  NAME        : RTC_InitDay
//  DESCRIPTION	: Initialize the RTC days register
//  PARAMETERS	: value is used to initialize RTC DAY register
//  RETURN VALUE: none
//--------------------------------------------------------------
void RTC_InitDay(const UWORD8 value)
{
UWORD8	day;

 day = RTC_ConvBcd(value);
 while (RTC_TEST_BUSY != 0);
 RTC_DAYS_REG = day;
}


//------------------------------------------------------------------
//  NAME 	: RTC_InitMon
//  DESCRIPTION	: Initialize the RTC months register
//  RETURN VALUE: none
//  PARAMETERS	: value is used to initialize RTC MONTH register
//  LIMITATIONS	:
//------------------------------------------------------------------
void RTC_InitMon(const UWORD8 value)
{
UWORD8 month;
  month = RTC_ConvBcd(value);
  while (RTC_TEST_BUSY != 0);
  RTC_MONTHS_REG = month;
}


//------------------------------------------------------------------
//  NAME 	: RTC_InitYear
//  DESCRIPTION	: Initialize the RTC years register
//  PARAMETERS	: value is used to initialize RTC YEAR register
//  RETURN VALUE: none
//  LIMITATIONS	:  none
//------------------------------------------------------------------
void RTC_InitYear(const UWORD8 value)
{
UWORD8 year;
  year = RTC_ConvBcd(value);
  while (RTC_TEST_BUSY != 0);
  RTC_YEARS_REG = year;
}


//---------------------------------------------------------------
//  NAME 	: RTC_InitWeek
//  DESCRIPTION	: Initialize the RTC week register
//  RETURN VALUE: none
//  PARAMETERS	: value is used to initialize RTC Week register
//  LIMITATIONS	:
//---------------------------------------------------------------------
void RTC_InitWeek(const UWORD8 value)
{
UWORD8 week;

  week = RTC_ConvBcd(value);
  while (RTC_TEST_BUSY != 0);
  RTC_WEEK_REG = week;
}


//----------------------------------------------------------------------------
//  NAME 	: RTC_InitTime
//  DESCRIPTION	: Initialize the time (seconds, minutes and hours register)
//  RETURN VALUE: none
//  PARAMETERS	: values used to store in the differents registers
//----------------------------------------------------------------------------
void RTC_InitTime(const UWORD8 sec, const UWORD8 min, const UWORD8 hrs,
                   const char mode12, const char pm )
{
UWORD8	second;
UWORD8	minute;
UWORD8	hour;

  second = RTC_ConvBcd(sec);
  minute = RTC_ConvBcd(min);

  if (hrs > 12 || mode12 == 0)
  {
     RTC_CTRL_REG &= ~RTC_MODE_12_24;
     hour = RTC_ConvBcd(hrs);
  }

  else
  {
     RTC_CTRL_REG |= RTC_MODE_12_24;
     hour = RTC_ConvBcd(hrs) | (pm << 7);
  }

  while (RTC_TEST_BUSY != 0);
  RTC_SECONDS_REG = second;
  RTC_MINUTES_REG = minute;
  RTC_HOURS_REG   = hour;
}



//-----------------------------------------------------------------------------
// NAME        : RTC_InitDdate
// DESCRIPTION : Initialize the days date (days, months, years & week register)
// RETURN VALUE: none
// PARAMETERS  : values used to store in the differents registers
// LIMITATIONS :