mem_copy.c

arm9_fpga2_verilog是一个可以综合的用verilog写的arm9的ip软核

/****************************************************************************
 *  File        : mem_copy.c
 *
 *  Project     : ISC - ARM
 * 
 *  Author      : Ed Kohler
 *
 *  Description : This program prompts the user for a hexadecimal memory 
 *					file.  This file should contain addresses maked by an
 *					'@' (@0000 for 0x0000) and data.  Each data word should
 *					be 32-bits long and there should be a carraige
 *					return in between words.  
 *
 ****************************************************************************/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <ws.h>


/* Base address register for PEx's memory port */
#define PEx_MEM				( 0x000 )
#define PEx_RESET_REG       ( 0x800 )
#define PEx_CONTROL_REG     ( 0x900 )
#define PEx_STATUS_REG      ( 0xA00 )

/* LAD bus offsets */
#define CTRL_1_OFFSET       ( 0x0 )
#define CTRL_2_OFFSET       ( 0x1 )
#define CTRL_3_OFFSET       ( 0x3 )
#define DPM_OFFSET          ( 0x100 )
#define STAT_OFFSET         ( 0x0 )

/* Default test settings */
#define DEFAULT_ITERATIONS  ( 1 )
#define PE_DEFAULT_MASK     ( 6 )
#if defined WIN32 || defined _ULTRA_
#define DEFAULT_SLOT       (0)
#else
#define DEFAULT_SLOT       (0xF)
#endif


/* Define offsets for block ram */
#define MAX_DWORDS_PER_TRANSFER ( 0x100 )
#define SHIFT_DPM_OFFSET        ( 20 )
#define SHIFT_WRITE_SEL         ( 20 )


/* User defined error codes */
#define ERROR_MEMORY_COMPARE_FAILED                   (WS_ERR_SECTION_USER_DEFINED_START + 0)
#define ERR_UNKNOWN_SWITCH                            (WS_ERR_SECTION_USER_DEFINED_START + 1)
#define ERR_NOT_ENOUGH_ARGS                           (WS_ERR_SECTION_USER_DEFINED_START + 2)

/* Other Misc definitions */
#define RETURN_PRINT_ERROR( rc ) \
{ printf( "ERROR %u: %s\n", rc, WS_ErrorString( rc ) ); \
  WS_Close( WS_SlotNumber );  return ( rc ); }

#define SLASH         ("/")
#define BITS_IN_DWORD (32)

#define BitTst( o,b )                       (((o) & (1 << (b))) != 0)
#if !defined(WIN32)
#define MAX_PATH (255)
#endif

/****************************************************************************
 *                              Prototypes                                  *
 ****************************************************************************/
WS_RetCode
DisplayPEConfiguration( DWORD WS_SlotNumber );

WS_RetCode
Mem_Copy_Example( float    clk_freq,
		  float    uclk_freq,
                  DWORD    WS_SlotNumber);

WS_RetCode
VerifyData(DWORD    ref[], 
           DWORD    test[],
           DWORD    size, 
           char    *errstr);

WS_RetCode
WriteData( DWORD    WS_SlotNumber, 
           DWORD    PeNum, 
           DWORD    Address, 
           DWORD    Port, 
           DWORD    DataToWrite[], 
           DWORD    NumDWORDSToWrite );


WS_RetCode 
ReadData(  DWORD    WS_SlotNumber, 
           DWORD    PeNum,
           DWORD    Address, 
           DWORD    Port,
           DWORD   *ReadBuffer,
           DWORD    NumDWORDSToRead );

WS_RetCode
ProgramPE( DWORD    WS_SlotNumber, 
           DWORD    PeNum, 
           char*    filename );


/****************************************************************************
 *                              Variables                                   *
 ****************************************************************************/
  char  *XilinxPartType[]=
  {
    "",
    "XC4013XL",
    "XC4020XL",
    "XC4028XL",
    "XC4036XL",
    "XC4044XL",
    "XC4052XL",
    "XC4062XL",
    "XC4085XL",
    "XC4013XLA",
    "XC4020XLA",
    "XC4028XLA",
    "XC4036XLA",
    "XC4044XLA",
    "XC4052XLA",
    "XC4062XLA",
    "XC4085XLA",
    "XC40110XV",
    "XC40150XV",
    "XC40200XV",
    "XC40250XV",
    "XCV50",
    "XCV100",
    "XCV150",
    "XCV200",
    "XCV300",
    "XCV400",
    "XCV600",
    "XCV800",
    "XCV1000"
  };

  char  *XilinxPackageType[]=
  {
    "",
    "HQ240",
    "HQ304",
    "BG432",
    "BG560",
    "BG352",
    "FG256"
  };

  char *DeviceID[]=
  {
      "",
      "PCI",
      "PE",
      "SRAM",
      "PLD",
      "IO FPGA",
      "CPU",
      "FLASH",
      "NONE"
  };

  char *Part_Type_PLD_Devices[]=
  {
      "",
      "XC9536",
      "XC9572XL",
      "XC95144XL",
      "XC9536XL"
  };

  char *Pkg_Type_PLD_Devices[]=
  {
      "",
      "CS48",
      "PQ100",
      "TQ100",
      "VQ64"
  };

  char *Memory_Devices[]=
  {
      "",
      "Cypress CY7C1334",
      "Cypress CY7C1350",
      "GSI GS71108",
      "Alliance AS4LC4M16",
      "Samsung KM736V849T"
  };

  char *WS_BoardType[]=
  {
      "",
      "StarFire",
      "StarFire II",
      "WildStar PCI",
      "WildStar Compact PCI",
      "WildStar VME"
  };



  WS_BASE_BOARD_TYPE
    BaseBoardType;


/****************************************************************************
 *                                   Main                                   *
 ****************************************************************************/
WS_RetCode main( int  argc, char *argv [] )
{
    WS_RetCode
      rc = WS_SUCCESS;

    int
      argi;

    float
      clk_freq = WS_MIN_MCLK_FREQ,
      uclk_freq = WS_MIN_UCLK_FREQ;

    
    DWORD
      WS_SlotNumber = DEFAULT_SLOT;      /* Default Slot number for the Wildstar WS_SlotNumber */
  
  
    const char * help_string = 
      "Usage: mem_copy <list of options>\n"
      "   Options:\n"
      "      -f <frequency>   Set the MClk Freqency ( default = 25MHz)\n"
      "      -u <frequency>   Set the UClk Frequency ( default = 320kHz)\n"
      "      -h               Show this help.\n"
      "      -s <slot ID>     Set the slot number. ( default = F )\n";

    if ( argc < 2 )
    {
      printf ( "%s\n\n", help_string );
      return(ERR_NOT_ENOUGH_ARGS);
    }
    else
    {
      for ( argi = 1; argi < argc; argi++ )
      {
        if ( argv [ argi ][ 0 ] == '-' )
        {
          switch ( toupper( argv [ argi ] [ 1 ]) )
          {
            case 'S':  /* Set the slot number */
              argi++;
              if (argi < argc)
              {  
                WS_SlotNumber = strtoul( argv [ argi ], NULL, 16 );
                printf("Setting Slot Number to %x\n", WS_SlotNumber );
              }
              else
              {
                printf( "  Warning:  Invalid Slot Number!\n");
                return(rc );
                
              }
              if ( (WS_SlotNumber < 0) || ( WS_SlotNumber > WS_MAX_BOARDS ) )
              {
                printf( "  Warning:  Invalid Slot Number!\n");
                return(rc );
              }
              break;
  
  	    case 'F': /* Set the M-clock frequency */
              argi++;
              if (argi < argc)
              {  
                 clk_freq = (float) atof ( argv [ argi ] );
                 printf( "Setting the Mclk to [%2.1f] MHz.\n", clk_freq);
              }
              else
              {
                printf( "Warning:  Invalid Clock Frequency (Max Value is [%2.1f]!\n", WS_MAX_MCLK_FREQ);
                printf( "                                   Min Value is [%2.1f]!\n", WS_MIN_MCLK_FREQ);
                return(rc);
              }
              if ( (clk_freq < WS_MIN_MCLK_FREQ ) || (clk_freq > WS_MAX_MCLK_FREQ  ) )
              {
                printf( "Warning:  Invalid Clock Frequency (Max Value is [%2.1f]!\n", WS_MAX_MCLK_FREQ);
                printf( "                                   Min Value is [%2.1f]!\n", WS_MIN_MCLK_FREQ);
                return(rc);
              }
              break;

            case 'U':  /* Set the U-clock Frequency */
              argi++;
              if (argi < argc)
              {
                 uclk_freq = (float) atof ( argv [ argi ] );
                 printf( "Setting the Uclk to [%2.1f] MHz.\n", uclk_freq);
              }
              else  
              {
                printf( "Warning:  Invalid Clock Frequency (Max Value is [%2.1f]!\n", WS_MAX_UCLK_FREQ);
                printf( "                                   Min Value is [%2.1f]!\n", WS_MIN_UCLK_FREQ);
                return(rc);   
              }
              if ( (uclk_freq < WS_MIN_UCLK_FREQ ) || (uclk_freq > WS_MAX_UCLK_FREQ  ) )
              {
                printf( "Warning:  Invalid Clock Frequency (Max Value is [%2.1f]!\n", WS_MAX_UCLK_FREQ);
                printf( "                                   Min Value is [%2.1f]!\n", WS_MIN_UCLK_FREQ);
                return(rc);
              }
              break;

            case 'H':  /* Print the help message */
              printf ( "%s\n\n", help_string );
              return(WS_SUCCESS);
              break;
  
           default:
              printf ( "  Unknown option: \"%s\"\n", argv [ argi ] );
              printf ( "%s\n\n", help_string );
              return(ERR_UNKNOWN_SWITCH);       
          }
        }  
      }
    }
    rc = Mem_Copy_Example(clk_freq, uclk_freq, WS_SlotNumber);
    return(rc);

}


/****************************************************************************
 * Function:  Mem_Copy_Example
 *
 * Description:   Test the memory functionality of a WILDStar WS_SlotNumber.
 *   
 * Arguments:
 *   clk_freq      frequency with which to program the clock
 *   uclk_freq	   frequency with which to run the ARM clock
 *
 * Returns:
 *   WS_SUCCESS  upon successful completion
 *
 *
 ****************************************************************************/
WS_RetCode
Mem_Copy_Example( float    clk_freq,
		          float	   uclk_freq,
                  DWORD    WS_SlotNumber )
{

  DWORD
	Reset,
        PENumber=1,
        StatusWord,
        *WriteBufferLocalPex,
	*ReadBufferLocalPex,
	reading,
	temp_addr,
	address,
	value,
	host_ARM;

  char
    *PartType,
    *PackageType,
    *error="Data Mismatch",
    line[9],
    FileName[MAX_PATH];

  FILE *memfile;

  int count=0,
	  i=0,
	  foundat=0,
	  total=0;

  WS_PhysicalBoardConfig
    WildstarConfiguration;

  WS_RetCode
    rc=WS_SUCCESS;

 /***************************************************************
  **                                                           **   
  **                 Open the board for testing                **
  **                                                           **
  ***************************************************************/
  rc = WS_Open( WS_SlotNumber, 0 );
  if ( rc != WS_SUCCESS )
  {
    RETURN_PRINT_ERROR(rc);
  }

  if ( rc == WS_SUCCESS )
  {
    /***************************************************************
     **                                                           **   
     **            Display configuration information              **
     **                                                           **
     ***************************************************************/
    rc = DisplayPEConfiguration( WS_SlotNumber );
    if ( rc != WS_SUCCESS )
    {
      RETURN_PRINT_ERROR(rc);
    }

    rc = WS_GetPhysicalConfig( WS_SlotNumber, &WildstarConfiguration );
    if ( rc != WS_SUCCESS )