flashsemihosting.c

在IAR4.3平台下

//*--------------------------------------------------------------------------------------
//*      ATMEL Microcontroller Software Support  -  ROUSSET  -
//*--------------------------------------------------------------------------------------
//* The software is delivered "AS IS" without warranty or condition of any
//* kind, either express, implied or statutory. This includes without
//* limitation any warranty or condition with respect to merchantability or
//* fitness for any particular purpose, or against the infringements of
//* intellectual property rights of others.
//*--------------------------------------------------------------------------------------
//* File Name               : FlashSemiHosting.c
//* Object                  : FLASH programmer for SAM7 product
//*
//* 1.0 01/Jul/04 JPP       : Creation
//*--------------------------------------------------------------------------------------

/* Include Standard c Libraries to allow stand alone compiling and operation */
#include <stdio.h>
#include <stdlib.h>

#include "flash.h"
#include "Board.h"

/* Target Identification */
#define TARGET_ID           "SAM7 "
//#define DEBUG 1

unsigned int numWordsRead;
unsigned int RAMSectorData[FLASH_PAGE_SIZE_LONG];

//*----------------------------------------------------------------------------
//* \fn    AT91F_Flash_Init
//* \brief Flash init
//*----------------------------------------------------------------------------
void AT91F_Flash_Init (void)
{
    //* Set Flash Waite sate
    //  Single Cycle Access at Up to 30 MHz
    //  if MCK = 47923200 I have 50 Cycle for 1 useconde ( flied MC_FMR->FMCN)
    //  = A page erase is performed before programming.
        AT91C_BASE_MC->MC_FMR = ((AT91C_MC_FMCN)&(50 <<16)) | AT91C_MC_FWS_1FWS ;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_Flash_Ready
//* \brief Wait the flash ready
//*----------------------------------------------------------------------------
void AT91F_Flash_Ready (void)
{
    //* Wait the and of command
          while ((AT91C_BASE_MC->MC_FSR & AT91C_MC_FRDY) != AT91C_MC_FRDY ) {};
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_Flash_Lock_Status
//* \brief Get the MVM fild status
//*----------------------------------------------------------------------------
int AT91F_Flash_Lock_Status(void)
{
  return (AT91C_BASE_MC->MC_FSR & AT91C_MC_FSR_LOCK);
}
//*----------------------------------------------------------------------------
//* \fn    AT91F_Flash_Unlock
//* \brief Clear the Non Volatile Memory Bits and set at 1 FSR bit=0
//* \input page number (0-1023) a same region have some page (16)
//* \output Region
//*----------------------------------------------------------------------------
int AT91F_Flash_Unlock(unsigned int Flash_Lock_Page)
{
    //* Write the Errase All command
        AT91C_BASE_MC->MC_FCR = AT91C_MC_CORRECT_KEY | AT91C_MC_FCMD_UNLOCK | (AT91C_MC_PAGEN & (Flash_Lock_Page << 8) ) ;

    //* Wait the and of command
        AT91F_Flash_Ready();

  return (AT91F_Flash_Lock_Status());
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_Flash_Write
//* \brief Write in one Flash page located in AT91C_IFLASH,  size in 32 bits
//* \input Flash_Address: start at 0x0010 0000 size: in byte
//*----------------------------------------------------------------------------
int AT91F_Flash_Write( unsigned int Flash_Address ,int size ,unsigned int * buff)
{
    //* set the Flasc controler base address
    AT91PS_MC ptMC = AT91C_BASE_MC;
    unsigned int i, page;
    unsigned int * Flash;
    //* init flash pointer
        Flash = (unsigned int *) Flash_Address;
    //* Get the Flasg page number
        page = ((Flash_Address - (unsigned int)AT91C_IFLASH ) /FLASH_PAGE_SIZE_BYTE);
   //* copy the new value
	for (i=0; (i < FLASH_PAGE_SIZE_BYTE) & (size > 0) ;i++, Flash++,buff++,size-=4 ){
	//* copy the flash to the write buffer ensure that code generation
	    *Flash=*buff;
	}
    //* Write the Errase_All command
        ptMC->MC_FCR = AT91C_MC_CORRECT_KEY | AT91C_MC_FCMD_START_PROG | (AT91C_MC_PAGEN & (page <<8)) ;
    //* Wait the end of command
         AT91F_Flash_Ready();
    //* Check the result
        if ( (ptMC->MC_FSR & ( AT91C_MC_PROGE | AT91C_MC_LOCKE ))!=0) return false;
  return true;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_Flash_Write
//* \brief Write in one Flash page located in AT91C_IFLASH,  size in byte
//* \input Start address (base=AT91C_IFLASH) size (in byte ) and buff address
//*----------------------------------------------------------------------------
int AT91F_Flash_Write_all( unsigned int Flash_Address ,int size ,unsigned int * buff)
{

    int   next, status;
    unsigned int  dest;
    unsigned int * src;

    dest = Flash_Address;
    src = buff;
    status = true;

    while( (status == true) & (size > 0) )
	{
        //* Check the size
        if (size <= FLASH_PAGE_SIZE_BYTE) next = size;
        else next = FLASH_PAGE_SIZE_BYTE;

        //* Unlock current sector base address - curent address by sector size
        AT91F_Flash_Unlock((dest - (unsigned int)AT91C_IFLASH ) /FLASH_PAGE_SIZE_BYTE);

        //* Write page and get status
        status = AT91F_Flash_Write( dest ,next ,src);
        // * get next page param
        size -= next;
        src += FLASH_PAGE_SIZE_BYTE/4;
        dest +=  FLASH_PAGE_SIZE_BYTE;
	}
    return status;
}

//*--------------------------------------------------------------------------------------
//* Function Name       : flash_identify
//* Object              : Read the flash Version
//*--------------------------------------------------------------------------------------
int flash_identify ( void )
{
#ifndef DEBUG
    if (*AT91C_MC_FVR == AT91C_MC_FLASH_VERSION) return true;
    else return false ;

#else
return true;
#endif
}

//*--------------------------------------------------------------------------------------
//* Function Name       : download_file_to_flash
//* Object              : Read data from file and write it into flash memory
//* Input Parameters    : <addr_base> base flash address
//*                       <addr_load> address to load
//*
//* Output Parameters   : TRUE or FALSE
//*--------------------------------------------------------------------------------------
int download_file_to_flash ( FILE *image, unsigned int Address )
{

    int         wordCount ;
    int         page;

    unsigned int *flashData ;

    numWordsRead = 1;

    while (numWordsRead !=0) {
        // Display  page to program
        //* Get the Flasg page number

        printf ("Read\n") ;
        page  =  (Address - (unsigned int)AT91C_IFLASH ) /FLASH_PAGE_SIZE_BYTE;
        // read a whole page from the file into RAM
        numWordsRead = fread ( RAMSectorData, 4, FLASH_PAGE_SIZE_LONG, image );

        if (numWordsRead != 0)
        {
            printf ( "Programming page %d\n", page) ;
            if ( ! AT91F_Flash_Write_all ( Address, numWordsRead*4, RAMSectorData ) ) {
                printf ( "Programming page %d Error\n", page ) ;
                return false ;
            }
            flashData =(unsigned int *)Address ;
            for (wordCount = 0; wordCount < numWordsRead; wordCount ++) {
                if ( RAMSectorData[wordCount] != flashData[wordCount] ) {
                  printf ( "Verify page %d Error\n", page ) ;
                  return false;
                }
            }// End for
	    } // End If
       Address+= numWordsRead*4 ;
    } // End while
    return (true ) ;
}

//*--------------------------------------------------------------------------------------
//* Function Name       : main
//* Object              : Get parameter
//* Input Parameters    : none
//* Output Parameters   : none
//*--------------------------------------------------------------------------------------
int main ( int argc, char *argv[] )
{
    unsigned int    load_addr ;
    FILE            *image ;

    char name[30];
        //* init flash memory
		AT91F_Flash_Init();
        printf ("\n**** %s Flash Programming Utility ****\n", TARGET_ID ) ;
        printf("\n**** This Utility work for external SAM7 board  !\n");
        /* Set load address */
#ifdef DEBUG
         load_addr = 0x00104000;
         sprintf(name,"c:/tmp/fill8.bin");
#else
        load_addr = 0x00100000;
        printf("\n**** Please Enter return for start !\n");
        gets(name);
        printf("\n**** File to download at %x**** \n",load_addr);
        /* Get File */
        gets(name);
#endif

        //* If Error while opening the external Flash Image file
        if (( image = fopen ( name, "rb" )) == NULL )
        {   //* Display Error then exit
            printf ( "Error - Cannot open file image \"%s\"\n", name ) ;
            return ( true ) ;
        }
        //* Else
        else
        {   //* Display input file name
            printf ( "Input file is: %s\n", name ) ;
        }

        //* Display Load Address
        printf ( "Load address is: %x\n", (int)load_addr ) ;

        // If FLASH Device is not recognized
        if ( ! flash_identify( ) )
        {  // Display Error and exit
            printf ( "Error -  Flash device not recognized\n" ) ;
            return ( false ) ;
        }
        else
        {   // If File Download into flash is not OK
            if ( ! download_file_to_flash ( image, load_addr ) )
            {   // Display Error and exit
                printf ( "Error while programming Flash\n" ) ;
                return ( false ) ;
            }
        }

    /* Close the external file and exit the program */
    fclose ( image ) ;
    // Display Flash written and exit
    printf ( "Flash written and verified\n" ) ;
    return ( true ) ;
}