triton_functions.c

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

/*-------------------------------------------------------------------------------
// NAME        : Stop_BB_charge
//
// DESCRIPTION : Start the back-up battery charging     
//
// PARAMETERS  : No
//
// RETURN VALUE: 
//
// LIMITATIONS : None
//------------------------------------------------------------------------------- */

void Stop_BB_charge(void)
{
  /* Selects the PMC_SLAVE register page */
  MSI2C_AccessPage(PMC_SLAVE_page);
  
  /* Sets the end-of-charge threshold and enables the back-up battery charging */
  MSI2C_MasterPollingSendAbb(PMC_SLAVE_BBSPOR_CFG, 0x10);
}



/*-------------------------------------------------------------------------------
// NAME        : Start_PWM
//
// DESCRIPTION : Start the battery pulsed charge     
//
// PARAMETERS  : duty cycle
//
// RETURN VALUE: N/A
//
// LIMITATIONS : None
//------------------------------------------------------------------------------- */
void Start_PWM(int duty_cycle)
{
  /* Selects the BCI register page */
  MSI2C_AccessPage(BCI_page);
  
  /* Sets MSBs of the duty cycle in the control register */
  MSI2C_MasterPollingSendAbb(BCI_BCIPWM1, ((duty_cycle >> 2) & 0xff));
  
  /* Sets LSBs of the duty cycle in the control register and enables the pulsed charge */
  MSI2C_MasterPollingSendAbb(BCI_BCIPWM2, ((duty_cycle & 0x3) << 6 | 0x20));
}





/*-------------------------------------------------------------------------------
// NAME        : Stop_PWM
//
// DESCRIPTION : Stop the battery pulsed charge     
//
// PARAMETERS  : N/A
//
// RETURN VALUE: N/A
//
// LIMITATIONS : None
//------------------------------------------------------------------------------- */
void Stop_PWM()
{
  /* Selects the BCI register page */
  MSI2C_AccessPage(BCI_page);
  
  /* Disables the pulsed charge */
  MSI2C_MasterPollingSendAbb(BCI_BCIPWM2, 0x0);
}




/*-------------------------------------------------------------------------------
// NAME        : Refresh_Watchdog
//
// DESCRIPTION : Re-writes the Watchdog key in WDKEY register to keep charging on     
//
// PARAMETERS  : N/A
//
// RETURN VALUE: N/A
//
// LIMITATIONS : None
//------------------------------------------------------------------------------- */
BOOL Refresh_Watchdog(int timer)
{
  int wdkey;
  int loop_time; /* in ms */
  int i,loop_number = 4;
  
  switch(timer)
    {
    case 1 :
      {
	wdkey = 0xAA;
	loop_time = 500;
      }
      break;
      
    case 2 :
      {
	wdkey = 0x55;
	loop_time = 1500;
      }
      break;
      
    case 4 :
      {
	wdkey = 0xDB;
	loop_time = 3500;
      }
      break;
      
    case 8 :
      {
	wdkey = 0xBD;
	loop_time = 7500;
      }
      break;
      
    default:
      break;
    }
  
  
  for (i=0;i<loop_number;i++)
    {
      /* Selects the BCI register page */
      MSI2C_AccessPage(BCI_page);
      
      /* Writes the specific key before the time counter is elapsed */
      MSI2C_MasterPollingSendAbb(BCI_BCIWDKEY, wdkey);
      
      /* delay before re-writing the key */
      TIME_WaitMs(loop_time);
    }
  
  return True;
}        

/*-------------------------------------------------------------------------------
// NAME        : reg_test
//
// DESCRIPTION : register Test value after reset
//
// PARAMETERS  : register table UWORD8
//
// RETURN VALUE: number of error UWORD16
//
// LIMITATIONS : None
//------------------------------------------------------------------------------- */
UWORD16 reg_test(UWORD8 REG_LIST[],UWORD16 length_tab,char *REG_NAME)
{
  UWORD16 result_tmp;
  UWORD8 read_value;
  char st[80];
  int i;
  result_tmp = 0x0;
  //  sprintf(st,"\rsize of tab : %x\r\n",length_tab/4);
  //  SERI_Send(st);
  SERI_Send("\r                                      REG    |  READ  |  EXPECTED\r\n");
  for ( i=0; i<length_tab/4;i++)
    {
      read_value = (MSI2C_MasterPollingReceiveAbb(REG_LIST[i*4]) & REG_LIST[i*4+1]);
      if ( read_value == (REG_LIST[i*4+3] & REG_LIST[i*4+1]) )
	{
	  result_tmp |= 0x0;
	  //	  	sprintf(st,"\r %35s \r",REG_NAME+(i*35));
	  //	  	SERI_Send(st);
	  sprintf(st,"\r %35s   %2x    |   %2x   |   %2x\r\n",REG_NAME+(i*35),REG_LIST[i*4],read_value,REG_LIST[i*4+3]);
	  SERI_Send(st);
	}      
      else
	{
	  result_tmp += 0x1;
	  //	  	sprintf(st,"\r %35s \r",REG_NAME+(i*35));
	  //	  	SERI_Send(st);
	  //	  	SERI_Send("\r  REG    |  READ   |  EXPECTED       ERROR !\r\n");
	  sprintf(st,"\r %35s...%2x....|...%2x...|...%2x...ERROR !\r\n",REG_NAME+(i*35),REG_LIST[i*4],read_value,REG_LIST[i*4+3]);
	  SERI_Send(st);
	}      
    }
  return (result_tmp);
}

/*-------------------------------------------------------------------------------
// NAME        : module_reg_test
//
// DESCRIPTION : module's register Test value after reset
//
// PARAMETERS  : no
//
// RETURN VALUE: number of error UWORD16
//
// LIMITATIONS : None
//-------------------------------------------------------------------------------*/
UWORD16 Aux_reg_test(void)
{
  UWORD16 result_temp = 0x0;
  SERI_Send("\r\n.........................AUX BAR.......................\r\n");
  MSI2C_AccessPage(USB_page);
  SERI_Send("\r.......USB\r\n");
  result_temp =  reg_test(USB_REG_LIST,USB_REG_LENGTH,USB_REG_NAME);
  SERI_Send("\r.......MADC\r\n");
  result_temp += reg_test(MADC_REG_LIST,MADC_REG_LENGTH,MADC_REG_NAME);
  SERI_Send("\r.......VIB\r\n");
  result_temp += reg_test(VIB_REG_LIST,VIB_REG_LENGTH,VIB_REG_NAME);
  SERI_Send("\r.......AUX\r\n");
  result_temp += reg_test(AUX_REG_LIST,AUX_REG_LENGTH,AUX_REG_NAME);
  SERI_Send("\r.......WLED\r\n");
  result_temp += reg_test(WLED_REG_LIST,WLED_REG_LENGTH,WLED_REG_NAME);
  SERI_Send("\r.......BCI\r\n");
  result_temp += reg_test(BCI_REG_LIST,BCI_REG_LENGTH,BCI_REG_NAME);
  SERI_Send("\r.......SIM\r\n");
  result_temp += reg_test(SIM_CARD_REG_LIST,SIM_CARD_REG_LENGTH,SIM_CARD_REG_NAME);
  return (result_temp);
}
UWORD16 Audio_reg_test(void)
{
  UWORD16 result_temp = 0x0;
  SERI_Send("\r\n.........................AUDIO BAR.....................\r\n");
  MSI2C_AccessPage(AUDIO_page);
  result_temp =  reg_test(AUDIO_REG_LIST,AUDIO_REG_LENGTH,AUDIO_REG_NAME);  
  return (result_temp);
}
UWORD16 Int_reg_test(void)
{
  UWORD16 result_temp = 0x0;
  SERI_Send("\r\n.........................INT BAR.......................\r\n");
  // correction of INT2_IT2STATUSP1L Reset Value
  // INT2_REG_LIST[7*4+3] = 0x80;
  // SERI_Send("\rINT2_IT2STATUSP1L modified to 0x80 instead of 0x00\r\n");
  MSI2C_AccessPage(INT2_page);
  result_temp =  reg_test(INT2_REG_LIST,INT2_REG_LENGTH,INT2_REG_NAME);
  return (result_temp);
}
UWORD16 Pwr_reg_test(void)
{
  UWORD16 result_temp = 0x0;
  SERI_Send("\r\n.........................POWER BAR.....................\r\n");
  MSI2C_AccessPage(PMC_MASTER_page);
  // correction of PMC_MASTER_STS_HW_CONDITIONS Reset Value
  // PMC_MASTER_REG_LIST[7*4+3] = 0x90;
  // SERI_Send("\rPMC_MASTER_STS_HW_CONDITIONS modified to 0x90 instead of 0x80\r\n");
  SERI_Send("\r.......MASTER\r\n");
  result_temp =  reg_test(PMC_MASTER_REG_LIST,PMC_MASTER_REG_LENGTH,PMC_MASTER_REG_NAME);
  SERI_Send("\r.......SLAVE\r\n");
  result_temp += reg_test(PMC_SLAVE_REG_LIST,PMC_SLAVE_REG_LENGTH,PMC_SLAVE_REG_NAME);
  SERI_Send("\r.......RTC\r\n");
  result_temp += reg_test(RTC_REG_LIST,RTC_REG_LENGTH,RTC_REG_NAME);
  return (result_temp);
}


// -------------------------------------------------------
// Function to access Triton Registers via UART -> I2C
// -------------------------------------------------------
void I2C_uart(void)
{   
  UWORD32 page,module,reg_num,action,data,control;
  char st[80];
  int i;
  
  control = 1;
  
  while(control)
    {
      page = 0xffff;
      reg_num = 0xffff;
      action = 0xffff; 
      data = 0xffff;
      
      while(page == 0xffff)
	{
	  SERI_Send("\r USB        < 0 > \r\n"); 
	  SERI_Send("\r MADC       < 1 > \r\n"); 
	  SERI_Send("\r AUX        < 2 > \r\n"); 
	  SERI_Send("\r VIB        < 3 > \r\n"); 
	  SERI_Send("\r WLED       < 4 > \r\n"); 
	  SERI_Send("\r BCI        < 5 > \r\n"); 
	  SERI_Send("\r SIM_CARD   < 6 > \r\n"); 
	  SERI_Send("\r INT        < 7 > \r\n"); 
	  SERI_Send("\r AUDIO      < 8 > \r\n"); 
	  SERI_Send("\r RTC        < 9 > \r\n"); 
	  SERI_Send("\r PMC_MASTER < A > \r\n"); 
	  SERI_Send("\r PMC_SLAVE  < B > \r\n"); 
	  SERI_Send("\r\nENTER TRITON MODULE < 0 -> B > \r\n"); 
	  module = SERI_GetHexNum(0x01);
	  if (module<0x9)
	    page =0x0;
	  else if (module<0xC)
	    page =0x1;
	}
      while(reg_num == 0xffff) 
	{
	  switch(module) {
	  case 0 :
	    for ( i=0; i<USB_REG_LENGTH/4;i++)
	      {
		sprintf(st,"\r %35s <%2x>\r\n",&USB_REG_NAME[i*35],USB_REG_LIST[i*4]);
		SERI_Send(st);
	      }
	    break;
	  case 1 :
	    for ( i=0; i<MADC_REG_LENGTH/4;i++)
	      {
		sprintf(st,"\r %35s <%2x>\r\n",&MADC_REG_NAME[i*35],MADC_REG_LIST[i*4]);
		SERI_Send(st);
	      }
	    break;
	  case 2 :
	    for ( i=0; i<AUX_REG_LENGTH/4;i++)
	      {
		sprintf(st,"\r %35s <%2x>\r\n",&AUX_REG_NAME[i*35],AUX_REG_LIST[i*4]);
		SERI_Send(st);
	      }
	    break;
	  case 3 :
	    for ( i=0; i<VIB_REG_LENGTH/4;i++)
	      {
		sprintf(st,"\r %35s <%2x>\r\n",&VIB_REG_NAME[i*35],VIB_REG_LIST[i*4]);
		SERI_Send(st);
	      }
	    break;
	  case 4 :
	    for ( i=0; i<WLED_REG_LENGTH/4;i++)
	      {
		sprintf(st,"\r %35s <%2x>\r\n",&WLED_REG_NAME[i*35],WLED_REG_LIST[i*4]);
		SERI_Send(st);
	      }
	    break;
	  case 5 :
	    for ( i=0; i<BCI_REG_LENGTH/4;i++)
	      {
		sprintf(st,"\r %35s <%2x>\r\n",&BCI_REG_NAME[i*35],BCI_REG_LIST[i*4]);
		SERI_Send(st);
	      }
	    break;
	  case 6 :
	    for ( i=0; i<SIM_CARD_REG_LENGTH/4;i++)
	      {
		sprintf(st,"\r %35s <%2x>\r\n",&SIM_CARD_REG_NAME[i*35],SIM_CARD_REG_LIST[i*4]);
		SERI_Send(st);
	      }
	    break;
	  case 7 :
	    for ( i=0; i<INT2_REG_LENGTH/4;i++)
	      {
		sprintf(st,"\r %35s <%2x>\r\n",&INT2_REG_NAME[i*35],INT2_REG_LIST[i*4]);
		SERI_Send(st);
	      }
	    break;
	  case 8 :
	    for ( i=0; i<AUDIO_REG_LENGTH/4;i++)
	      {
		sprintf(st,"\r %35s <%2x>\r\n",&AUDIO_REG_NAME[i*35],AUDIO_REG_LIST[i*4]);
		SERI_Send(st);
	      }
	    break;
	  case 9 :
	    for ( i=0; i<RTC_REG_LENGTH/4;i++)
	      {
		sprintf(st,"\r %35s <%2x>\r\n",&RTC_REG_NAME[i*35],RTC_REG_LIST[i*4]);
		SERI_Send(st);
	      }
	    break;
	  case 0xA :
	    for ( i=0; i<PMC_MASTER_REG_LENGTH/4;i++)
	      {
		sprintf(st,"\r %35s <%2x>\r\n",&PMC_MASTER_REG_NAME[i*35],PMC_MASTER_REG_LIST[i*4]);
		SERI_Send(st);
	      }
	    break;
	  case 0xB :
	    for ( i=0; i<PMC_SLAVE_REG_LENGTH/4;i++)
	      {
		sprintf(st,"\r %35s <%2x>\r\n",&PMC_SLAVE_REG_NAME[i*35],PMC_SLAVE_REG_LIST[i*4]);
		SERI_Send(st);
	      }
	    break;
	  default :
	    break;}
	  SERI_Send("\r\nENTER TRITON REGISTER NUMBER < 00..FF > \r\n");
	  reg_num =  SERI_GetHexNum(0x02);
	}
      
      if(page == 0)
	{
	  MSI2C_AccessPage(0x00);
	}
      if(page == 1)
	{ 
	  MSI2C_AccessPage(0x01);	
	}
      
      while((action == 0xffff)|(action<0x2)) 
	{
	  SERI_Send("\r\nACTION < WRITE = 0  READ = 1  ABORT = A>  \r\n");
	  action = SERI_GetHexNum(0x01);
	  switch(action)
	    {
	    case 1 :         
	      data = MSI2C_MasterPollingReceiveAbb((UWORD8)reg_num);
	      sprintf(st,"\r\nPAGE : %x  REG : %x  DATA : %x  \r\n", page,reg_num,data);
	      SERI_Send(st);
	      break;
	      
	    case 0:
	      data = 0xffff;