allflash.c

boot loader示范程序

#include <stdio.h>
#include <misc.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <iocntrl.h>
#include <process.h>



#define AUTO_PG_ERASE1  0x2020
#define AUTO_PG_ERASE2  0xD0D0







#define     PIO0_OUT	        0x2000A000      /* PIO 0 output reg       */
#define     PIO0_C0     	    0x2000A020      /* PIO 0 C0 reg           */
#define     PIO0_C1         	0x2000A030      /* PIO 0 C1 reg           */
#define     PIO0_C2         	0x2000A040      /* PIO 0 C2 reg           */


/********************************AMD define*******************************************/
#define 	AMD_ID				0x0001		
#define		AMD_AM29F800		0x22d6

#define 	STATUS_ERROR		0x00
#define 	STATUS_READY		0x01
#define 	STATUS_ERSUSP		0x02
#define 	STATUS_TIMEOUT		0x03
#define 	STATUS_BUSY			0x04



/********************************INTEL define*******************************************/
#define 	INTEL_ID			0x0089		
#define		INTEL_28F800TL		0x889c
#define     INTEL_28F004BX_TL   0x7878
#define     INTEL_28F004BX_BL   0x7979  
#define  	ERASE_SETUP    		0x0020               /* erase_setup command          */
#define  	ERASE_CONFIRM  		0x00d0               /* erase_confirm command        */
#define  	ERASE_SUSPEND  		0x00b0               /* erase_suspend command        */
#define  	ERASE_RESUME   		0x00d0               /* erase_confirm command        */
#define  	PROGRAM_SETUP  		0x0040               /* program_setup command        */
#define  	CLEAR_SREG     		0x0050               /* clear status_reg command     */
#define  	READ_SREG      		0x0070               /* read status_reg command      */
#define  	READ_IDENT     		0x0090               /* read flash_rom ident command */
#define  	READ_ARRAY     		0x00ff               /* read flash_rom_array command */
#define  	BIT7_STATUS    		0x0080               /* condition P/E success        */
#define  	BIT6_STATUS    		0x0040               /* condition P/E success        */
#define  	BIT5_STATUS    		0x0020               /* condition P/E success        */
#define  	BIT4_STATUS    		0x0010               /* condition P/E success        */
#define  	BIT3_STATUS  		0x0008               /* condition P/E success        */
#define  	ALLBITS1       		0x00ff

#define 	ADT_CONTROL_PORTF0 0xc0f00000


/********************************SST define*******************************************/
#define 	SST_ID				0xBFBF		
#define		SST_28SF040			0x0404
#define 	ROW_SIZE            256             /* Must be 256 bytes for 28SF040  */


/********************************ST define*******************************************/
#define 	ST_ID				0x2020		
#define		ST_M28F411			0xf6f6
#define		ST_M28F410			0xf2f2
#define 	ST_M28F211			0xe4e4



#define     FROM_TOP        	0x80000000      /* top_most +1 FlashROM address */
#define     FROM_BOT        	0x7FF00000


#define  	MFGID_ADDR  		(FROM_BOT | 0x00000000)
#define  	DEVID_ADDR  		(FROM_BOT | 0x00000001)


typedef enum{
	BOOTBLK,
	PARAMBLK1,
	PARAMBLK2,
	MAINBLK1,
	MAINBLK2,
	MAINBLK3,
	MAINBLK4,
	MAINBLK5,
	MAINBLK6,
	MAINBLK7,
	MAINBLK8,
	MAINBLK9,
	MAINBLK10,
	MAINBLK11,
	MAINBLK12,
	MAINBLK13,
	MAINBLK14,
	MAINBLK15,
	MAINBLK16
} flashblock;

#define 	MAXSECTORS          19
struct flashinfo {
	 char *manufacture_name;
	 char *device_name;         /* "", etc. */
	 int num_sector;          /* # of sectors */
 struct {
	 unsigned int base;           /* offset from beginning of device */
	 }sec[MAXSECTORS];  /* per-sector info */
};

struct flashinfo *meminfo; /* A pointer into a specific field defined
                              in memdesc below */                    

struct flashinfo used_flash[6]= {
	{ "AMD","AM29F800",19,{0x7E000,0x7D000,0x7C000,0x78000,0x70000,0x68000,0x60000,0x58000,0x50000,
						0x48000,0x40000,0x38000,0x30000,0x28000,0x20000,0x18000,0x10000,0x08000,0x0000}},
	{ "INTEL","28F800TL",11,{0xFC000,0xFA000,0xF8000,0xE0000,0xC0000,0xA0000,0x80000,0x60000,0x40000,0x20000,0x00000,0,0,0,0,0,0,0,0}},                
	{ "INTEL","28F004BX_TL",7,{0x7E000,0x7D000,0x7c000,0x70000,0x60000,0x50000,0x40000,0,0,0,0,0,0,0,0,0,0,0,0}},             
	{ "SST","28SF040",0,{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}},                   
	{ "ST","M28F411",7,{0x1f0000,0x1e8000,0x1e0000,0x1c0000,0x100000,0x080000,0x000000,0,0,0,0,0,0,0,0,0,0,0,0}},                     
	{ "ST","M28F410",7,{0x1f0000,0x1e8000,0x1e0000,0x1c0000,0x100000,0x080000,0x000000,0,0,0,0,0,0,0,0,0,0,0,0}},                     
};                                         
                                           

#define MEMBLOCK(x)  	(FROM_BOT | meminfo->sec[x].base)

                                          
                                           
#define         USHORT          unsigned short
#define MAX_BYTES_PER_ROW       16         
#define ONE_BYTE                1          
#define MAX_STRING_LENGTH       80         
typedef char STRING[MAX_STRING_LENGTH];
#ifdef HEX_FORMAT
typedef int BYTE_ROW[MAX_BYTES_PER_ROW];
#else
typedef unsigned char BYTE_ROW[MAX_BYTES_PER_ROW];
#endif
typedef struct hex_rom_struct {
  int          entries;
  unsigned int address;
  BYTE_ROW     row;
} HEX_ROM_STRUCT;

/*
 * Type defs for filenames and parameters
 */
typedef char *ADDRESS;
typedef volatile char *VOLATILE_ADDRESS;
typedef char BYTE;
typedef enum romtool_mode   {NULL_MODE, ERROR_MODE, ERASE, PROGRAM, VERIFY, DUMP} ROMTOOL_MODE;
typedef enum romtool_report {NULL_REPORT, ERROR_REPORT, FULL, REDUCED, NONE} ROMTOOL_REPORT;
#define MAX_FILENAME_LENGTH     255
typedef char FILE_STRING[MAX_FILENAME_LENGTH];
typedef enum bool {FALSE, TRUE} BOOL;

/*
 * Macros to handle various levels of reporting to screen and logfile
 */
#define FULL_REP_MSG(m) if (rom_report == FULL) printf m
#define FULL_LOG_MSG(m) if ((rom_report == FULL) && (rom_logging)) fprintf m
#define REDUCED_REP_MSG(m) if (rom_report != NONE) printf m
#define REDUCED_LOG_MSG(m) if ((rom_report != NONE) && (rom_logging)) fprintf m
#define LOG_MSG(m) if (rom_logging) fprintf m


/*****************************Gloval variable***********************************/

BOOL            rom_logging = FALSE;            /* log file active              */
BOOL            rom_serial = FALSE;             /* ROM serial number update     */
ROMTOOL_REPORT  rom_report = NULL_REPORT;       /* reporting level              */
FILE            *rom_logfile_fp;                /* logfile descriptor           */
FILE            *rom_datafile_fp;               /* datafile descriptor          */
int             rom_size;                       /* size of ROM                  */
int             *vppgen;                        /* vpp_generator pointer        */
int             *word_address;                  /* word_address pointer         */
unsigned int    rom_base;                       /* base address of ROM          */
FILE_STRING     rom_datafile;                   /* datafile name                */
FILE_STRING     rom_logfile;                    /* logfile name                 */
FILE_STRING     rom_serialno;                   /* Serial number/code           */
ROMTOOL_MODE    rom_mode = NULL_MODE;           /* operational mode             */
BOOL            result = TRUE;                  /* global result flag           */
BOOL            error = TRUE;                   /* global result flag           */
BOOL            type_bl = TRUE;                 /* 400BX-BL or -TL flag        */

volatile USHORT        mfr_id;
volatile USHORT        dev_id;

/*****************************fuction prototype ***********************************/
void Check_Toggle_Ready (volatile USHORT *Dst);
void Disable_Chip_Data_Protection(void);
void Enable_Chip_Data_Protection(void);
void vpp_on(void);
void vpp_off(void);
USHORT flash_status(USHORT *fp);



void rom_exit_terminate (int val){
	
	if (rom_datafile_fp != NULL) {
		fclose(rom_datafile_fp);
		FULL_REP_MSG(("ROMTOOL: data file %s closed\n", rom_datafile));
		FULL_LOG_MSG((rom_logfile_fp, "ROMTOOL: data file %s closed\n", rom_datafile));
	}

	if (rom_logging) {
		FULL_REP_MSG(("ROMTOOL: log file %s closing\n", rom_logfile));
		FULL_LOG_MSG((rom_logfile_fp, "ROMTOOL: log file %s closing\n", rom_logfile));
		fclose(rom_logfile_fp);
	}
	
	if(val == 9999)
		FULL_REP_MSG(("ROMTOOL: ROM operation terminated with successfully\n"));
	if(val == -9999)
		FULL_REP_MSG(("ROMTOOL: ROM operation terminated with un------successfully\n"));

	exit (val);
}

/*******************************PROC::Flash ID confirm***************************************************
*
* test the flashrom idents                
*
***************************************************************************************************/

BOOL check_idents (void){

	char          s_msg[100];             /* general message_string def'n         */
	char          s_mfri[20];             /* manufacturers_id string def'n        */
	char          s_devi[20];             /* device_id string def'n               */
	char 		  error;

	static volatile USHORT  *ptr_to_b;      /* block_pointer def'n                */
	int  ReturnStatus;
	volatile USHORT OriginalByte;


	error = FALSE;   


	FULL_REP_MSG(("ROMTOOL: Checking FlashROM Identifiers...\n"));
	FULL_LOG_MSG((rom_logfile_fp, "ROMTOOL: Checking FlashROM Identifiers...\n"));

/*************************INTEL Flash  ID check*****************************************************/


	ReturnStatus = 0;
	                     /* reset error value for return         */

	ptr_to_b = (USHORT *)MFGID_ADDR;
	OriginalByte = *ptr_to_b;                   /* save the original memory contents    */		

	*ptr_to_b = 0x0090;               /* write read_ident command             */

	mfr_id = *ptr_to_b;                   /* read mfr_id                          */

	ptr_to_b = (USHORT *)(MFGID_ADDR | 0x00000002);                /* address A0=1  */

	dev_id = *ptr_to_b;

	if ((mfr_id == INTEL_ID) && ((dev_id == INTEL_28F800TL)||(dev_id ==INTEL_28F004BX_TL)||(dev_id ==INTEL_28F004BX_BL)))
		ReturnStatus = 0;
	else
		ReturnStatus = -1;

	if (ReturnStatus ==-1)
		*ptr_to_b = OriginalByte;     

/***************************************************************************************************/	

/*************************AMD Flash  ID check*****************************************************/

	if(ReturnStatus == -1){

		ReturnStatus = 0;

		ptr_to_b  = (USHORT *)MFGID_ADDR;
	    OriginalByte = *ptr_to_b;                   /* save the original memory contents    */
	
		ptr_to_b[0] = 0xF0;                  /* reset tje 28SF040 chip first                */
		
		ptr_to_b[0x555] = 0xAA;
		ptr_to_b[0x2AA] = 0x55;
		ptr_to_b[0x555] = 0x90;		
	
		
		ptr_to_b = (USHORT *)MFGID_ADDR;			
	
		mfr_id = *ptr_to_b;                   /* read mfr_id                          */
	
		ptr_to_b[0] = 0xF0;               
		
		ptr_to_b[0x555] = 0xAA;
		ptr_to_b[0x2AA] = 0x55;
		ptr_to_b[0x555] = 0x90;		
	
		ptr_to_b = (USHORT *)MFGID_ADDR + 1;			
	
		dev_id = *ptr_to_b;
			
		*ptr_to_b = 0xF0;                 
		
		if ((mfr_id == AMD_ID) && (dev_id == AMD_AM29F800))
			ReturnStatus = 0;
		else
			ReturnStatus = -1;
	
	
		if (ReturnStatus ==-1)
			*ptr_to_b = OriginalByte;     
	}
	
/***************************************************************************************************/	
/*************************SST Flash  ID check*****************************************************/
	if(ReturnStatus == -1){

		ReturnStatus = 0;

		ptr_to_b = (USHORT *)MFGID_ADDR;
    	OriginalByte = *ptr_to_b;                   /* save the original memory contents    */		

		*ptr_to_b = 0xFFFF;					/* Setup command */
		*ptr_to_b = 0x9090;               /* write read_ident command             */


		ptr_to_b = (USHORT *)MFGID_ADDR;

		mfr_id = *ptr_to_b;                   /* read mfr_id                          */

		ptr_to_b = (USHORT *)(MFGID_ADDR + 2);                /* address A0=1  */

		dev_id = *ptr_to_b;

		if ((mfr_id == SST_ID) && (dev_id == SST_28SF040))
			ReturnStatus = 0;
		else
			ReturnStatus = -1;

		if (ReturnStatus ==-1)
			*ptr_to_b = OriginalByte;     
	}