fl_wrt.c

AT91所有开发板的资料 AT91所有开发板的资料

/*
 *       Function: RomInfo
 *        Purpose: Print standard info about the ROM to stdout, if not
 *                 in "quiet" mode.
 *
 *  PreConditions: 
 * 
 *         Params:
 *            Input: filename - the pathname in host form containing the PROM image
 *                   base - the base address of the Flash PROM in memory
 *                   sector - the sector to start at; a sector is a block (e.g. of 256
 *                            bytes) in the PROM
 *
 *        Returns: none.
 * 
 * PostConditions:
 */
void RomInfo(char *msg)
{
    IdentifyChip();
    
    if (!quiet)
    {
        printf(msg);
    
        if (file_defined)
            FileInfo();
        
        printf("ROM Sector size : 0x%lx\n", sector_size);
        printf("ROM Total Length    : %ldKb\n",
               divroundup((no_of_sectors * sector_size), 1024));
        
        if (start_defined)
            printf("Start Offset    : 0x%lx\n", start_offset);
        if (base_defined)
            printf("Base Address    : 0x%lx\n", base_address);
    }
}

/*
 *       Function: FileInfo
 *        Purpose: Print the filename and file size in Kb and sectros
 *                 if not quiet mode.
 *
 *  PreConditions: file_defined TRUE, openFile called, sector_size set.
 * 
 *         Params:
 *            Input: filename - global containing a pointer to the filename.
 *                   filesize - global containing the file size in bytes.
 *
 *        Returns: none.
 * 
 * PostConditions:
 */
void FileInfo(void)
{
    if (!quiet)
    {
        printf("Input File      : \"%s\"\n", filename);
        printf("File size       : %luKb (%lu sectors)\n",
               divroundup(filesize, 1024),
               divroundup(filesize, sector_size));
    }
}

void openFile(void)
{
    /* open the external FLASH Image file - any failure then exit */
    if ((image = fopen(filename,"rb")) == NULL)
    {
        printf("Error: Cannot open file \"%s\"\n", filename);
        exit(1);
    }
    
    if (fseek(image, 0, SEEK_END) == 0)
    {
        filesize = ftell(image);
        fseek(image, 0, SEEK_SET);
        filesize_defined = TRUE;
    }
}

void ShowProgress(int sectors_done)
{
    if (!quiet && ((sectors_done & 0xF) == 0))
    {
        printf("%d ", sectors_done);
        if ((sectors_done & 0xFF) == 0)
            putchar('\n');
        fflush(stdout);
    }
}


/*
 *       Function: VerifyFileInFlash
 *        Purpose: Verify the named file matches the data in flash ROM
 *
 *  PreConditions: 
 * 
 *         Params:
 *            Input: none.
 *
 *        Returns: none.
 * 
 * PostConditions:
 */
static void VerifyFileInFlash()
{
    int sectors_done;
    int endflag = 0,value_read = 0, offset;
    int errors=0;
    
    if (file_defined)
        openFile();
    
    RomInfo("Verifying Flash ROM\n");

    needBaseAddress();
    needStartOffset();
    if (!file_defined)
    {
        needFilename();
        openFile();
        FileInfo();
    }

    romsize = no_of_sectors * sector_size;
    
    if (!checkFileSize("verified"))
        return;
    
    if (!quiet)
        printf("Now verifying flash from sector 0x%lx - please wait\n",
               start_offset);

    /* Check the Image file to the FLASH Device in the required sector sizes */
    offset = sector_size * start_offset;
    sectors_done=0;
    endflag = 0;
    while (!endflag && offset < romsize && errors < 20)
    {
        int finish_sector;

        /* read Image file and write in sector sizes until not enough data
         * to fill sector
         */
        if ((value_read = fread(sector, 1, sector_size, image)) != sector_size)
        {
            /* fill remaining sector data with fill pattern 0x5a */
            for (finish_sector = value_read; finish_sector < sector_size ; finish_sector++)
            {
                ((char *)sector)[finish_sector] = FILL_PATTERN;
                endflag++;
            }
        }

        /* Verify the image file to the specified device at the offset required */
        errors += verify_sector(base_address + offset, sector_size, sector);        
        
        sectors_done++;
        ShowProgress(sectors_done);
        
        /* increment the offset for the address write - increment is the
         * sector size
         */
        offset += sector_size;
    }

    /* Close the external file and return */
    fclose(image);
    
    if (errors==0)
        printf("\nFlash verified successfully\n");
    else if (errors == 20)
        printf("\nFlash write aborted: too many errors.\n");
    else
        printf("\nFlash failed with %i verify errors\n",errors);
}

int verify_sector(unsigned long start_address, int sector_size, 
                  unsigned int sector_data[])
{
    int verify_errors = 0;
    int i;

    ASSERT(rom_identified);
    
    /* check that the sector size is not greater than the maximum */
    if (sector_size > MAX_SECTOR_SIZE) {
        printf ("Error: Sector size too large\n");
        return 1;
    }
        
    for (i = 0; i < (sector_size/4) && verify_errors < 10; i++)
    { 
        if (((volatile int *) start_address)[i] != sector_data[i])
        {
            printf("\nError: Verify Failed at address %lx\n",
                   start_address + (WORD_SIZE*i));
            verify_errors++;
        }
    }

    /* Return the number of cycles required to write the data */
    return verify_errors;
}


static void ShowROMIdentity()
{
    IdentifyChip();

    if (rom_identified)
    {
        printf ("Manufacturer:  ");
        if (manuf_code == MAN_ATMEL)
            printf ("ATMEL\n");
        else
        if (manuf_code == MAN_AMD)
            printf ("AMD\n");
        else
        if (manuf_code == MAN_STM)
            printf ("ST\n");
        else
            printf ("(unknown)\n");
    
        printf ("Device type:   ");
        switch (device_code)
        {
            case  ATMEL_AT29C040A_ID:
                printf ("AT29C040A\n");
                break;

            case  ATMEL_AT29C1024_ID:
                printf ("AT29C1024\n");
                break;

	   case AMD_AM29LV400B_ID:
                printf ("AM29LV400B\n");
                break;

	   case AMD_AM29LV800B_ID:
                printf ("AM29LV800B\n");
                break;

	   case STM_M29W400B_ID:
                printf ("M29W400B\n");
                break;

	   case STM_M29W800B_ID:
                printf ("M29W800B\n");
                break;

            default :
                printf ("(unknown)\n");
                break;
        }
        printf ("Sector size:   %lu bytes\n", sector_size);
        printf ("Total sectors: %lu\n", no_of_sectors);   
        printf ("ROM size:      %lu bytes\n", sector_size * no_of_sectors);
        printf ("Base Address:  0x%lx\n", base_address);
    }
}


/* main 
 *
 * This is the c library entry point and controlling function for
 * the whole  program. It checks that there is a specified file for
 * download and then  checks the identity of the flash device on
 * board.. The external file is then  opened and transferred to the
 * flash memory in the required sectors
 */
int main(int argc, char *argv[])
{
    int i;
    
#define GETARG(i)   ((argv[i][2] == '\0' && i < (argc+1)) ? argv[++i] : argv[i]+2)
    
    for(i = 1; i < argc && argv[i][0]=='-'; i++)
    {
        switch (argv[i][1])
        {
            case 'v':
                mode = op_verify;
                break;
                
            case 'w':
                mode = op_writerom;
                break;
                
            case 'B':
                mode = op_blank;
                break;
                
            case 'h':
                mode = op_help;
                break;
                
            case 'I':
                mode = op_identify;
                break;
                
            case 'V':
                verbose = TRUE;
                break;
                
            case 't':
                device_code = STM_M29W400B_ID;
                manuf_code = MAN_STM;
                SetDeviceParams();
                break;
                
            case 'p':
                interactive = TRUE;
                break;
                
            case 's':
                start_offset = atol(GETARG(i));
                start_defined = TRUE;
                break;
                
            case 'b':
                base_address = atol(GETARG(i));
                base_defined = TRUE;
                break;
                
            default:
                printf("Error: unknown option letter \"%c\"\n", argv[i][1]);

                DisplayHelp();
                exit(1);
        }
    }

    if (!quiet)
        printf("ARM Flash Programming Utility\n\n");

    if (i < argc)
    {
        strcpy(filename, argv[i]);
        file_defined = TRUE;
    }
    else
        filename[0] = 0;

    switch(mode)
    {
        case op_writerom:
            DownloadFileToFlash();
            break;
        case op_blank:
            BlankFlash();
            break;
        case op_verify:
            VerifyFileInFlash();
            break;
        case op_help:
            DisplayHelp();
            break;
        case op_identify:
            ShowROMIdentity();
            break;
            
    }

    return 0;
}