dmatest.c

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

//---------------------------------------------------------------------
UWORD16 DMAT_ImifToImif(const DMA_ChannelId_t ChannelId,
			   						const UWORD32 src_address,
				   					const UWORD32 dst_address,
					   				const UWORD16 size_in_bytes,
						   			volatile boolean_t *const dmaendblock)
{
boolean_t ok;

  // Initialize the data to be transmitted
  DMAT_InitDataToTransfer(src_address,size_in_bytes,RHEA_BITS32_SIZE);

  // mark the latest destination address for checking overflow of dma write 
  DMAT_MarkData(dst_address,size_in_bytes, RHEA_BITS32_SIZE );
  

  *dmaendblock = False;

  // a transfert between imif to imif is equivalent to a transfert local to local
  DMA_SendLocalToLocal(ChannelId,
                      DMA_LOW_PRIORITY, /* not an emergency */
                      src_address,
                      dst_address,
                      size_in_bytes,
                      DMA_AUTOINIT_DISABLE, /* One shot only */
                      DMA_DISABLE_HALF_BLOCK_TRANSFER_IT);

 /* wait the end of Dma Transfer */
  while ( *dmaendblock == False) ;


  /* Check that data transfered are correct */
  ok = DMAT_CheckMarkData(dst_address,size_in_bytes, RHEA_BITS32_SIZE );
  ok &= DMAT_CompareDataToTransfer(src_address,dst_address,size_in_bytes,RHEA_BITS32_SIZE);
  if (ok) 
     return(RES_OK);
  else  
     return(RES_BAD);
}


//---------------------------------------------------------------------
//            DMAT_SdramToSdram
//---------------------------------------------------------------------
UWORD16 DMAT_SdramToSdram(const DMA_ChannelId_t ChannelId,
			   						 const UWORD32 src_sdram_address,
				   					 const UWORD32 dst_sdram_address,
					   				 const UWORD16 size_in_bytes,
						   			 volatile boolean_t *const dmaendblock)
{
boolean_t ok;

  // Initialize the data to be transmitted
  DMAT_InitDataToTransfer(src_sdram_address,size_in_bytes,RHEA_BITS32_SIZE);

  // mark the latest destination address for checking overflow of dma write 
  DMAT_MarkData(dst_sdram_address,size_in_bytes, RHEA_BITS32_SIZE );

  *dmaendblock = False;

  //Start transfer of several Data
  DMA_SendSdramToSdram(ChannelId,
                      DMA_LOW_PRIORITY, /* not an emergency */
                      src_sdram_address,
                      dst_sdram_address,
                      size_in_bytes,
                      DMA_AUTOINIT_DISABLE, /* One shot only */
                      DMA_DISABLE_HALF_BLOCK_TRANSFER_IT);

 /* wait the end of Dma Transfer */
  while ( *dmaendblock == False) ;


  /* Check that data transfered are correct */
  ok = DMAT_CheckMarkData(dst_sdram_address,size_in_bytes, RHEA_BITS32_SIZE );
  ok &= DMAT_CompareDataToTransfer(src_sdram_address,dst_sdram_address,size_in_bytes,RHEA_BITS32_SIZE);
  if (ok) 
     return(RES_OK);
  else  
     return(RES_BAD);

}
//--------------------------------------------------------------------
//                  DMAT_LocalBusToEmif                            
//--------------------------------------------------------------------
UWORD16 DMAT_LocalBusToEmif(const DMA_ChannelId_t ChannelId,
			   				      const UWORD32 src_lb_address,
				   			      const UWORD32 dst_emif_address,
					   		      const UWORD16 size_in_bytes,
						   	      volatile boolean_t *const dmaendblock)
{
boolean_t ok;
	*dmaendblock = False;
  // Initialize the data to be transmitted
  DMAT_InitDataToTransfer(src_lb_address,size_in_bytes,RHEA_BITS32_SIZE);
  // mark the latest destination address for checking overflow of dma write 
  DMAT_MarkData(dst_emif_address,size_in_bytes, RHEA_BITS32_SIZE );
  // Thanks to ARM DMA Controller transfer data from EMIF to Local Bus 
  DMA_SendLocalToEmif( ChannelId,
                       DMA_LOW_PRIORITY,
                       src_lb_address,
                       dst_emif_address,
                       size_in_bytes,
                       DMA_AUTOINIT_DISABLE,
		       			  DMA_DISABLE_HALF_BLOCK_TRANSFER_IT );


 /* wait the end of Dma Transfer */
  while ( *dmaendblock == False) ;

  /* Check that data transfered are correct */
  ok = DMAT_CheckMarkData(dst_emif_address,size_in_bytes, RHEA_BITS32_SIZE );
  ok &= DMAT_CompareDataToTransfer(src_lb_address,dst_emif_address,size_in_bytes,RHEA_BITS32_SIZE);
  if (ok) 
     return(RES_OK);
  else  
     return(RES_BAD);
}  


//--------------------------------------------------------------------
//                  DMAT_EmifToLocalBus                            
//--------------------------------------------------------------------
UWORD16 DMAT_EmifToLocalBus(const DMA_ChannelId_t ChannelId,
			   				      const UWORD32 src_emif_address,
				   			      const UWORD32 dst_lb_address,
					   		      const UWORD16 size_in_bytes,
						   	      volatile boolean_t *const dmaendblock)
{
boolean_t ok;
	*dmaendblock = False;

  // Initialize the data to be transmitted
  DMAT_InitDataToTransfer(src_emif_address,size_in_bytes,RHEA_BITS32_SIZE);
  // mark the latest destination address for checking overflow of dma write 
  DMAT_MarkData(dst_lb_address,size_in_bytes, RHEA_BITS32_SIZE );
  DMA_SendEmifToLocal( ChannelId,
                       DMA_LOW_PRIORITY,
                       src_emif_address,
                       dst_lb_address,
                       size_in_bytes,
                       DMA_AUTOINIT_DISABLE,
		       			  DMA_DISABLE_HALF_BLOCK_TRANSFER_IT );

 /* wait the end of Dma Transfer */
  while ( *dmaendblock == False) ;

  /* Check that data transfered are correct */
  ok = DMAT_CheckMarkData(dst_lb_address,size_in_bytes, RHEA_BITS32_SIZE );
  ok &= DMAT_CompareDataToTransfer(src_emif_address,dst_lb_address,size_in_bytes,RHEA_BITS32_SIZE);
  if (ok) 
     return(RES_OK);
  else  
     return(RES_BAD);
}  



//--------------------------------------------------------------------
//                  DMAT_SdramToLocalBus                            
//--------------------------------------------------------------------
UWORD16 DMAT_SdramToLocalBus(const DMA_ChannelId_t ChannelId,
			   				      const UWORD32 src_sdram_address,
				   			      const UWORD32 dst_lb_address,
					   		      const UWORD16 size_in_bytes,
						   	      volatile boolean_t *const dmaendblock)
{
boolean_t ok;

	*dmaendblock = False;
  // Initialize the data to be transmitted
  DMAT_InitDataToTransfer(src_sdram_address,size_in_bytes,RHEA_BITS32_SIZE);
  // mark the latest destination address for checking overflow of dma write 
  DMAT_MarkData(dst_lb_address,size_in_bytes, RHEA_BITS32_SIZE );
  DMA_SendSdramToLocal( ChannelId,
                        DMA_LOW_PRIORITY,
                        src_sdram_address,
                        dst_lb_address,
                        size_in_bytes,
                        DMA_AUTOINIT_DISABLE,
		       			   DMA_DISABLE_HALF_BLOCK_TRANSFER_IT );
 /* wait the end of Dma Transfer */
  while ( *dmaendblock == False) ;

  /* Check that data transfered are correct */
  ok = DMAT_CheckMarkData(dst_lb_address,size_in_bytes, RHEA_BITS32_SIZE );
  ok &= DMAT_CompareDataToTransfer(src_sdram_address,dst_lb_address,size_in_bytes,RHEA_BITS32_SIZE);
  if (ok) 
     return(RES_OK);
  else  
     return(RES_BAD);
  
}

//--------------------------------------------------------------------
//                  DMAT_LocalBusToSdram                            
//--------------------------------------------------------------------
UWORD16  DMAT_LocalBusToSdram(const DMA_ChannelId_t ChannelId,
			   				      const UWORD32 src_lb_address,
				   			      const UWORD32 dst_sdram_address,
					   		      const UWORD16 size_in_bytes,
						   	      volatile boolean_t *const dmaendblock)
{
boolean_t ok;

	*dmaendblock = False;
  // Initialize the data to be transmitted
  DMAT_InitDataToTransfer(src_lb_address,size_in_bytes,RHEA_BITS32_SIZE);
  // mark the latest destination address for checking overflow of dma write 
  DMAT_MarkData(dst_sdram_address,size_in_bytes, RHEA_BITS32_SIZE );
  DMA_SendLocalToSdram( ChannelId,
                        DMA_LOW_PRIORITY,
                        src_lb_address,
                        dst_sdram_address,
                        size_in_bytes,
                        DMA_AUTOINIT_DISABLE,
                        DMA_DISABLE_HALF_BLOCK_TRANSFER_IT );

 /* wait the end of Dma Transfer */
  while ( *dmaendblock == False) ;

  /* Check that data transfered are correct */
  ok = DMAT_CheckMarkData(dst_sdram_address,size_in_bytes, RHEA_BITS32_SIZE );
  ok &= DMAT_CompareDataToTransfer(src_lb_address,dst_sdram_address,size_in_bytes,RHEA_BITS32_SIZE);
  if (ok) 
     return(RES_OK);
  else  
     return(RES_BAD);
  
}


//--------------------------------------------------------------------
//                  DMAT_ImifToLocalBus                            
//--------------------------------------------------------------------
UWORD16  DMAT_ImifToLocalBus(const DMA_ChannelId_t ChannelId,
			   				      const UWORD32 src_imif_address,
				   			      const UWORD32 dst_lb_address,
					   		      const UWORD16 size_in_bytes,
						   	      volatile boolean_t *const dmaendblock)
{
boolean_t ok;

	*dmaendblock = False;
  // Initialize the data to be transmitted
  DMAT_InitDataToTransfer(src_imif_address,size_in_bytes,RHEA_BITS32_SIZE);
  // mark the latest destination address for checking overflow of dma write 
  DMAT_MarkData(dst_lb_address,size_in_bytes, RHEA_BITS32_SIZE );
  DMA_SendLocalToLocal( ChannelId,
                        DMA_LOW_PRIORITY,
                        src_imif_address,
                        dst_lb_address,
                        size_in_bytes,
								DMA_AUTOINIT_DISABLE ,
								DMA_DISABLE_HALF_BLOCK_TRANSFER_IT );

 /* wait the end of Dma Transfer */
  while ( *dmaendblock == False) ;

  /* Check that data transfered are correct */
  ok = DMAT_CheckMarkData(dst_lb_address,size_in_bytes, RHEA_BITS32_SIZE );
  ok &= DMAT_CompareDataToTransfer(src_imif_address,dst_lb_address,size_in_bytes,RHEA_BITS32_SIZE);
  if (ok) 
     return(RES_OK);
  else  
     return(RES_BAD);
  
}

//--------------------------------------------------------------------
//                  DMAT_LocalBusToImif                            
//--------------------------------------------------------------------
UWORD16 DMAT_LocalBusToImif(const DMA_ChannelId_t ChannelId,
			   				      const UWORD32 src_lb_address,
				   			      const UWORD32 dst_imif_address,
					   		      const UWORD16 size_in_bytes,
						   	      volatile boolean_t *const dmaendblock)
{
boolean_t ok;

	*dmaendblock = False;
  // Initialize the data to be transmitted
  DMAT_InitDataToTransfer(src_lb_address,size_in_bytes,RHEA_BITS32_SIZE);
  // mark the latest destination address for checking overflow of dma write 
  DMAT_MarkData(dst_imif_address,size_in_bytes, RHEA_BITS32_SIZE );
  DMA_SendLocalToLocal( ChannelId,
                        DMA_LOW_PRIORITY,
                        src_lb_address,
                        dst_imif_address,
                        size_in_bytes,
								DMA_AUTOINIT_DISABLE ,
								DMA_DISABLE_HALF_BLOCK_TRANSFER_IT );

 /* wait the end of Dma Transfer */
  while ( *dmaendblock == False) ;

  /* Check that data transfered are correct */
  ok = DMAT_CheckMarkData(dst_imif_address,size_in_bytes, RHEA_BITS32_SIZE );
  ok &= DMAT_CompareDataToTransfer(src_lb_address,dst_imif_address,size_in_bytes,RHEA_BITS32_SIZE);
  if (ok) 
     return(RES_OK);
  else  
     return(RES_BAD);
  
}

//--------------------------------------------------------------------
//                  DMAT_LocalBusToLocalBus                            
//--------------------------------------------------------------------
UWORD16 DMAT_LocalBusToLocalBus(const DMA_ChannelId_t ChannelId,
			   				      const UWORD32 src_lb_address,
				   			      const UWORD32 dst_lb_address,
					   		      const UWORD16 size_in_bytes,
						   	      volatile boolean_t *const dmaendblock)
{
boolean_t ok;

	*dmaendblock = False;
  // Initialize the data to be transmitted
  DMAT_InitDataToTransfer(src_lb_address,size_in_bytes,RHEA_BITS32_SIZE);
  // mark the latest destination address for checking overflow of dma write 
  DMAT_MarkData(dst_lb_address,size_in_bytes, RHEA_BITS32_SIZE );
  DMA_SendLocalToLocal( ChannelId,
                        DMA_LOW_PRIORITY,
                        src_lb_address,
                        dst_lb_address,
                        size_in_bytes,
								DMA_AUTOINIT_DISABLE ,
								DMA_DISABLE_HALF_BLOCK_TRANSFER_IT );

 /* wait the end of Dma Transfer */
  while ( *dmaendblock == False) ;

  /* Check that data transfered are correct */
  ok = DMAT_CheckMarkData(dst_lb_address,size_in_bytes, RHEA_BITS32_SIZE );
  ok &= DMAT_CompareDataToTransfer(src_lb_address,dst_lb_address,size_in_bytes,RHEA_BITS32_SIZE);
  if (ok) 
     return(RES_OK);
  else  
     return(RES_BAD);
  
}



//--------------------------------------------------------------------
//                  DMAT_LocalBusTimeout                            
//--------------------------------------------------------------------
//   Following accesses should be aborted because                 
//   testbench uses only one external local bus interface         
//   => debug registers should be updated                         
//--------------------------------------------------------------------
UWORD16 DMAT_LocalBusTimeout(const UWORD32 dst_lb_address,
 											volatile boolean_t *const localbus_irq_flag)
 
{
#define ABORT_DATA_TEST 0x12345678

UWORD32 data;

  // Initialize the data to be transmitted
  data = ABORT_DATA_TEST;
  *localbus_irq_flag = False;
	
  DMA_SendLocalToLocal(DMA_CHANNEL_0,
                      DMA_LOW_PRIORITY,
                      (UWORD32) &data,
                      dst_lb_address,
                      4,
                      DMA_AUTOINIT_DISABLE,
                      DMA_DISABLE_HALF_BLOCK_TRANSFER_IT);
  // wait for interrupt of localbus
  while (*localbus_irq_flag == False) ;

if (LBUSTST_CheckDebugRegisters(dst_lb_address, ABORT_DATA_TEST, DMA,
				   							 LOCALBUS_WRITE, LOCALBUS_32BITS, LOCALBUS_BURST_SIZE_1))
    return(RES_OK);
else  
    return(RES_BAD);


}