/***************************************************************************************************Software DriverSST39VF6401/SST39VF640264 Mbit Multi-Purpose Flash (MPF+)June 2003 ABOUT THE SOFTWAREThis application note provides a software driver example for 39VF6401/39VF640264 Mbit Multi-Purpose Flash (MPF+) that can be used in any microprocessor basedsystem.The SST39VF6401 supports bottom boot block protection, and the SST39VF6402 supports top boot block protection. The boot block memory area is protected when WP# is low and unprotected when WP# is high.Software driver example routines provided in this document utilize high-level"C" programming language for broad platform support. In many cases, software driver routines can be inserted "as is" into the main body of code being developed by the system software developers. Extensive comments are included in each routine to describe the function of each routine. The software driver routines in "C" can be used with many microprocessors and microcontrollers. ABOUT THE SST39VF6401/SST39VF6402Companion product datasheet for 39VF6401/39VF6402 should be reviewed in conjunction with this application note for a complete understanding of the device.The C code in this document contains the following routines, which are listedin this order:Name                    Function------------------------------------------------------------------Check_SST_39VF640X      Check manufacturer and device IDCFI_Query               CFI Query Entry/Exit command sequenceSecID_Query		SecID Query Entry/Exit command sequenceErase_One_Sector        Erase a sector of 2048 wordsErase_One_Block         Erase a block of 32K wordsErase_Entire_Chip       Erase the contents of the entire chipProgram_One_Word        Alter data in one wordProgram_One_Sector      Alter data in 2048-word sectorProgram_One_Block       Alter data in 32K-word blockSecID_Lock_Status	Check the Lock Status of Security ID segmentUser_SecID_Word_Program Write data into User Security ID SegmentUser_SecID_Lock_Out 	Lock out the User Security ID SegmentErase_Suspend		Suspend Sector/Block Erase operationErase_Resume		Resume Sector/Block Erase operationCheck_Toggle_Ready      End of internal program or erase detection using                        Toggle bitCheck_Data_Polling      End of internal program or erase detection using                        Data# polling"C" LANGUAGE DRIVERS*************************************************************************************************//***********************************************************************//* Copyright Silicon Storage Technology, Inc. (SST), 1994-2003         *//* Example "C" language Driver of 39VF640X 64 Mbit MPF+ Device	       *//* Jerry Deng, Silicon Storage Technology, Inc.                        *//*                                                                     *//* Revision 1.0, June 19, 2003                                         *//*                                                                     *//* This file requires these external "timing"  routines:               *//*                                                                     *//*      1.)  Delay_10_Micro_Seconds                                    *//*      2.)  Delay_20_Micro_Seconds                                    *//*      3.)  Delay_150_Nano_Seconds                                    *//*      4.)  Delay_25_Milli_Seconds                                    *//*      5.)  Delay_50_Milli_Seconds                                    *//***********************************************************************/#define FALSE                   0#define TRUE                    1#define SECTOR_SIZE             2048    // Must be 2048 words for 39VF640X#define BLOCK_SIZE              32768   // Must be 32K words for 39VF640X#define SST_ID                  0x00BF  // SST Manufacturer's ID code#define SST_39VF6401            0x236B  // SST39VF6401 device code#define SST_39VF6402            0x236A  // SST39VF6402 device codetypedef unsigned char           BYTE;     // BYTE is 8-bit in lengthtypedef unsigned int            WORD;     // WORD is 16-bit in lengthtypedef unsigned long int       Uint32;   // Uint32 is 32-bit in lengthUint32 system_base = 0xC0000000;  // 4GByte System Memory Address.	// This sample code uses 0xC0000000 as the system_base address.   	// The user should modify this address accordingly.#define sysAddress(offset) ((volatile WORD *)(system_base + offset))#define MAX_TIMEOUT	0x07FFFFFF   // A ceiling constant used by Check_Toggle_	// Ready() and Check_Data_Polling().      	// The user should modify this constant accordingly.// --------------------------------------------------------------------//                       EXTERNAL ROUTINES// --------------------------------------------------------------------extern void     Delay_10_Micro_Seconds();extern void     Delay_20_Micro_Seconds();extern void     Delay_150_Nano_Seconds();extern void     Delay_25_Milli_Seconds();extern void     Delay_50_Milli_Seconds();// --------------------------------------------------------------------int Check_SST_39VF640X(void);void CFI_Query(WORD*);void SecID_Query(WORD*, WORD*);int Erase_One_Sector(Uint32);int Erase_One_Block (Uint32);void Erase_Entire_Chip(void);int Program_One_Word (WORD*, Uint32);int Program_One_Sector (WORD*, Uint32);int Program_One_Block (WORD *Src, Uint32 Dst);int SecID_Lock_Status(void);int User_SecID_Word_Program (WORD*, WORD*, int);void User_SecID_Lock_Out (void);void Erase_Suspend (void);void Erase_Resume (void);int Check_Toggle_Ready (Uint32);int Check_Data_Polling (Uint32, WORD);/************************************************************************//* PROCEDURE:   Check_SST_39VF640X                                      *//*                                                                      *//* This procedure decides whether a physical hardware device has a      *//* SST39VF640X 64 Mbit MPF+ Device installed or not.         		*//*                                                                      *//* Input:                                                               *//*          None                                                        *//*                                                                      *//* Output:                                                              *//*          return TRUE:  indicates a SST39VF640X                       *//*          return FALSE: indicates not a SST39VF640X                   *//************************************************************************/int Check_SST_39VF640X(void){    WORD SST_id1;    WORD SST_id2;    int  ReturnStatus;    //  Issue the Software Product ID code to 39VF640X    *sysAddress(0x5555) = 0x00AA;  // write data 0x00AA to device addr 0x5555    *sysAddress(0x2AAA) = 0x0055;  // write data 0x0055 to device addr 0x2AAA    *sysAddress(0x5555) = 0x0090;  // write data 0x0090 to device addr 0x5555    Delay_150_Nano_Seconds();   // Tida Max 150ns for 39VF640X    // Read the product ID from 39VF640X    SST_id1  = *sysAddress(0x0000);   // get first ID byte    SST_id2  = *sysAddress(0x0001);   // get second ID byte    // ------------------------------------------------------------    // Determine whether there is a SST 39VF6401 installed or not    // use the following code:    if ((SST_id1 == SST_ID) && (SST_id2 == SST_39VF6401))            ReturnStatus = TRUE;    else            ReturnStatus = FALSE;    // ------------------------------------------------------------    // Or determine whether there is a SST 39VF6402 installed or not    // use the following code:         if ((SST_id1 == SST_ID) && (SST_id2 == SST_39VF6402))            ReturnStatus = TRUE;    else            ReturnStatus = FALSE;    // ------------------------------------------------------------    // Issue the Software Product ID Exit code, thus returning the    // 39VF640X to the normal operation.    *sysAddress(0x5555) = 0x00AA;  // write data 0x00AA to device addr 0x5555    *sysAddress(0x2AAA) = 0x0055;  // write data 0x0055 to device addr 0x2AAA    *sysAddress(0x5555) = 0x00F0;  // write data 0x00F0 to device addr 0x5555    Delay_150_Nano_Seconds();   // Tida Max 150ns for 39VF640X                                        return (ReturnStatus);}/************************************************************************//* PROCEDURE:   CFI_Query                                               *//*                                                                      *//* This procedure should be used to query for CFI information           *//*                                                                      *//* Input:                                                               *//*          Src	Source address to store CFI_Query data string		*//*                                                                      *//* Output:                                                              *//*          None                                                        *//************************************************************************/void CFI_Query(WORD *Src){     //  Issue the CFI Query entry code to 39VF640X    *sysAddress(0x5555) = 0x00AA;  // write data 0x00AA to device addr 0x5555    *sysAddress(0x2AAA) = 0x0055;  // write data 0x0055 to device addr 0x2AAA    *sysAddress(0x5555) = 0x0098;  // write data 0x0098 to device addr 0x5555    Delay_150_Nano_Seconds();     // insert delay time = Tida    // ----------------------------------------------------------    //  Perform all CFI operations here:    //  CFI_Query_address is from 0010H--0034H    for (WORD index = 0x0010; index <= 0x0034; index++)    {     	 *Src = *sysAddress(index);         ++Src;	// CFI query data is stored in user-defined memory space.    }    // ----------------------------------------------------------        // Issue the CFI Exit code thus returning the 39VF640X        // to the read operating mode    *sysAddress(0x5555) = 0x00AA;  // write data 0x00AA to device addr 0x5555    *sysAddress(0x2AAA) = 0x0055;  // write data 0x0055 to device addr 0x2AAA    *sysAddress(0x5555) = 0x00F0;  // write data 0x00F0 to device addr 0x5555    Delay_150_Nano_Seconds();     // insert delay time = Tida}/************************************************************************//* PROCEDURE:   SecID_Query                                             *//*                                                                      *//* This procedure should be used to query for Security ID information.  *//*                                                                      *//* Input:                                                               *//*          SST_SecID	Source address to store SST SecID string	*//*          User_SecID	Source address to store User SecID string	*//*                                                                      *//* Output:                                                              *//*          None                                                        *//************************************************************************/void SecID_Query(WORD *SST_SecID, WORD *User_SecID){