dm642_test.c

dsp dm642 flash烧录入

/*
 *  Copyright 2000 by Texas Instruments Incorporated.
 *  All rights reserved. Property of Texas Instruments Incorporated.
 *  Restricted rights to use, duplicate or disclose this code are
 *  granted through contract.
 *  U.S. Patent Nos. 5,283,900  5,392,448
 */
/* "@(#) DSP/BIOS 4.00 03-27-00 (barracuda-e08)" */
/***************************************************************************/
/*                                                                         */
/*     H E L L O . C                                                       */
/*                                                                         */
/*     Basic C standard I/O from main.                                     */
/*                                                                         */
/*                                                                         */
/***************************************************************************/
// #define CHIP_DM642

//#include <stdlib.h>
#include <stdio.h>
#include <log.h>

#include "ATOMcfg.h"

#include <stdio.h>

#include <csl.h>
#include <csl_cache.h>
#include <csl_edma.h>
#include <csl_timer.h>
#include <csl_irq.h>
#include <csl_mcbsp.h>
#include <csl_pci.h>

 #include "ATOM_define.h"
 #include "ATOM_init.h"

 //#include "DM642_PCI.h"

/* 8Mbyte sdram */
#define START       0x80000000
#define END         0x88000000
#define VALUE       0xaaaaaaaa
/*
static int testValue[16]= {0x00000000, 0x11111111, 0x22222222, 0x33333333, 0x44444444, 0x55555555,
                           0x66666666, 0x77777777, 0x88888888, 0x99999999, 0xaaaaaaaa, 0xbbbbbbbb,
                           0xcccccccc, 0xdddddddd, 0xeeeeeeee, 0xffffffff                           
                          };

*/
//Function used to stop EDMA
void stopEdma(void); 
void Send_FIFOB();
void init_inRAM(void);
void test_MCBSP0(void);
void test__SDRAM();
 

void Write_PCI_EEPROM();
void Read_PCI_EEPROM();
 
void main()

{ 
   
     
     init_emifa(); 
      init_inter();
     
      CSL_init();      
   
      CONTROL =0xaaaa;     
  
    // init_inRAM();
    // test_MCBSP0();
	test__SDRAM();
     
      
    //  printf("address = 0x%x dircontrol value= 0x%x \n",j,k);
       
      //  Write_PCI_EEPROM();
       //   Read_PCI_EEPROM();
         
         
     // CONTROL =0xaa55;
     //  test__SDRAM CONTROL =0xaa55;
          
      
    
     //Send_FIFOB();
    
  
	 // for (;;);          
}


void Write_PCI_EEPROM()
{
  PCI_RSTSRC=0x00000018;
 // PCI_PCIIEN=0x00000280;
  PCI_PCIIS=0x00000280;
  

  PCI_EEADD=0x0000;
  PCI_EEDAT=0x104c;
  PCI_EECTL=0x0001;
  
  /*
   PCI_eepromWrite(0x00,0x104c);
    PCI_eepromWrite(0x02,0x0000);
     PCI_eepromWrite(0x04,0x03d3);
      PCI_eepromWrite(0x08,0x0010);
       PCI_eepromWrite(0x0a,0x0000);
        PCI_eepromWrite(0x0c,0x0000);       
         PCI_eepromWrite(0x0e,0x0000);
                
         PCI_eepromWrite(0x10,0x0008);
          PCI_eepromWrite(0x12,0x3fff);
           PCI_eepromWrite(0x14,0x0000);
            PCI_eepromWrite(0x16,0x0008);
             PCI_eepromWrite(0x18,0x0011);
              PCI_eepromWrite(0x1a,0x0000);
              
               PCI_eepromWrite(0x2c,0x0000);
                PCI_eepromWrite(0x2e,0x0000);
               //  PCI_eepromWrite(0x30,0x0000);
                //  PCI_eepromWrite(0x1a,0x0000);
*/
}

  void Read_PCI_EEPROM()
  {

  Uint16 eepromdata; 
  Uint32 eepromSZ;
  
   PCI_RSTSRC=0x00000018;
   PCI_PCIIEN=0x00000280;
   PCI_PCIIS=0x00000080;
   
      PCI_EEADD=0x0000;
      PCI_EECTL=0x0002;
     
       eepromdata=PCI_EEDAT;
    // x = PCI_eepromWrite(0x00,0x104c);
     
    eepromSZ = PCI_eepromSize();
   
 // eepromdata = PCI_eepromRead(0x00000000);
 	printf("eepromSZ= 0x%x,eepromdata= 0x%x \n",eepromSZ,eepromdata);

  }
void Read_FIFOA()
{
 // CSL_cfgInit();
  
 // DMA_Wait(hEdmaCha4);
 // DMA_Close(hEdmaCha4);
  stopEdma();

}













void Read_FIFOB()
{
 
     
  CSL_cfgInit();
 //IER =0x000000f3;
 EDMA_RSETA(0x01A0FFFC, EDMA_ESRL, 0x00000010); 
  EDMA_wait();
 stopEdma();
 printf("The interrupte of B is very good \n"); 
}
void Read_FIFOC()
{
}

void Read_FIFOD()
{

}

  EDMA_read_A(void)
{

}

void init_inRAM(void)
 
   {
	unsigned int i, j;  
	short * intp;  
    j = BufferA_ADDR;                               
	  for(i= BufferA_ADDR;i<BufferA_ADDR+BUFF_SZ;i+=4)                                              
	  {
	    	intp =(short *)j;
	    	*intp = 0xaa55;          
	       	j += 2; 
	    	intp = (short *)j;
	    	*intp = 0xffff;          
	      	j += 2; 	       	
      }   

}

void Send_FIFOB()
 
 {         
      CSL_cfgInit();
      
       EDMA_RSETA(0x01A0FFBC, EDMA_ESRH, 0x00000002); 
       EDMA_wait();
         
     stopEdma();
 // printf("start test EDMA from FIFOB\n");
 
 }


//---------main routine---------
 void test_MCBSP0(void)
{
	MCBSP_Handle hMcbsp;  
	volatile Uint32 x,y;
	int success = 1;
    
	//Initialize CSL
//	CSL_init();

	//Open up serial port 1
	hMcbsp = MCBSP_open(MCBSP_DEV0, MCBSP_OPEN_RESET);
  
	//Configure McBSP for digital loopback, 32bit mode
	//  and setup the sample rate generator to allow self clocking
	MCBSP_config(hMcbsp, &ConfigLoopback);

	//Enable McBSP in steps
	MCBSP_start(hMcbsp, MCBSP_RCV_START | 
						MCBSP_XMIT_START |
   					 	MCBSP_SRGR_START | 
   					 	MCBSP_SRGR_FRAMESYNC,
   			    MCBSP_SRGR_DEFAULT_DELAY);

	//Loop for a while writing values out to the port
	//  then reading them back in. This should take a few seconds
	for (y=0; y<0x00080000; y++)
	{  
		//Wait until the transmitter is ready for a sample, then write to it
		while (!MCBSP_xrdy(hMcbsp));                       
		MCBSP_write(hMcbsp,y);
  
		//Wait until the value is received, then read it
		while (!MCBSP_rrdy(hMcbsp));           
		x = MCBSP_read(hMcbsp);
    
		//Check transmitted and received values to make sure they match
		if (x != y)
		{
			success = 0;
			printf("\nTEST FAILED\n");
			break;
		} 
	}
  
	//Close the port
	MCBSP_close(hMcbsp);
	
	if(success)  
		printf("\nTEST PASSED\n");
}


 /*  ========test__SDRAM========
 */
 void test__SDRAM()

{             

	unsigned int i,j;  
	  
	int k,value;
	int * intp;              
#if 1  
	  printf("start test sdram from 0x80000000 to 0x81000000 used by 0x55555555 and 0xaaaaaaa\n");

	  j = START;                               
	  for(i= START;i<END;i+=8)                                              
	  {
	    	intp = (int *)j;
	    	*intp = 0x55555555;          
	       	j += 4; 
	    	intp = (int *)j;
	    	*intp = 0xaaaaaaaa;          
	       	j += 4; 
	       	
      }   

      j = START;  
	  for(i = START; i < END; i+=8)                                               
	  {
	    	intp = (int *)j;
	    	k = *intp;
	    	value=0x55555555;
            if(k!=value)
	    	{
	    		printf("address = 0x%x error value= 0x%x correct value = 0x%x \n",j,k,value);
	    		fflush(stdout);
	    	}	                    
	    	j += 4;
	    	intp = (int *)j;
	    	k = *intp;
	    	value=0xaaaaaaaa;
            if(k!=value)
	    	{
	    		printf("address = 0x%x error value= 0x%x correct value = 0x%x \n",j,k,value);
	    		fflush(stdout);
	    	}
	    	j += 4;	    	
	  }
	  
      printf("end test sdram \n");
#endif

#if 1 
      printf("I am testing adress complements\n"); 
      j= START;
	  for(i = START; i < END; i+=4)                                              
	  {
	    	intp = (int *)j;
	    	*intp = j;          
	       	j += 4;
	  }  
	     
	   j = START;  
	   for(i = START; i < END; i+=4)                                               
	   {
	    	intp = (int *)j;
	    	
	    	k = *intp;
	    	if (k != j    )
	    	{
	    		printf("address = 0x%x error value= 0x%x correct value= 0x%x\n",j,k,~j);
	    		fflush(stdout);
	    	}	                    
	    	j += 4;
	    }
	
    printf("averted address testing end!\n");
#endif 
 /*  
#if 1
printf("I am writing and reading 0,1,--,e,f at every byte from 0x80000000 to 0x81000000\n"); 
  
 for(m=0; m < 16; m++)
  {
	  value = testValue[m];
	  printf("m = %x testValue = %x\n", m, value);
	  j = START;                               
	  for(i = START; i < END; i+=4)                                              
      {
	    	intp = (int *)j;
	    	*intp = value;          
	       	j += 4;
	    	
	   }  
	     
	   j = START;  
	   for(i = START; i < END; i+=4)                                               
	    {
	    	intp = (int *)j;
	    	
	    	k = *intp;
	    	if (k  != value  )
	    	{
	    		printf("address = 0x%x error value= 0x%x correct value= 0x%x\n",j,k,value);
	    		fflush(stdout);
	    	}	                    
	    	j += 4;
	    }
	}      
#endif

#if 1
      printf("I am writing and reading data from 0 to 0xffffffff at 0x80000000 unit\n"); 

	  intp = (int *)START;
	  i=0x0; 
	  m=0x0; 	  

	  for(j=0; j < 0x10; j++)
	  {
		  m = m +0x10000000;
		  for(; i < m; i++)                                              
		    {
		    	*intp = i;              
				k = *intp;
		    	if (k != i)
		    	{
		    		printf("error value = 0x%x correct value = 0x%x \n",k,i);
		    	}	                    	    	
		    }  

		 printf("%x end\n",j);	
		 
	  }
#endif
*/
    printf("all Testing end\n");
}