dmatest.c

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

                     	DMA_AUTOINIT_DISABLE,
                     	DMA_DISABLE_HALF_BLOCK_TRANSFER_IT);

  //INT_SetUser();

  /* wait until the transfer is completed */
  while ( *dmaendblock != True ) ;


  /* Check that data transfered into emif is correct */
  ok = DMAT_CheckMarkData(emif_dst_address,size_in_bytes, memory_rhea_width );
  ok &= DMAT_CompareDataToTransfer(rhea_src_address,emif_dst_address,size_in_bytes,memory_rhea_width);

if (ok)
	return(RES_OK);
else
   return(RES_BAD);

}



//-------------------------------------------------------------------------
//               DMAT_RheaToImifOrLocalBus
//-------------------------------------------------------------------------
UWORD16 DMAT_RheaToImifOrLocalBus ( const DMA_ChannelId_t    		  channel_id,
                            	 const RHEA_Strobe0ChipSelect_t rhea_src_chipselect,
									 	 const UWORD32 			     	  rhea_src_address,
										 const UWORD32 				     dst_address,
									 	 const UWORD16 					  size_in_bytes,
		  							    const RHEA_Access_Size_t		  memory_rhea_width,
										 volatile boolean_t *const  dmaendblock)
										 
{
//UWORD16 i;
BOOL ok;

*dmaendblock = False;

/* Init data to be transfered */
DMAT_InitDataToTransfer(rhea_src_address,size_in_bytes,memory_rhea_width);

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

/* Thanks to ARM DMA Controller transfer data from RHEA to EMIF */
//INT_SetSupervisor();
                     

DMA_SendRheaToImifLb(channel_id,
                     	DMA_LOW_PRIORITY,
                     	rhea_src_address,    // Source Rhea offset into the Chip Select 
                     	rhea_src_chipselect, // Source Rhea Chip Select 
		     					dst_address,
                     	size_in_bytes,
								memory_rhea_width,
                     	DMA_AUTOINIT_DISABLE,
                     	DMA_DISABLE_HALF_BLOCK_TRANSFER_IT);

  //INT_SetUser();

  /* wait until the transfer is completed */
  while ( *dmaendblock != True ) ;


  /* Check that data transfered into emif is correct */
  ok = DMAT_CheckMarkData(dst_address,size_in_bytes, memory_rhea_width );
  ok &= DMAT_CompareDataToTransfer(rhea_src_address,dst_address,size_in_bytes,memory_rhea_width);

if (ok)
	return(RES_OK);
else
   return(RES_BAD);

}

/*
-------------------------------------------------------------------------
--               DMAT_ImifOrLocalbusToRhea               
-------------------------------------------------------------------------
*/
UWORD16 DMAT_ImifOrLocalbusToRhea(const DMA_ChannelId_t  channel_id,
									  const UWORD32 				      src_address,
                             const RHEA_Strobe0ChipSelect_t rhea_dst_chipselect,
									  const UWORD32 			         rhea_dst_address,
									  const UWORD16 		   			size_in_bytes,
		  							  const RHEA_Access_Size_t			memory_rhea_width,
									  volatile boolean_t *const  dmaendblock)
										 
{

//UWORD16 i;
BOOL ok;
/*
--------------------------------------------------------------------
--      1st Test :                                                --
--  accesses From EMIF to Rhea via DMA Controller                --
--------------------------------------------------------------------
*/

  /* Init data to be transfered */
  DMAT_InitDataToTransfer(src_address,size_in_bytes,memory_rhea_width);

  DMAT_MarkData(rhea_dst_address,size_in_bytes, memory_rhea_width);


	*dmaendblock = False;

  /* Thanks to ARM DMA Controller transfer data from RHEA to EMIF */
  //INT_SetSupervisor();

  DMA_SendImifLbToRhea(channel_id,
                     DMA_LOW_PRIORITY,
                     src_address,
                     rhea_dst_address,      /* Source Rhea offset into the Chip Select */
                     rhea_dst_chipselect, /* Source Rhea Chip Select */ 
                     size_in_bytes,
							memory_rhea_width,
                     DMA_AUTOINIT_DISABLE,
                     DMA_DISABLE_HALF_BLOCK_TRANSFER_IT);


  //INT_SetUser();
  // wait the end of transfert
  while (	*dmaendblock == False) ;

  /* Check that transfer is correct */
  ok = DMAT_CheckMarkData(rhea_dst_address,size_in_bytes, memory_rhea_width );
  ok &= DMAT_CompareDataToTransfer(src_address,rhea_dst_address,size_in_bytes,memory_rhea_width);

if (ok)
	return(RES_OK);
else
   return(RES_BAD);

}

/*
-------------------------------------------------------------------------
--               DMAT_SdramToRhea
-------------------------------------------------------------------------
*/
UWORD16 DMAT_SdramToRhea(const DMA_ChannelId_t    		 channel_id,
									   const UWORD32 				       sdram_src_address,
                              const RHEA_Strobe0ChipSelect_t rhea_dst_chipselect,
									   const UWORD32 			          rhea_dst_address,
									   const UWORD16 		   			 size_in_bytes,
		  							   const RHEA_Access_Size_t		 memory_rhea_width,
									   volatile boolean_t *const 		 dmaendblock)
										 
{

//UWORD16 i;
BOOL ok;
/*
--------------------------------------------------------------------
--      1st Test :                                                --
--  accesses From EMIF to Rhea via DMA Controller                --
--------------------------------------------------------------------
*/

  /* Init data to be transfered */
  DMAT_InitDataToTransfer(sdram_src_address,size_in_bytes,memory_rhea_width);

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


  /* Thanks to ARM DMA Controller transfer data from RHEA to EMIF */
//  INT_SetSupervisor();

  *dmaendblock =False;
  DMA_SendSdramToRhea(channel_id,
                     DMA_LOW_PRIORITY,
                     sdram_src_address,
                     rhea_dst_address,      /* Source Rhea offset into the Chip Select */
                     rhea_dst_chipselect, /* Source Rhea Chip Select */ 
                     size_in_bytes,
							memory_rhea_width,
                     DMA_AUTOINIT_DISABLE,
                     DMA_DISABLE_HALF_BLOCK_TRANSFER_IT);


//  INT_SetUser();
  // wait the end of transfert
  while (*dmaendblock == False) ;

  /* Check that data transfered are correct */
  ok = DMAT_CheckMarkData(rhea_dst_address,size_in_bytes, memory_rhea_width );
  ok &= DMAT_CompareDataToTransfer(sdram_src_address,rhea_dst_address,size_in_bytes,memory_rhea_width);

if (ok)
	return(RES_OK);
else
   return(RES_BAD);

}

/*
-------------------------------------------------------------------------
--               DMAT_RheaToSdram
-------------------------------------------------------------------------
*/
UWORD16 DMAT_RheaToSdram(const DMA_ChannelId_t    		 channel_id,
                              const RHEA_Strobe0ChipSelect_t rhea_src_chipselect,
									   const UWORD32 			          rhea_src_address,
									   const UWORD32 				       sdram_dst_address,
									   const UWORD16 		   			 size_in_bytes,    
		  							   const RHEA_Access_Size_t		 memory_rhea_width,
									   volatile boolean_t *const 		 dmaendblock)
										 
{

//UWORD16 i;
BOOL ok;

  DMAT_InitDataToTransfer(rhea_src_address,size_in_bytes,memory_rhea_width);
  // mark the latest destination address for checking overflow of dma write 
  DMAT_MarkData(sdram_dst_address,size_in_bytes, memory_rhea_width);
  
  /* Thanks to ARM DMA Controller transfer data from RHEA to SDRAM */
  //INT_SetSupervisor();
  *dmaendblock =False;
  DMA_SendRheaToSdram(channel_id,
                     DMA_LOW_PRIORITY,
                     rhea_src_address,     /* Source Rhea offset into the Chip Select */
                     rhea_src_chipselect, /* Source Rhea Chip Select */ 
                     sdram_dst_address,
                     size_in_bytes,
							memory_rhea_width,
                     DMA_AUTOINIT_DISABLE,
                     DMA_DISABLE_HALF_BLOCK_TRANSFER_IT);


  //INT_SetUser();
  // wait the end of transfert
  while (*dmaendblock == False) ;

  /* Check that data transfered are correct */
  ok = DMAT_CheckMarkData(sdram_dst_address,size_in_bytes, memory_rhea_width );
  ok &= DMAT_CompareDataToTransfer(rhea_src_address,sdram_dst_address,size_in_bytes,memory_rhea_width);
if (ok)
	return(RES_OK);
else
   return(RES_BAD);

}

//---------------------------------------------------------------------
//            DMAT_SdramToEmif
//---------------------------------------------------------------------
UWORD16 DMAT_SdramToEmif(const DMA_ChannelId_t ChannelId,
			   						const UWORD32 src_sdram_address,
				   					const UWORD32 dst_emif_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  destination address +1 for checking overflow of dma write 
  DMAT_MarkData(dst_emif_address,size_in_bytes, RHEA_BITS32_SIZE );

  *dmaendblock = False;

  //Start transfer of several Data
  DMA_SendSdramToEmif(ChannelId,
                      DMA_LOW_PRIORITY, /* not an emergency */
                      src_sdram_address,
                      dst_emif_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_emif_address,size_in_bytes, RHEA_BITS32_SIZE );

  ok &= DMAT_CompareDataToTransfer(src_sdram_address,dst_emif_address,size_in_bytes,RHEA_BITS32_SIZE);

  if (ok) 
     return(RES_OK);
  else  
     return(RES_BAD);


}

/*
--------------------------------------------------------------
                DMAT_EmifToSdram
--------------------------------------------------------------
*/
UWORD16 DMAT_EmifToSdram(const DMA_ChannelId_t channel_id,
									const UWORD32 src_emif_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_emif_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
  from External Slow to external SDRAM Fast
  */
  
  DMA_SendEmifToSdram(channel_id,
                      DMA_LOW_PRIORITY, /* not an emergency */
                      src_emif_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_emif_address,dst_sdram_address,size_in_bytes,RHEA_BITS32_SIZE);
  if (ok) 
     return(RES_OK);
  else  
     return(RES_BAD);

}

//---------------------------------------------------------------------
//            DMAT_EmifToEmif
//---------------------------------------------------------------------
UWORD16 DMAT_EmifToEmif(const DMA_ChannelId_t ChannelId,
			   						const UWORD32 src_emif_address,
				   					const UWORD32 dst_emif_address,
					   				const UWORD16 size_in_bytes,
						   			volatile boolean_t *const dmaendblock)
{
boolean_t ok;

  // 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_emif_address,size_in_bytes, RHEA_BITS32_SIZE );
  

  *dmaendblock = False;

  //Start transfer of several Data
  DMA_SendEmifToEmif(ChannelId,
                      DMA_LOW_PRIORITY, /* not an emergency */
                      src_emif_address,
                      dst_emif_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_emif_address,size_in_bytes, RHEA_BITS32_SIZE );
  ok &= DMAT_CompareDataToTransfer(src_emif_address,dst_emif_address,size_in_bytes,RHEA_BITS32_SIZE);
  if (ok) 
     return(RES_OK);
  else  
     return(RES_BAD);


}

//---------------------------------------------------------------------
//            DMAT_ImifToImif