test_mec01.c

ARM入门的好帮手.包含了从简单到相对较复杂的程序.

        *(base_addr + FLASH_SEQ_ADD2) = FLASH_CODE2;
        *(base_addr + FLASH_SEQ_ADD1) = ID_OUT_CODE;

        //* If both manufacturer and device codes corresponds
        if (( flash_pt->flash_id == device_code ) &&
            ( flash_pt->flash_manuf_id == manuf_code ))
        {
            //* Exit the search loop
            exit = TRUE ;
        }
        //* Else
        else
        {
            //* Next Flash, If end of table
            if ( ++flash_pt >= FlashTable + NB_FLASH_SUPPORTED )
            {
                //* Return 0, Display Error and Exit loop
                flash_pt = (const FlashDef *)0 ;
                printf ( "Error - Unknown device: manufacturer %02x / device %02x \n",
                        manuf_code, device_code );
                exit = TRUE ;
            }
            //* Endif
        }
        //* Endif
    }
    //* EndWhile

    //* Return pointer to Flash found
    return ( flash_pt ) ;
}

/*------------------------------------------------------------*/
int wait_flash_ready ( flash_word *address )
/*------------------------------------------------------------*/
{
//* Begin
    int time_out = 0 ;

    //* While two consecutive read don't give same value or timeout
    while (( *address != *address ) && ( time_out++ < TIME_OUT )) ;

    //* If timeout
    if ( time_out < TIME_OUT )
    {
       return ( TRUE ) ;
    }
    //* Else
    else
    {
        return ( FALSE ) ;
    }
}
//* End

/*------------------------------------------------------------*/
void erase_chip ( flash_word *base_addr )
/*------------------------------------------------------------*/
{
    int         j ;
    flash_word  read_data ;

        //* Display Erasing Chip
        printf ( "\nErasing Flash... \n" ) ;

        //* Enter Chip Erase Sequence codes
        *(base_addr + FLASH_SEQ_ADD1) = FLASH_CODE1;
        *(base_addr + FLASH_SEQ_ADD2) = FLASH_CODE2;
        *(base_addr + FLASH_SEQ_ADD1) = ERASE_CHIP_CODE1;
        *(base_addr + FLASH_SEQ_ADD1) = FLASH_CODE1;
        *(base_addr + FLASH_SEQ_ADD2) = FLASH_CODE2;
        *(base_addr + FLASH_SEQ_ADD1) = ERASE_CHIP_CODE2;

        //* Wait for Flash Ready after Erase, if timeout
        if ( wait_flash_ready ( base_addr )== FALSE )
        {
            //* Display Timeout and return False
            printf ( "Timeout while erasing\n" ) ;
        }
        else
        {
             //* For each word of the flash
             for ( j = 0 ; j < ((2*1024*1024)/2) ; j ++ )
             {
                 //* Check erased value reading, if not
                 if (( read_data = *(base_addr + j)) != (flash_word)0xFFFF )
                 {
                     //* Display Error and return False
                     printf ( "Flash not erased !\n" ) ;
                     printf ( "Address 0x%08x, Value 0x%08x\n",
                              (int)(base_addr + j), read_data ) ;
                 }
             }

             //* Display Chip Erased
             printf ( "Flash erased and checked !\n\n" ) ;
        }
}

/*------------------------------------------------------------------------------*/
int write_flash ( flash_word *base_addr, flash_word *load_addr, flash_word data )
/*------------------------------------------------------------------------------*/
{
    flash_word  read_data ;

    //* Enter Programming code sequence
    *(base_addr + FLASH_SEQ_ADD1) = FLASH_CODE1 ;
    *(base_addr + FLASH_SEQ_ADD2) = FLASH_CODE2 ;
    *(base_addr + FLASH_SEQ_ADD1) = WRITE_CODE ;
    *load_addr = data ;

    //* Wait for Flash ready after erasing, if timeout
    if ( wait_flash_ready ( load_addr ) != TRUE )
    {
        //* Display Error and Exit
        printf ( "Timeout while programming\n" ) ;
        return ( FALSE ) ;
    }
    //* Endif

    //* If Data written does not equal data
    if (( read_data = *load_addr ) != data )
    {
        //* Display Error and return False
        printf ( "Program Error\n" ) ;
        printf ( "Address 0x%08x / Data 0x%04x / 0x%04x \n",
                 (int)load_addr, data, read_data ) ;
        //* Return False
        return ( FALSE );
    }
    //* Endif

    //* Return False
    return ( TRUE ) ;
}
//* End

//*---------------------------------------------------------------------
//* Function    : Main function
//* Objet       : Test for FLASH and SRAM Memories
//*---------------------------------------------------------------------
int main ( void )
{
    //* Variables definition for Flash Memory
    flash_word          *base_addr ;
    const FlashDef      *flash ;
    int                 pos = 0 ;
    int                 end_pos = 40 ;

    //* Variables definition for SRAM Memory
    volatile u_int      *wr_pt = (u_int*)sram_base_addr ;
    u_int               count ;
    u_int               sram_data ;
    u_int               error ;
    u_int               save_error = FALSE ;


u_int   offset_addr[40] = {0x0000,0x2002,0x4004,0x6008,0x8010,0xA020,0xC040,0xE080,0x10100,0x18200,0x020400,
                           0x030800,0x041000,0x050000,0x060000,0x070000,0x080000,0x090000,0xa0000,0x0b0000,
                           0x0c0000,0x0d0000,0x0e0000,0x0F0000,0x100000,0x110000,0x120000,0x130000,0x140000,
                           0x150000,0x160000,0x170000,0x180000,0x190000,0x1a0000,0x1b0000,0x1c0000,0x1d0000,
                           0x1e0000,0x1F0000} ;

flash_word  flash_data[40] = {0x0001,0x0002,0x0004,0x0008,0x0010,0x0020,0x0040,0x0080,0x0100,0x0200,0x0400,0x0800,
                              0x1000,0x2000,0x4000,0x8000,0x0016,0x0017,0x0018,0x0019,0x0020,0x0021,0x0022,0x0023,
                              0x0024,0x0025,0x0026,0x0027,0x0028,0x0029,0x0030,0x0031,0x0032,0x0033,0x0034,0x0035,
                              0x0036,0x0037,0x0038,0x0039} ;


    //*Setup EBI to support all memories on Extention board
    *(u_int*)0xFFE00008 = CONF_CSR2 ;
    *(u_int*)0xFFE0000C = CONF_CSR3 ;
    *(u_int*)0xFFE00010 = CONF_CSR4 ;
    *(u_int*)0xFFE00014 = CONF_CSR5 ;
    *(u_int*)0xFFE0001C = CONF_CSR7 ;
    *(u_int*)0xFFE00024 = ALE ;

    base_addr = (flash_word*)flash1_base_addr ;

    //* Display Test Software Header
    printf ( "\n**** MEMORY EXTENTION BOARD TEST SOFTWARE %s ****\n", SOFTWARE_VERSION ) ;
    printf ( "\n**** Testing Flash Memories ****\n" ) ;
    printf ( "\n-----------------------------------------------------\n" ) ;

//*----------------------------
//* Testing first Flash device
//*----------------------------
        //* If FLASH Device is not recognised
        if (( flash = flash_identify ( base_addr )) == (const FlashDef *)0 )
        {
            //* Display Error and exit
            printf ( "Error - The Flash device is not recognised\n" ) ;
        }

        //* Display Flash Base Address
        erase_chip ( base_addr ) ;

        printf ( "Writing Data to %s Flash memory...\n", flash->flash_name ) ;

        for ( pos = 0; pos < end_pos ; pos++ )
        {
            //* Write the value read in Flash, if error
            if ( write_flash ( base_addr, (flash_word*)((u_int)base_addr + offset_addr[pos]), flash_data[pos] ) != TRUE )
            {
                printf ( "Programming Error !!\n" ) ;
            }
        }

        //* Display Flash written and exit
        printf ( "Flash written and checked\n" ) ;

        erase_chip ( base_addr ) ;

        //*Change base address for next Flash Device
        base_addr = (flash_word*)flash2_base_addr ;
        printf ( "\n-----------------------------------------------------\n" ) ;

//*------------------------------
//* Testing second Flash device
//*------------------------------

    //* If FLASH Device is not recognised
    if (( flash = flash_identify ( base_addr )) == (const FlashDef *)0 )
    {
        //* Display Error and exit
        printf ( "Error - The Flash device is not recognised\n" ) ;
    }

    //* Display Flash Base Address
    erase_chip ( base_addr ) ;

    //* Display Flash Tested
    printf ( "Writing Data to %s Flash memory...\n", flash->flash_name ) ;

    if (flash->flash_id == 0x00CB)
    end_pos = 24 ;

    for ( pos = 0; pos < end_pos ; pos++ )
    {
        //* Write the value read in Flash, if error
        if ( write_flash ( base_addr, (flash_word*)((u_int)base_addr + offset_addr[pos]), flash_data[pos] ) != TRUE )
        {
            printf ( "Programming Error !!\n" ) ;
        }
    }

    //* Display Flash written and exit
    printf ( "Flash written and checked\n" ) ;

    erase_chip ( base_addr ) ;

    printf ( "\n-----------------------------------------------------\n" ) ;
    printf ( "\n\n**** Testing SRAM Memories ****\n\n" ) ;
    printf ( "\n-----------------------------------------------------\n" ) ;
    printf ( "\nWriting Data to SRAM Memories and Verifying ...\n" ) ;

        for ( count = 0 ; count < (sram_size/4) ; count ++, wr_pt ++ )
        {

            error = FALSE ;

            *wr_pt = 0 ;
            if (( sram_data = *wr_pt ) != 0 ) error = TRUE ;
            *wr_pt = 0xFFFFFFFF ;
            if (( sram_data = *wr_pt ) != 0xFFFFFFFF ) error = TRUE ;
            *wr_pt = 0x55555555 ;
            if (( sram_data = *wr_pt ) != 0x55555555 ) error = TRUE ;
            *wr_pt = 0xAAAAAAAA ;
            if (( sram_data = *wr_pt ) != 0xAAAAAAAA ) error = TRUE ;

            if ( error == TRUE )
            {
                printf ( "TEST SRAM ERROR : 0x%08x / 0x%08x\n", (int)wr_pt, sram_data ) ;
                save_error = TRUE ;
            }
        }

    if ( save_error == FALSE )
    {
        printf ( "\nSRAM MEMORY OK\n" ) ;
        return ( TRUE ) ;
    }
    else
    {
        printf ( "SRAM MEMORY ERROR !\n" ) ;
        return ( FALSE ) ;
    }
}