mem_copy.c

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

    /* Write to DPM */
    rc = WS_WritePeReg( WS_SlotNumber, PeNum, Port + DPM_OFFSET, ( NumDWORDSToWrite - memCntr ), &DataToWrite[memCntr] );
    
    /* Update up control register 1 */
    dMemAddress = Address + memCntr;
    dDpmOffset = 0;
    dControlReg1 = (dDpmOffset << SHIFT_DPM_OFFSET) | dMemAddress;
    
    /* Update up control register 2 */
    dNumDwords = NumDWORDSToWrite - memCntr;
    dControlReg2 = (dWriteSel << SHIFT_WRITE_SEL) | dNumDwords;

    
    /* Write to the Control Registers */
    rc = WS_WritePeReg( WS_SlotNumber, PeNum, Port + CTRL_1_OFFSET, 1, &dControlReg1 );
    rc = WS_WritePeReg( WS_SlotNumber, PeNum, Port + CTRL_2_OFFSET, 1, &dControlReg2 );
    rc = WS_WritePeReg( WS_SlotNumber, PeNum, Port + CTRL_3_OFFSET, 1, &dControlReg3 );

    /* Check to see all data was transferred */
    do
    {
        rc = WS_ReadPeReg ( WS_SlotNumber, PeNum, Port + STAT_OFFSET, 1, &StatusWord );
    } while ( (StatusWord & 0x1) != 1 );
  }

  return ( rc );

}


/******************************* Function ************************************
 * Function:	  ReadData
 * 	
 * Returns:		  DWORD -  return code
 * Description:   Read data from memory
 *****************************************************************************/

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

  DWORD
    StatusWord,
    memCntr = 0,
    dDpmOffset,
    dMemAddress,
    dNumDwords,
    dWriteSel,
    dControlReg1,
    dControlReg2,
    dControlReg3;

  WS_RetCode
    rc = WS_SUCCESS;

  /* Set initial values of the control register D */
  dNumDwords = MAX_DWORDS_PER_TRANSFER;
  dWriteSel = 1;
  dControlReg2 = (dWriteSel << SHIFT_WRITE_SEL) | dNumDwords;



  /* if the number of dwords to read is greater than MAX_DWORDS_PER_TRANSFER */
  if ( NumDWORDSToRead > MAX_DWORDS_PER_TRANSFER )
  {
    do
    {

      /* Set up control register */
      dMemAddress = Address + memCntr;
      dDpmOffset = 0;
      dControlReg1 = (dDpmOffset << SHIFT_DPM_OFFSET) | dMemAddress;

      /* Write to the Control Registers */
      rc = WS_WritePeReg( WS_SlotNumber, PeNum, Port + CTRL_1_OFFSET, 1, &dControlReg1 );
      rc = WS_WritePeReg( WS_SlotNumber, PeNum, Port + CTRL_2_OFFSET, 1, &dControlReg2 );
	  rc = WS_WritePeReg( WS_SlotNumber, PeNum, Port + CTRL_3_OFFSET, 1, &dControlReg3 );

      /* Check to see all data was transferred */
      do
      {
        rc = WS_ReadPeReg ( WS_SlotNumber, PeNum, Port + STAT_OFFSET, 1, &StatusWord );
      }while ( (StatusWord & 0x1) != 1 );


      /* Read data from memory */
      rc = WS_ReadPeReg( WS_SlotNumber, PeNum, Port + DPM_OFFSET, MAX_DWORDS_PER_TRANSFER, &ReadBuffer[memCntr] );
      memCntr = memCntr + MAX_DWORDS_PER_TRANSFER;

		}while (( ( NumDWORDSToRead - memCntr ) >= MAX_DWORDS_PER_TRANSFER ) && ( rc == WS_SUCCESS ));

  } 
  
  /* if the number of dwords to write is less than or equal to MAX_DWORDS_PER_TRANSFER */
  if (( rc == WS_SUCCESS ) && (( NumDWORDSToRead - memCntr ) != 0 ))
  {

    /* Update up control register A */
    dMemAddress = Address + memCntr;
    dDpmOffset = 0;
    dControlReg1 = (dDpmOffset << SHIFT_DPM_OFFSET) | dMemAddress;
    
    /* Update up control register D */
    dNumDwords = NumDWORDSToRead - memCntr;
    dControlReg2 = (dWriteSel << SHIFT_WRITE_SEL) | dNumDwords;
    
    /* Write to the Control Registers */
    rc = WS_WritePeReg( WS_SlotNumber, PeNum, Port + CTRL_1_OFFSET, 1, &dControlReg1 );
    rc = WS_WritePeReg( WS_SlotNumber, PeNum, Port + CTRL_2_OFFSET, 1, &dControlReg2 );
		rc = WS_WritePeReg( WS_SlotNumber, PeNum, Port + CTRL_3_OFFSET, 1, &dControlReg3 );

    /* Check to see all data was transferred */
    do
    {
        rc = WS_ReadPeReg ( WS_SlotNumber, PeNum, Port + STAT_OFFSET, 1, &StatusWord );
    }while ( (StatusWord & 0x1) != 1 );

    /* Read data from memory */
    rc = WS_ReadPeReg( WS_SlotNumber, PeNum, Port + DPM_OFFSET, ( NumDWORDSToRead - memCntr ), &ReadBuffer[memCntr] );

  }

  return ( rc );

}


/********************** Exported Function ************************************
 * Function:	  ProgramPE
 * 	
 * Returns:		  DWORD -  return code
 * Description:   programs PE from given filename
 *****************************************************************************/

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

#define WS_MAX_PGM_DWORDS  ( 400000 )

  FILE* 
    pInFile;

  DWORD
   *progBuffer,
    numDwordsRead;

  WS_RetCode
    rc = WS_SUCCESS;



  if ( (pInFile = fopen(filename,"rb")) != NULL )
  {
    progBuffer = (DWORD *)malloc( WS_MAX_PGM_DWORDS * sizeof(DWORD) );
    if( progBuffer != NULL )
    {
      numDwordsRead = fread( progBuffer,
                             sizeof(DWORD),
                             WS_MAX_PGM_DWORDS,
                             pInFile );

      rc = WS_ProgramPe( WS_SlotNumber,
                         PeNum,
                         progBuffer,
                         numDwordsRead,
                         NULL );
      free(progBuffer);
    }
    else
    {
      printf("Memory allocation error\n");
      rc = -1;
    }
    fclose( pInFile );
  }
  else
  {
    printf ( "Unable to open file '%s'\n", filename );
    rc = -1;
  }

  return(rc);
}



/******************************* Function ************************************
 * Function:	  DisplayPEConfiguration
 * Parameters:	
 * Returns:		  DWORD -  return code 
 * Description:   Displays configurations information about the WildStar Board
 *****************************************************************************/

WS_RetCode
DisplayPEConfiguration( DWORD WS_SlotNumber)
{

  WS_RetCode
    rc =  WS_SUCCESS;

  static WS_PhysicalBoardConfig
    WildstarConfiguration;

  static WS_Version
    WildstarVersion;

 /***************************************************************
  **                                                           **   
  **  Get and Display version information about the            **
  **                   Wildstar board                          **
  **                                                           **
  ***************************************************************/
  rc = WS_GetVersions( WS_SlotNumber, &WildstarVersion );

  printf ("\n\n******** Wildstar Version Information ********\n\n");


  printf ( "API Version:            %01x.%02x.%02x\n", ((WildstarVersion.dAPI >> 16 ) & 0xFF),
           ((WildstarVersion.dAPI >> 8 ) & 0xFF), WildstarVersion.dAPI & 0xFF);

  printf ( "PCI Version:            %01x.%02x.%02x\n", ((WildstarVersion.dPCI >> 16 ) & 0xFF),
           ((WildstarVersion.dPCI >> 8 ) & 0xFF), WildstarVersion.dPCI & 0xFF);

  printf ( "Flash PLD Version:      %01x.%02x.%02x\n", ((WildstarVersion.dFlash_PLD >> 16 ) & 0xFF),
           ((WildstarVersion.dFlash_PLD >> 8 ) & 0xFF), WildstarVersion.dFlash_PLD & 0xFF);

  printf ( "CrossBar0 PLD Version:  %01x.%02x.%02x\n", ((WildstarVersion.dCrossBar0_PLD >> 16 ) & 0xFF),
           ((WildstarVersion.dCrossBar0_PLD >> 8 ) & 0xFF), WildstarVersion.dCrossBar0_PLD & 0xFF);

  printf ( "CrossBar1 PLD Version:  %01x.%02x.%02x\n\n", ((WildstarVersion.dCrossBar1_PLD >> 16 ) & 0xFF),
           ((WildstarVersion.dCrossBar1_PLD >> 8 ) & 0xFF), WildstarVersion.dCrossBar1_PLD & 0xFF);



 /***************************************************************
  **                                                           **   
  **    Get and Display Configuration information about the    **
  **                   Wildstar board                          **
  **                                                           **
  ***************************************************************/
  rc = WS_GetPhysicalConfig( WS_SlotNumber, &WildstarConfiguration );


  /* If there is configuration information display it otherwise don't */
  if ( rc == WS_SUCCESS )
  {
    printf ( "******** BaseBoard Information ********\n\n");

    /* BaseBoard information */
    printf ( "%s\n", WildstarConfiguration.BaseInfo.cDescription );
    if ( WildstarConfiguration.BaseInfo.BaseBoardType <= sizeof(WS_BoardType)/sizeof(char *) )
    {
      printf ( "\tBaseBoard Type:    %s\n", WS_BoardType[WildstarConfiguration.BaseInfo.BaseBoardType] );
    }
    printf ( "\tSerial Number      1000%u\n\n", WildstarConfiguration.BaseInfo.dSerialNumber );

    /* PCI Information */
    if ( WildstarConfiguration.BaseInfo.PCI_Device.dDeviceId == WS_PCI_DEVICE_ID )
    {
      printf ( "%s\n",  WildstarConfiguration.BaseInfo.PCI_Device.cDescription );
      if ( WildstarConfiguration.BaseInfo.PCI_Device.dPartType <= sizeof(XilinxPartType)/sizeof(char *) )
      {
        printf ( "\tPart Type:     %s\n", XilinxPartType[WildstarConfiguration.BaseInfo.PCI_Device.dPartType] );
      }
      if ( WildstarConfiguration.BaseInfo.PCI_Device.dPackageType <= sizeof(XilinxPackageType)/sizeof(char *) )
      {
        printf ( "\tPackage Type:  %s\n", XilinxPackageType[WildstarConfiguration.BaseInfo.PCI_Device.dPackageType] );
      }
      printf ( "\tSpeed Grade:   -%u\n\n", WildstarConfiguration.BaseInfo.PCI_Device.dSpeedGrade );
    }

    /* PE0 Information */
    if ( WildstarConfiguration.BaseInfo.PE_Device[0].dDeviceId == WS_PE_DEVICE_ID )
    {
      printf ( "%s\n", WildstarConfiguration.BaseInfo.PE_Device[0].cDescription );
      if ( WildstarConfiguration.BaseInfo.PE_Device[0].dPartType <= sizeof(XilinxPartType)/sizeof(char *) )
      {
        printf ( "\tPart Type:     %s\n", XilinxPartType[WildstarConfiguration.BaseInfo.PE_Device[0].dPartType] );
      }
      if ( WildstarConfiguration.BaseInfo.PE_Device[0].dPackageType <= sizeof(XilinxPackageType)/sizeof(char *) )
      {
        printf ( "\tPackage Type:  %s\n", XilinxPackageType[WildstarConfiguration.BaseInfo.PE_Device[0].dPackageType] );
      }
      printf ( "\tSpeed Grade:   -%u\n\n", WildstarConfiguration.BaseInfo.PE_Device[0].dSpeedGrade );
    }

    /* PE1 Information */
    if ( WildstarConfiguration.BaseInfo.PE_Device[1].dDeviceId == WS_PE_DEVICE_ID )
    {
      printf ( "%s\n", WildstarConfiguration.BaseInfo.PE_Device[1].cDescription );
      if ( WildstarConfiguration.BaseInfo.PE_Device[1].dPartType <= sizeof(XilinxPartType)/sizeof(char *) )
      {
        printf ( "\tPart Type:     %s\n", XilinxPartType[WildstarConfiguration.BaseInfo.PE_Device[1].dPartType] );
      }
      if ( WildstarConfiguration.BaseInfo.PE_Device[1].dPackageType <= sizeof(XilinxPackageType)/sizeof(char *) )
      {
        printf ( "\tPackage Type:  %s\n", XilinxPackageType[WildstarConfiguration.BaseInfo.PE_Device[1].dPackageType] );
      }
      printf ( "\tSpeed Grade:   -%u\n\n", WildstarConfiguration.BaseInfo.PE_Device[1].dSpeedGrade );
    }

    /* PE2 Information */
    if ( WildstarConfiguration.BaseInfo.PE_Device[2].dDeviceId == WS_PE_DEVICE_ID )
    {
      printf ( "%s\n", WildstarConfiguration.BaseInfo.PE_Device[2].cDescription );
      if ( WildstarConfiguration.BaseInfo.PE_Device[2].dPartType <= sizeof(XilinxPartType)/sizeof(char *) )
      {
        printf ( "\tPart Type:     %s\n", XilinxPartType[WildstarConfiguration.BaseInfo.PE_Device[2].dPartType] );
      }
      if ( WildstarConfiguration.BaseInfo.PE_Device[2].dPackageType <= sizeof(XilinxPackageType)/sizeof(char *) )
      {
        printf ( "\tPackage Type:  %s\n", XilinxPackageType[WildstarConfiguration.BaseInfo.PE_Device[2].dPackageType] );
      }
      printf ( "\tSpeed Grade:   -%u\n\n", WildstarConfiguration.BaseInfo.PE_Device[2].dSpeedGrade );
    }
  }
  else
  {
    printf ("    ** BaseBoard Configuration Information Not Available **\n\n");
    exit(1);
  }

  /* Mezzanine Information */
  if ( WildstarConfiguration.MezzInfo[0].dMezzCardType == WS_MEZZ_CARD_TYPE_MEM )
  {
    printf ( "******** Mezzanine Card[0] Information ********\n\n");
    printf ( "%s\n", WildstarConfiguration.MezzInfo[0].cDescription );
    printf ( "\tMezz. Card Serial Number: [%u]\n\n", WildstarConfiguration.MezzInfo[0].dSerialNumber );

    /* Memory Devices */
    if ( WildstarConfiguration.MezzInfo[0].Mezz_Device[0].dDeviceId == WS_MEMORY_DEVICE_ID )
    {
      printf ("\tMezz Device[0]:  %s\n", WildstarConfiguration.MezzInfo[0].Mezz_Device[0].cDescription );
      if ( WildstarConfiguration.MezzInfo[0].Mezz_Device[0].dDeviceId <= sizeof(DeviceID)/sizeof(char *) )
      {
        printf ("\t\tDescription:   %s\n", DeviceID[WildstarConfiguration.MezzInfo[0].Mezz_Device[0].dDeviceId] );  
      }
      if ( WildstarConfiguration.MezzInfo[0].Mezz_Device[0].dPartType <= sizeof(Memory_Devices)/sizeof(char *) )
      {
        printf ("\t\tPart Type:     %s\n", Memory_Devices[WildstarConfiguration.MezzInfo[0].Mezz_Device[0].dPartType] );
      }
      printf ("\t\tSpeed Grade:   -%u\n", WildstarConfiguration.MezzInfo[0].Mezz_Device[0].dSpeedGrade );
      printf ("\t\tPort Size:     %u DWORDS\n\n", WildstarConfiguration.MezzInfo[0].Mezz_Device[0].dMemorySize );
    }

    /* Crossbar Devices */
    if ( WildstarConfiguration.MezzInfo[0].Mezz_Device[1].dDeviceId == WS_PLD_DEVICE_ID )
    {
      printf ("\tMezz Device[1]: %s\n", WildstarConfiguration.MezzInfo[0].Mezz_Device[1].cDescription );
      if ( WildstarConfiguration.MezzInfo[0].Mezz_Device[1].dDeviceId <= sizeof(DeviceID)/sizeof(char *) )
      {
        printf ("\t\tDescription:  %s\n", DeviceID[WildstarConfiguration.MezzInfo[0].Mezz_Device[1].dDeviceId] );
      }
      if ( WildstarConfiguration.MezzInfo[0].Mezz_Device[1].dPartType <= sizeof(Part_Type_PLD_Devices)/sizeof(char *) )
      {
        printf ("\t\tPart Type:    %s\n", Part_Type_PLD_Devices[WildstarConfiguration.MezzInfo[0].Mezz_Device[1].dPartType] );
      }
      if ( WildstarConfiguration.MezzInfo[0].Mezz_Device[1].dPackageType <= sizeof(Pkg_Type_PLD_Devices)/sizeof(char *) )
      {
        printf ("\t\tPackage Type: %s\n", Pkg_Type_PLD_Devices[WildstarConfiguration.MezzInfo[0].Mezz_Device[1].dPackageType] );
      }
      printf ("\t\tSpeed Grade:  -%u\n\n", WildstarConfiguration.MezzInfo[0].Mezz_Device[1].dSpeedGrade );
    }
  }



  if ( WildstarConfiguration.MezzInfo[1].dMezzCardType == WS_MEZZ_CARD_TYPE_MEM )
  {
    printf ( "******** Mezzanine Card[1] Information ********\n\n");
    printf ( "%s\n", WildstarConfiguration.MezzInfo[1].cDescription );
    printf ( "\tMezz. Card Serial Number: [%u]\n\n", WildstarConfiguration.MezzInfo[1].dSerialNumber );

    /* Memory Devices */
    if ( WildstarConfiguration.MezzInfo[1].Mezz_Device[0].dDeviceId == WS_MEMORY_DEVICE_ID )
    {
      printf ("\tMezz Device[0]:  %s\n", WildstarConfiguration.MezzInfo[1].Mezz_Device[0].cDescription );
      if ( WildstarConfiguration.MezzInfo[1].Mezz_Device[0].dDeviceId <= sizeof(DeviceID)/sizeof(char *) )
      {
        printf ("\t\tDescription:   %s\n", DeviceID[WildstarConfiguration.MezzInfo[1].Mezz_Device[0].dDeviceId] );  
      }
      if ( WildstarConfiguration.MezzInfo[1].Mezz_Device[0].dPartType <= sizeof(Memory_Devices)/sizeof(char *) )
      {
        printf ("\t\tPart Type:     %s\n", Memory_Devices[WildstarConfiguration.MezzInfo[1].Mezz_Device[0].dPartType] );
      }
      printf ("\t\tSpeed Grade:   -%u\n", WildstarConfiguration.MezzInfo[1].Mezz_Device[0].dSpeedGrade );
      printf ("\t\tPort Size:     %u DWORDS\n\n", WildstarConfiguration.MezzInfo[1].Mezz_Device[0].dMemorySize );
    }

    /* Crossbar Devices */
    if ( WildstarConfiguration.MezzInfo[1].Mezz_Device[1].dDeviceId == WS_PLD_DEVICE_ID )
    {
      printf ("\tMezz Device[1]: %s\n", WildstarConfiguration.MezzInfo[1].Mezz_Device[1].cDescription );
      if ( WildstarConfiguration.MezzInfo[1].Mezz_Device[1].dDeviceId <= sizeof(DeviceID)/sizeof(char *) )
      {
        printf ("\t\tDescription:  %s\n", DeviceID[WildstarConfiguration.MezzInfo[1].Mezz_Device[1].dDeviceId] );
      }
      if ( WildstarConfiguration.MezzInfo[1].Mezz_Device[1].dPartType <= sizeof(Part_Type_PLD_Devices)/sizeof(char *) )
      {
        printf ("\t\tPart Type:    %s\n", Part_Type_PLD_Devices[WildstarConfiguration.MezzInfo[1].Mezz_Device[1].dPartType] );
      }
      if ( WildstarConfiguration.MezzInfo[1].Mezz_Device[1].dPackageType <= sizeof(Pkg_Type_PLD_Devices)/sizeof(char *) )
      {
        printf ("\t\tPackage Type: %s\n", Pkg_Type_PLD_Devices[WildstarConfiguration.MezzInfo[1].Mezz_Device[1].dPackageType] );
      }
      printf ("\t\tSpeed Grade:  -%u\n\n", WildstarConfiguration.MezzInfo[1].Mezz_Device[1].dSpeedGrade );
    }
  }

  return(rc);
}