Software DriverSST39VF0808 Mbit Multi-Purpose FlashMay 2003ABOUT THE SOFTWAREThis application note provides a software driver example for 39VF080 8 Mbit Multi-Purpose Flash, that can be used in any microprocessor based system. 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 SST39VF080Companion product datasheet for the 39VF080 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_39VF080       Check manufacturer and device IDCFI_Query               CFI Query Entry/Exit command sequenceErase_One_Sector        Erase a sector of 4096 bytesErase_One_Block         Erase a block of 64K bytesErase_Entire_Chip       Erase the contents of the entire chipProgram_One_Byte        Alter data in one byteProgram_One_Sector      Alter data in 4096 byte sectorProgram_One_Block       Alter data in 64K byte blockCheck_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 39VF080 8 Mbit Multi-Purpose Flash   *//* Nelson Wang, Silicon Storage Technology, Inc.                       *//*                                                                     *//* Revision 1.0, May 28, 2003                                          *//*                                                                     *//* This file requires these external "timing"  routines:               *//*                                                                     *//*      1.)  Delay_150_Nano_Seconds                                    *//*      2.)  Delay_25_Milli_Seconds                                    *//*      3.)  Delay_100_Milli_Seconds                                   *//***********************************************************************/#define FALSE                   0#define TRUE                    1#define SECTOR_SIZE             4096    /* Must be 4096 bytes for 39VF080 */#define BLOCK_SIZE              65536   /* Must be 64K bytes for 39VF080  */#define SST_ID                  0xBF  	/* SST Manufacturer's ID code  */#define SST_39VF080             0xD8  	/* SST39VF080 device code      */                                        typedef unsigned char           BYTE;typedef unsigned int            WORD;/* -------------------------------------------------------------------- *//*                       EXTERNAL ROUTINES                              *//* -------------------------------------------------------------------- */extern void     Delay_150_Nano_Seconds();extern void     Delay_25_Milli_Seconds();extern void     Delay_100_Milli_Seconds();/************************************************************************//* PROCEDURE:   Check_SST_39VF080                                       *//*                                                                      *//* This procedure decides whether a physical hardware device has a      *//* SST39VF080 8 Mbit Multi-Purpose Flash installed or not.              *//*                                                                      *//* Input:                                                               *//*          None                                                        *//*                                                                      *//* Output:                                                              *//*          return TRUE:  indicates a SST39VF080                        *//*          return FALSE: indicates not a SST39VF080                    *//************************************************************************/int Check_SST_39VF080()              {        BYTE far *Temp;        BYTE SST_id1;        BYTE far *Temp1;        BYTE SST_id2;        int  ReturnStatus;        /*  Issue the Software Product ID code to 39VF080   */        Temp1 = (BYTE far *)0xC0005555; /* set up address to be C000:5555h  */        *Temp1= 0xAA;                   /* write data 0xAA to the address   */        Temp1 = (BYTE far *)0xC0002AAA; /* set up address to be C000:2AAAh  */        *Temp1= 0x55;                   /* write data 0x55 to the address   */        Temp1 = (BYTE far *)0xC0005555; /* set up address to be C000:5555h  */        *Temp1= 0x90;                   /* write data 0x90 to the address   */        Delay_150_Nano_Seconds();       /* insert delay time = Tida         */        /* Read the product ID from 39VF080 */        Temp  = (BYTE far *)0xC0000000; /* set up address to be C000:0000h */        SST_id1  =  *Temp;              /* get first ID byte               */        SST_id1  =  SST_id1 & 0x00FF;   /* mask of higher byte             */        Temp1 = (BYTE far *)0xC0000001; /* set up address to be C000:0001h */        SST_id2  =  *Temp1;             /* get second ID byte              */        /* Determine whether there is a SST39VF080 installed or not */        if ((SST_id1 == SST_ID) && (SST_id2 ==SST_39VF080))                ReturnStatus = TRUE;        else                ReturnStatus = FALSE;        /* Issue the Soffware Product ID Exit code thus returning the 39VF080 */        /* to the read operating mode                                         */        Temp1  = (BYTE far *)0xC0005555; /* set up address to be C000:5555h   */        *Temp1 = 0xAA;                   /* write data 0xAA to the address    */        Temp1  = (BYTE far *)0xC0002AAA; /* set up address to be C000:2AAAh   */        *Temp1 = 0x55;                   /* write data 0x55 to the address    */        Temp1  = (BYTE far *)0xC0005555; /* set up address to be C000:5555h   */        *Temp1 = 0xF0;                   /* write data 0xF0 to the address    */        Delay_150_Nano_Seconds();        /* insert delay time = Tida          */        return(ReturnStatus);}/************************************************************************//* PROCEDURE:   CFI_Query                                               *//*                                                                      *//* This procedure should be used to query for CFI information           *//*                                                                      *//* Input:                                                               *//*          None                                                        *//*                                                                      *//* Output:                                                              *//*          None                                                        *//************************************************************************/void CFI_Query(){        BYTE far *Temp1;        /*  Issue the Software Product ID code to 39VF080   */        Temp1 = (BYTE far *)0xC0005555; /* set up address to be C000:5555h    */        *Temp1= 0xAA;                   /* write data 0xAA to the address     */        Temp1 = (BYTE far *)0xC0002AAA; /* set up address to be C000:2AAAh    */        *Temp1= 0x55;                   /* write data 0x55 to the address     */        Temp1 = (BYTE far *)0xC0005555; /* set up address to be C000:5555h    */        *Temp1= 0x98;                   /* write data 0x98 to the address     */        Delay_150_Nano_Seconds();       /* insert delay time = Tida           */        /* --------------------------------- */        /*  Perform all CFI operations here  */        /*  NOTE:  no sample code provided   */        /* --------------------------------- */        /* Issue the CFI Exit code thus returning the 39VF080 */        /* to the read operating mode                          */        Temp1  = (BYTE far *)0xC0005555; /* set up address to be C000:5555h   */        *Temp1 = 0xAA;                   /* write data 0xAA to the address    */        Temp1  = (BYTE far *)0xC0002AAA; /* set up address to be C000:2AAAh   */        *Temp1 = 0x55;                   /* write data 0x55 to the address    */        Temp1  = (BYTE far *)0xC0005555; /* set up address to be C000:5555h   */        *Temp1 = 0xF0;                   /* write data 0xF0 to the address    */        Delay_150_Nano_Seconds();        /* insert delay time = Tida          */}/************************************************************************//* PROCEDURE:   Erase_One_Sector                                        *//*                                                                      *//* This procedure can be used to erase a total of 4096 bytes.           *//*                                                                      *//* Input:                                                               *//*      Dst     DESTINATION address where the erase operation starts    *//*                                                                      *//* Output:                                                              *//*      NONE                                                            *//************************************************************************/void Erase_One_Sector (BYTE far *Dst){        BYTE far *Temp;        /*  Issue the Sector Erase command to 39VF080  */        Temp  = (BYTE far *)0xC0005555; /* set up address to be C000:5555h  */        *Temp = 0xAA;                   /* write data 0xAA to the address   */        Temp  = (BYTE far *)0xC0002AAA; /* set up address to be C000:2AAAh  */        *Temp = 0x55;                   /* write data 0x55 to the address   */        Temp  = (BYTE far *)0xC0005555; /* set up address to be C000:5555h  */        *Temp = 0x80;                   /* write data 0x80 to the address   */        Temp  = (BYTE far *)0xC0005555; /* set up address to be C000:5555h  */        *Temp = 0xAA;                   /* write data 0xAA to the address   */        Temp  = (BYTE far *)0xC0002AAA; /* set up address to be C000:2AAAh  */        *Temp = 0x55;                   /* write data 0x55 to the address   */        Temp  = Dst;                  /* set up starting address to be erased */        *Temp = 0x30;                   /* write data 0x30 to the address   */        Delay_25_Milli_Seconds();       /* Delay time = Tse                 */}/************************************************************************//* PROCEDURE:   Erase_One_Block                                         *//*                                                                      *//* This procedure can be used to erase a total of 64K words.            *//*                                                                      *//* Input:                                                               *//*      Dst     DESTINATION address where the erase operation starts    *//*                                                                      *//* Output:                                                              *//*      NONE                                                            *//************************************************************************/void Erase_One_Block (BYTE far *Dst){        BYTE far *Temp;        /*  Issue the Sector Erase command to 39VF080  */