triton_functions.c

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

  sprintf(st,"\rPMC_SLAVE_VRABB_CFG_STS value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_VRABB_RES_ID);
  sprintf(st,"\rPMC_SLAVE_VRABB_RES_ID value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_VRABB_CFG_STATE);
  sprintf(st,"\rPMC_SLAVE_VRABB_CFG_STATE value = %x \r\n",ReadData);
  SERI_Send(st);
  
  /* VRVBUS */
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_VRVBUS_CFG_STS);
  sprintf(st,"\rPMC_SLAVE_VRVBUS_CFG_STS value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_VRVBUS_RES_ID);
  sprintf(st,"\rPMC_SLAVE_VRVBUS_RES_ID value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_VRVBUS_CFG_STATE);
  sprintf(st,"\rPMC_SLAVE_VRVBUS_CFG_STATE value = %x \r\n",ReadData);
  SERI_Send(st);
  
  /* VREXTL */
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_VREXTL_CFG_STS);
  sprintf(st,"\rPMC_SLAVE_VREXTL_CFG_STS value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_VREXTL_RES_ID);
  sprintf(st,"\rPMC_SLAVE_VREXTL_RES_ID value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_VREXTL_CFG_STATE);
  sprintf(st,"\rPMC_SLAVE_VREXTL_CFG_STATE value = %x \r\n",ReadData);
  SERI_Send(st);
  
  /* REGEN */
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_EXT_REGEN_CFG_STS);
  sprintf(st,"\rPMC_SLAVE_EXT_REGEN_CFG_STS value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_EXT_REGEN_RES_ID);
  sprintf(st,"\rPMC_SLAVE_EXT_REGEN_RES_ID value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_EXT_REGEN_CFG_STATE);
  sprintf(st,"\rPMC_SLAVE_EXT_REGEN_CFG_STATE value = %x \r\n",ReadData);
  SERI_Send(st);
  
  /* CBAT32 */
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_CBAT32_CFG_STS);
  sprintf(st,"\rPMC_SLAVE_CBAT32_CFG_STS value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_CBAT32_RES_ID);
  sprintf(st,"\rPMC_SLAVE_CBAT32_RES_ID value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_CBAT32_CFG_STATE);
  sprintf(st,"\rPMC_SLAVE_CBAT32_CFG_STATE value = %x \r\n",ReadData);
  SERI_Send(st);
  
  /* CBAT28 */
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_CBAT28_CFG_STS);
  sprintf(st,"\rPMC_SLAVE_CBAT28_CFG_STS value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_CBAT28_RES_ID);
  sprintf(st,"\rPMC_SLAVE_CBAT28_RES_ID value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_CBAT28_CFG_STATE);
  sprintf(st,"\rPMC_SLAVE_CBAT28_CFG_STATE value = %x \r\n",ReadData);
  SERI_Send(st);
  
  /* BGAP */
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_BGAP_CFG_STS);
  sprintf(st,"\rPMC_SLAVE_BGAP_CFG_STS value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_BGAP_RES_ID);
  sprintf(st,"\rPMC_SLAVE_BGAP_RES_ID value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_BGAP_CFG_STATE);
  sprintf(st,"\rPMC_SLAVE_BGAP_CFG_STATE value = %x \r\n",ReadData);
  SERI_Send(st);
  
  /* BGSLP */
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_BGSLP_CFG_STS);
  sprintf(st,"\rPMC_SLAVE_BGSLP_CFG_STS value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_BGSLP_RES_ID);
  sprintf(st,"\rPMC_SLAVE_BGSLP_RES_ID value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_BGSLP_CFG_STATE);
  sprintf(st,"\rPMC_SLAVE_BGSLP_CFG_STATE value = %x \r\n",ReadData);
  SERI_Send(st);
  
  /* TSHUTDOWN */
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_TSHUTDOWN_CFG_STS);
  sprintf(st,"\rPMC_SLAVE_TSHUTDOWN_CFG_STS value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_TSHUTDOWN_RES_ID);
  sprintf(st,"\rPMC_SLAVE_TSHUTDOWN_RES_ID value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_TSHUTDOWN_CFG_STATE);
  sprintf(st,"\rPMC_SLAVE_TSHUTDOWN_CFG_STATE value = %x \r\n",ReadData);
  SERI_Send(st);
  
  /* BIAS */
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_BIAS_CFG_STS);
  sprintf(st,"\rPMC_SLAVE_BIAS_CFG_STS value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_BIAS_RES_ID);
  sprintf(st,"\rPMC_SLAVE_BIAS_RES_ID value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_BIAS_CFG_STATE);
  sprintf(st,"\rPMC_SLAVE_BIAS_CFG_STATE value = %x \r\n",ReadData);
  SERI_Send(st);
  
  /* CLKON */
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_CLKON_CFG_STS);
  sprintf(st,"\rPMC_SLAVE_CLKON_CFG_STS value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_CLKON_RES_ID);
  sprintf(st,"\rPMC_SLAVE_CLKON_RES_ID value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_CLKON_CFG_STATE);
  sprintf(st,"\rPMC_SLAVE_CLKON_CFG_STATE value = %x \r\n",ReadData);
  SERI_Send(st);
  
  /* STATE_MNGT */
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_STATE_MNGT_CFG_STS);
  sprintf(st,"\rPMC_SLAVE_STATE_MNGT_CFG_STS value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_STATE_MNGT_RES_ID);
  sprintf(st,"\rPMC_SLAVE_STATE_MNGT_RES_ID value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_STATE_MNGT_CFG_STATE);
  sprintf(st,"\rPMC_SLAVE_STATE_MNGT_CFG_STATE value = %x \r\n",ReadData);
  SERI_Send(st);
  
  /* SLEEP_MNGT */
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_SLEEP_MNGT_CFG_STS);
  sprintf(st,"\rPMC_SLAVE_SLEEP_MNGT_CFG_STS value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_SLEEP_MNGT_RES_ID);
  sprintf(st,"\rPMC_SLAVE_SLEEP_MNGT_RES_ID value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_SLEEP_MNGT_CFG_STATE);
  sprintf(st,"\rPMC_SLAVE_SLEEP_MNGT_CFG_STATE value = %x \r\n",ReadData);
  SERI_Send(st);
  
  /* P2_CLKEN */
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_P2_CLKEN_CFG_STS);
  sprintf(st,"\rPMC_SLAVE_P2_CLKEN_CFG_STS value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_P2_CLKEN_RES_ID);
  sprintf(st,"\rPMC_SLAVE_P2_CLKEN_RES_ID value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_P2_CLKEN_CFG_STATE);
  sprintf(st,"\rPMC_SLAVE_P2_CLKEN_CFG_STATE value = %x \r\n",ReadData);
  SERI_Send(st);
  
  /* BAT_PRES_CHECK */
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_BAT_PRES_CHECK_CFG_STS);
  sprintf(st,"\rPMC_SLAVE_BAT_PRES_CHECK_CFG_STS value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_BAT_PRES_CHECK_RES_ID);
  sprintf(st,"\rPMC_SLAVE_BAT_PRES_CHECK_RES_ID value = %x \r\n",ReadData);
  SERI_Send(st);
  
  ReadData = MSI2C_MasterPollingReceiveAbb(PMC_SLAVE_BAT_PRES_CHECK_CFG_STATE);
  sprintf(st,"\rPMC_SLAVE_BAT_PRES_CHECK_CFG_STATE value = %x \r\n",ReadData);
  SERI_Send(st);
  
}

/*---------------------------------------------------------------------
// NAME        : Triton_Audio_Restore_initial_Context
//
// DESCRIPTION : Set reset value to all Audio register.
//
// PARAMETERS  : No
//
// RETURN VALUE: No
//
// LIMITATIONS : None
//---------------------------------------------------------------------*/
void Triton_Audio_Restore_initial_Context(void)
{
  
  /* to access to the page of the Abb module AUDIO */
  MSI2C_AccessPage(AUDIO_page);
  
  MSI2C_MasterPollingSendAbb(AUDIO_TOGB,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_CTRL1,0x0); 
  MSI2C_MasterPollingSendAbb(AUDIO_CTRL2,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_CTRL3,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_CTRL4,0x0); 
  MSI2C_MasterPollingSendAbb(AUDIO_CTRL5,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_CTRL6,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_POPMAN,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_POPAUTO,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_SIDETONE,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_VULGAIN,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_VDLGAIN,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_OUTEN1,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_OUTEN2,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_OUTEN3,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_AUDLGAIN,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_AUDRGAIN,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_VPLLTEST,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_STPLLTEST,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_VFTEST,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_AUDFTEST1,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_AUDFTEST2,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_AUDFTEST3,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_HFTEST1,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_HFTEST2,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_POPTEST1,0x0);
  MSI2C_MasterPollingSendAbb(AUDIO_POPTEST2,0x0);
  
}

/*-------------------------------------------------------------------------------
// NAME        : precharge_off
//
// DESCRIPTION : stops the AC and USB precharge     
//
// PARAMETERS  : 
//
// RETURN VALUE: 
//
// LIMITATIONS : None
//------------------------------------------------------------------------------- */
void precharge_off(void)
{
  /* Selects the TRITON BCI register page */
  MSI2C_AccessPage(BCI_page);
  
  /* Disables both the AC precharge and the USB precharge */
  MSI2C_MasterPollingSendAbb(BCI_BCICTL3,0xC0);
  
  /* A) DONE */
  
  SERI_Send("\r\n AC Precharge and USB precharge disabled\r\n"); 
}

/*-------------------------------------------------------------------------------
// NAME        : precharge_on
//
// DESCRIPTION : start the AC and USB precharge     
//
// PARAMETERS  : 
//
// RETURN VALUE: 
//
// LIMITATIONS : None
//------------------------------------------------------------------------------- */
void precharge_on(void)
{
  /* Selects the TRITON BCI register page */
  MSI2C_AccessPage(BCI_page);
  
  /* Enables both the AC precharge and the USB precharge */
  MSI2C_MasterPollingSendAbb(BCI_BCICTL3,0x00);
  
  /* A) DONE */
  
  SERI_Send("\r\n AC Precharge and USB precharge enabled\r\n"); 
}

/*-------------------------------------------------------------------------------
// NAME        : MADC_RT_poll
//
// DESCRIPTION : Performs an MADC Real Time conversion of the selected channels     
//
// PARAMETERS  : list of selected channels to be converted (integer)
//
// RETURN VALUE: '1' is returned when the conversion is finished
//
// LIMITATIONS : None
//------------------------------------------------------------------------------- */

int MADC_RT_poll(int list)
{
  int madc_busy = 1;  /* MADC status bit randomly initialized as busy */
  int madc_eocrt = 0; /* MADC real time conversion randomly initialized as working */
  int tempo;
  int previous_content;      
  char st[80]  ;
  
  /* access to the BCI register page */
  MSI2C_AccessPage(BCI_page);
  
  /* Read previous BCICTL3 content */
  previous_content = MSI2C_MasterPollingReceiveAbb(BCI_BCICTL3) & 0xff;
  
  /* Set the resistor divider bridges for MESBAT and MESVAC */
  MSI2C_MasterPollingSendAbb(BCI_BCICTL3,(previous_content | 0x30));  
  
  /* access to the INTH module register page */
  MSI2C_AccessPage(INT2_page);
  
  /* mask the end-of-conversion INT2P1 */
  MSI2C_MasterPollingSendAbb(INT2_IT2MASKP1L,0x8); 
  
  /* access to the MADC module register page */
  MSI2C_AccessPage(MADC_page);
  
  /* MADC ON */
  MSI2C_MasterPollingSendAbb(AUX_REG_TOGGLE1,0x2);
  
  /* channel selection (LSB) */
  MSI2C_MasterPollingSendAbb(MADC_RTSELECT_LSB,(list & 0xff));
  
  /* channel selection (MSB) */
  MSI2C_MasterPollingSendAbb(MADC_RTSELECT_MSB,(list & 0x700)>>8);
  
  
  /* START Real Time conversion */
  
  /* TSP Configuration */ 
  ULPD_GsmClockEn();               // Enable GSM clock in ULPD
  TPU_ClkEnable(1);                // Enable the TPU clock
  
  /* TPU scenario launch */
  TPU_LoadScenario(startADC);	   /* load first scenario in TPU RAM */
  TPU_Reset(0);		           /* Suppress TPU reset */		
  for(tempo=0; tempo<5; tempo++);  /* Wait before next command */
  TPU_Enable(1);		   /* Enable the TPU */
  
  
  
  /* Polling on the BUSY bit */
  do
    {
      madc_busy = MSI2C_MasterPollingReceiveAbb(MADC_CTRL_P1) & 0x1;
      madc_eocrt = (MSI2C_MasterPollingReceiveAbb(MADC_CTRL_P1) & 0x4)>>2;
      sprintf(st,"\r\n BUSY bit = %d , expected '0' when conversion finished\r\n",madc_busy);
      SERI_Send(st);
      sprintf(st,"\r\n EOCRT bit = %d , expected '1' when conversion finished\r\n",madc_eocrt);
      SERI_Send(st);
      
    } while ((madc_busy)||(!madc_eocrt));
  
  /* access to the INTH module register page */
  MSI2C_AccessPage(INT2_page);
  
  /* unmask the end-of-conversion INT2P1 */
  MSI2C_MasterPollingSendAbb(INT2_IT2MASKP1L,0x0); 
  
  return (1);
}


/*---------------------------------------------------------------------------------
// NAME        : MADC_RT_INT2
//
// DESCRIPTION : Performs an MADC Real Time conversion of the selected channels     
//
// PARAMETERS  : list of selected channels to be converted (integer)
//
// RETURN VALUE: '1' is returned when the TPU scenario is launched
//
// LIMITATIONS : None
//--------------------------------------------------------------------------------- */

int MADC_RT_INT2(int list)
{
  int tempo;
  int previous_content;      
  
  /* access to the BCI register page */
  MSI2C_AccessPage(BCI_page);
  
  /* Read previous BCICTL3 content */
  previous_content = MSI2C_MasterPollingReceiveAbb(BCI_BCICTL3) & 0xff;
  
  /* Set the resistor divider bridges for MESBAT and MESVAC */
  MSI2C_MasterPollingSendAbb(BCI_BCICTL3,(previous_content | 0x30));  
  
  /* access to the INTH module register page */
  MSI2C_AccessPage(INT2_page);
  
  /* enable all INT2P1 sources */
  MSI2C_MasterPollingSendAbb(INT2_IT2MASKP1L,0x00); 
  
  /* access to the MADC module register page */
  MSI2C_AccessPage(MADC_page);
  
  /* MADC ON */