AT91PS_MC     f_pMC     = AT91C_BASE_MC;

int flash_write_page(int* addr, int* data, unsigned int size_data)    
{
    int page;
    unsigned int i = 0, count=0;
    int * Flash;
      
    Flash = (int*)addr;
    page =  ((int)addr >> 8);
  
    for (i=0;(i<size_data)&&(i<255); Flash++,count++,i += 4)  
        {
         *Flash= data[count];
        }
    
    f_pMC->MC_FCR = (0x5a << 24) | (page << 8) | AT91C_MC_FCMD_START_PROG;

    while(!( f_pMC->MC_FSR) & AT91C_MC_FRDY);

    if((f_pMC->MC_FSR & AT91C_MC_LOCKE) || (f_pMC->MC_FSR & AT91C_MC_PROGE))
    {
       return -1;
    }
    return 0;
}

    //Write Flash
    s_pAIC->AIC_IDCR = NU1;
    flash_write_page (data_real,buff_ssc,32);
    s_pAIC->AIC_IECR = iMask;

p_pMC->MC_FMR = 0x24<<16;

int temp;
  while(!((temp=f_pMC->MC_FSR) & AT91C_MC_FRDY));
    
    if((temp & AT91C_MC_LOCKE) || (temp & AT91C_MC_PROGE))
    {
       return -1;
    }

while(!((temp=f_pMC->MC_FSR) & AT91C_MC_FRDY));

PAbt_Handler    B       PAbt_Handler

FIQ_Handler     B       FIQ_Handler

#include "board.h"
AT91PS_MC     f_pMC     = AT91C_BASE_MC;
int flash_write_page(int addr, char *data, int size_data)
{
    int i = 0,  page, temp;
    int *Flash, *data_temp;
    Flash = (int*)addr;
    data_temp= (int*) data;
    page = (int)((addr - (int)AT91C_IFLASH)>> 8);

    for (i=0;(i<size_data)&&(i<255); Flash++,data_temp++,i += 4)
        {
        *Flash =*data_temp;
        }
    f_pMC->MC_FCR = (0x5a << 24) | (page << 8) | AT91C_MC_FCMD_START_PROG;
    while(!((temp=f_pMC->MC_FSR) & AT91C_MC_FRDY));
    if((temp & AT91C_MC_LOCKE) || (temp & AT91C_MC_PROGE))
    {
       return -1;
    }
    return 0;
}

    f_pMC->MC_FCR = (0x5a << 24) | (page << 8) | AT91C_MC_FCMD_START_PROG;
    while(!((temp=f_pMC->MC_FSR) & AT91C_MC_FRDY));

__ramfunc  int flash_write_page(int addr, char *data, int size_data)

//*----------------------------------------------------------------------------
//* 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 : Flash.c
//* Object : Flash routine
//* Creation : JPP 30/Jun/2004
//* Modif : JPM 16/Nov/2004 Flash write status
//*----------------------------------------------------------------------------

// Include Standard files
#include <hardware.h>
#include <flash.h>

#define false 0
#define true 1

//*----------------------------------------------------------------------------
//* \fn AT91F_Flash_Init
//* \brief Flash init
//*----------------------------------------------------------------------------
void AT91F_Flash_Init (void)
{
//* Set number of Flash Waite sate
// SAM7S64 features Single Cycle Access at Up to 30 MHz
// if MCK = 47923200, 50 Cycles for 1 µseconde ( field MC_FMR->FMCN)
AT91C_BASE_MC->MC_FMR = ((AT91C_MC_FMCN)&(50 <<16)) | AT91C_MC_FWS_1FWS;
}

//*----------------------------------------------------------------------------
//* \fn AT91F_Flash_Ready
//* \brief Wait the flash ready
//*----------------------------------------------------------------------------
__ramfunc int AT91F_Flash_Ready (void)
{
unsigned int status;
status = 0;

//* Wait the end of command
while ((status & AT91C_MC_FRDY) != AT91C_MC_FRDY )
{
status = AT91C_BASE_MC->MC_FSR;
}
return status;
}

//*----------------------------------------------------------------------------
//* \fn AT91F_Flash_Lock_Status
//* \brief Get the Lock bits field status
//*----------------------------------------------------------------------------
__ramfunc int AT91F_Flash_Lock_Status(void)
{
return (AT91C_BASE_MC->MC_FSR & AT91C_MC_FSR_LOCK);
}
//*----------------------------------------------------------------------------
//* \fn AT91F_Flash_Lock
//* \brief Write the lock bit and set at 0 FSR Bit = 1
//* \input page number (0-1023)
//* \output Region
//*----------------------------------------------------------------------------
__ramfunc int AT91F_Flash_Lock (unsigned int Flash_Lock_Page)
{
//* set the Flash controller base address
AT91PS_MC ptMC = AT91C_BASE_MC;

//* write the flash
//* Write the Set Lock Bit command
ptMC->MC_FCR = AT91C_MC_CORRECT_KEY | AT91C_MC_FCMD_LOCK | (AT91C_MC_PAGEN & (Flash_Lock_Page << 8) );

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

return (AT91F_Flash_Lock_Status());
}
//*----------------------------------------------------------------------------
//* \fn AT91F_Flash_Unlock
//* \brief Clear the lock bit and set at 1 FSR bit=0
//* \input page number (0-1023)
//* \output Region
//*----------------------------------------------------------------------------
__ramfunc int AT91F_Flash_Unlock(unsigned int Flash_Lock_Page)
{
//* Write the Clear Lock Bit command
AT91C_BASE_MC->MC_FCR = AT91C_MC_CORRECT_KEY | AT91C_MC_FCMD_UNLOCK | (AT91C_MC_PAGEN &
(Flash_Lock_Page << 8) );

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

return (AT91F_Flash_Lock_Status());
}

//*----------------------------------------------------------------------------
//* \fn AT91F_Flash_Check_Erase
//* \brief Check the memory at 0xFF in 32 bits access
//*----------------------------------------------------------------------------
__ramfunc int AT91F_Flash_Check_Erase (unsigned int * start, unsigned int size)
{
unsigned int i;
//* Check if flash is erased
for (i=0; i < (size/4); i++ )
{
if ( start[i] != ERASE_VALUE ) return false;
}
return true;
}

//*----------------------------------------------------------------------------
//* \fn AT91F_Flash_Erase_All
//* \brief Send command erase all flash
//*----------------------------------------------------------------------------
__ramfunc int AT91F_Flash_Erase_All(void)
{
//* set the Flash controller base address
AT91PS_MC ptMC = AT91C_BASE_MC;
//* Write the Erase All command
ptMC->MC_FCR = AT91C_MC_CORRECT_KEY | AT91C_MC_FCMD_ERASE_ALL;
//* Wait the end of command
AT91F_Flash_Ready();
//* Check the result
return ( (ptMC->MC_FSR & ( AT91C_MC_PROGE | AT91C_MC_LOCKE ))==0);
}

//*----------------------------------------------------------------------------
//* \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
//*----------------------------------------------------------------------------
__ramfunc int AT91F_Flash_Write( unsigned int Flash_Address ,int size ,unsigned int * buff)
{
//* set the Flash controller base address
AT91PS_MC ptMC = AT91C_BASE_MC;
unsigned int i, page, status;
unsigned int * Flash;
//* init flash pointer
Flash = (unsigned int *) Flash_Address;
//* Get the Flash 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 ensuring code generation
*Flash=*buff;
}
//* Write the write page command
ptMC->MC_FCR = AT91C_MC_CORRECT_KEY | AT91C_MC_FCMD_START_PROG | (AT91C_MC_PAGEN & (page <<8));
//* Wait the end of command
status = AT91F_Flash_Ready();
//* Check the result
if ( (status & ( 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
//*----------------------------------------------------------------------------
__ramfunc 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 - current 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;
}

//*----------------------------------------------------------------------------
//* \fn AT91F_NVM_Status
//* \brief Get the NVM field status
//*----------------------------------------------------------------------------
__ramfunc int AT91F_NVM_Status(void)
{
return (AT91C_BASE_MC->MC_FSR & AT91C_MC_FSR_MVM);
}

//*----------------------------------------------------------------------------
//* \fn AT91F_NVM_Set
//* \brief Write the Non Volatile Memory Bits and set at 0 FSR Bit = 1
//*----------------------------------------------------------------------------
__ramfunc int AT91F_NVM_Set (unsigned char NVM_Number)
{
//* set the Flash controller base address
AT91PS_MC ptMC = AT91C_BASE_MC;

//* write the flash
//* Write the Set NVM Bit command
ptMC->MC_FCR = AT91C_MC_CORRECT_KEY | AT91C_MC_FCMD_SET_GP_NVM | (AT91C_MC_PAGEN & (NVM_Number << 8)
);

//* Wait the end of command
AT91F_Flash_Ready();
return (AT91F_NVM_Status());
}
//*----------------------------------------------------------------------------
//* \fn AT91F_NVM_Clear
//* \brief Clear the Non Volatile Memory Bits and set at 1 FSR bit=0
//*----------------------------------------------------------------------------
__ramfunc int AT91F_NVM_Clear(unsigned char NVM_Number)
{
//* set the Flash controller base address
AT91PS_MC ptMC = AT91C_BASE_MC;

//* write the flash
//* Write the Clear NVM Bit command
ptMC->MC_FCR = AT91C_MC_CORRECT_KEY | AT91C_MC_FCMD_CLR_GP_NVM | (AT91C_MC_PAGEN & (NVM_Number << 8)
);

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

return (AT91F_NVM_Status());
}

//*----------------------------------------------------------------------------
//* \fn AT91F_SET_Security_Status
//* \brief Get Flash Security Bit Status
//*----------------------------------------------------------------------------
int AT91F_SET_Security_Status (void)
{
return (AT91C_BASE_MC->MC_FSR & AT91C_MC_SECURITY);
}

//*----------------------------------------------------------------------------
//* \fn AT91F_SET_Security
//* \brief Set Flash Security Bit
//*----------------------------------------------------------------------------
int AT91F_SET_Security (void)
{
//* write the flash
//* Write the Set Security Bit command
AT91C_BASE_MC->MC_FCR = ( AT91C_MC_CORRECT_KEY | AT91C_MC_FCMD_SET_SECURITY );

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

return (AT91F_SET_Security_Status());
}


//*----------------------------------------------------------------------------
//* 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 : Flash.h
//* Object : Flash constan description
//* Creation : JPP 30/Jun/2004
//*
//*----------------------------------------------------------------------------

#ifndef Flash_h
#define Flash_h

/*-------------------------------*/
/* Flash Status Field Definition */
/*-------------------------------*/

#define AT91C_MC_FSR_MVM ((unsigned int) 0xFF << 8) // (MC) Status Register GPNVMx: General-purpose NVM
Bit Status
#define AT91C_MC_FSR_LOCK ((unsigned int) 0xFFFF << 16) // (MC) Status Register LOCKSx: Lock Region x
Lock Status

#define ERASE_VALUE 0xFFFFFFFF

/*-----------------------*/
/* Flash size Definition */
/*-----------------------*/
/* 64 Kbytes of Internal High-speed Flash, Organized in 512 Pages of 128 Bytes */

#define FLASH_PAGE_SIZE_BYTE 256
#define FLASH_PAGE_SIZE_LONG 32

#define FLASH_LOCK_BITS_SECTOR 16
#define FLASH_SECTOR_PAGE 32
#define FLASH_LOCK_BITS 16 /* 16 lock bits, each protecting 16 sectors of 32 pages*/
#define FLASH_BASE_ADDRESS 0x00100000
/*------------------------------*/
/* External function Definition */
/*------------------------------*/

/* Flash function */
extern void AT91F_Flash_Init(void);
extern int AT91F_Flash_Check_Erase(unsigned int * start, unsigned int size);
extern int AT91F_Flash_Erase_All(void);
extern int AT91F_Flash_Write( unsigned int Flash_Address ,int size ,unsigned int * buff);
extern int AT91F_Flash_Write_all( unsigned int Flash_Address ,int size ,unsigned int * buff);

/* Lock Bits functions */
extern int AT91F_Flash_Lock_Status(void);
extern int AT91F_Flash_Lock (unsigned int Flash_Lock);
extern int AT91F_Flash_Unlock(unsigned int Flash_Lock);

/* NVM bits functions */
extern int AT91F_NVM_Status(void);
extern int AT91F_NVM_Set (unsigned char NVM_Number);
extern int AT91F_NVM_Clear(unsigned char NVM_Number);

/* Security bit function */
extern int AT91F_SET_Security_Status (void);
extern int AT91F_SET_Security (void);

#endif /* Flash_h */

AT91F_Flash_Init;
AT91F_Flash_Ready;
AT91F_Flash_Write;

at91_flash.h:
#ifndef AT91_FLASH_H__
#define AT91_FLASH_H__
#include    <stdint.h>
#include    <ioAT91SAM77S64.h>

#define MCK_CYCLES          ((15ULL * MCK + 5000000) / 10000000)
#define FLASH_WAITSTATES    MCK_CYCLES < 30000000ULL ? AT91C_MC_FWS_0FWS : AT91C_MC_FWS_1FWS

inline void ErasePage(uint32_t const *addr)
{
    FlashCommand( (0x5AULL *  AT91C_MC_KEY / 0xFF) | (((uint32_t)addr >> 7) << 8) | AT91C_MC_FCMD_START_PROG, \
                  (0 * AT91C_MC_FRDY) | (0 * AT91C_MC_LOCKE) | ( 0 * AT91C_MC_PROGE) \
                  | (0 * AT91C_MC_NEBP) | (FLASH_WAITSTATES) | (MCK_CYCLES * AT91C_MC_FMCN / 0xFF));
}

inline void ProgramPage(uint32_t const *addr)
{
    FlashCommand( (0x5AULL *  AT91C_MC_KEY / 0xFF) | (((uint32_t)addr >> 7) << 8) | AT91C_MC_FCMD_START_PROG, \
                  (0 * AT91C_MC_FRDY) | (0 * AT91C_MC_LOCKE) | ( 0 * AT91C_MC_PROGE) \
                  | (1 * AT91C_MC_NEBP) | (FLASH_WAITSTATES) | (MCK_CYCLES * AT91C_MC_FMCN / 0xFF));
}

inline void RewritePage(uint32_t const *addr)
{
    FlashCommand( (0x5AULL *  AT91C_MC_KEY / 0xFF) | (((uint32_t)addr >> 7) << 8) | AT91C_MC_FCMD_START_PROG, \
                (0 * AT91C_MC_FRDY) | (0 * AT91C_MC_LOCKE) | ( 0 * AT91C_MC_PROGE) \
                | (0 * AT91C_MC_NEBP) | (FLASH_WAITSTATES) | (MCK_CYCLES * AT91C_MC_FMCN / 0xFF));
}
#endif  // AT91_FLASH_H__

at91_flash.c:
__ramfunc __arm void FlashCommand_RAM(uint32_t command)
{
    AT91C_BASE_MC->MC_FCR = command;
    while(!(AT91C_BASE_MC->MC_FSR & AT91C_MC_FRDY));
}

__arm void FlashCommand(uint32_t command, uint32_t mode)
{
    uint32_t Status = __get_CPSR();
    do
    {
        __set_CPSR(Status | (1 << CPSR_IRQ_EN));    // disable IRQ
    }
    while(! (__get_CPSR() & (1 << CPSR_IRQ_EN)));
    
    AT91C_BASE_MC->MC_FMR = mode;
    FlashCommand_RAM(command);
    __set_CPSR(Status);             // restore IRQ
}

  FLASH_LOAD 0x100000
  {
  EXE +0 0x40000
    {
    *.o (RESET, +FIRST)
    * (+RO)
    }
  DATA 0x200000 0x7fff
    {
    * (+RW +ZI)
    }
  ISR_EXE 0x208000 0x2000
    {
    flash.o (+RO)
    }
  }

#pragma arm section CODE = "CODE_RAM"
...
#pragma arm section CODE

FLASH_LOAD 0x100000
  {
  EXE +0 0x40000
    {
    *.o (RESET, +FIRST)
    * (+RO)
    }
  DATA 0x200000 0x8000
    {
    * (+RW +ZI)
    }
  ISR_EXE 0x208000 0x2000
    {
    * (CODE_RAM)
    }
  }