sst39vf080.txt

SST 系列Nor flash 的读写源码

        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 = 0x50;                   /* write data 0x50 to the address   */
        Delay_25_Milli_Seconds();       /* Delay time = Tbe                 */
}


/************************************************************************/
/* PROCEDURE:   Erase_Entire_Chip                                       */
/*                                                                      */
/* This procedure can be used to erase the entire chip.                 */
/*                                                                      */
/* Input:                                                               */
/*      NONE                                                            */
/*                                                                      */
/* Output:                                                              */
/*      NONE                                                            */
/************************************************************************/

void Erase_Entire_Chip()
{
        BYTE far *Temp;

        /*  Issue the Chip 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  = (BYTE far *)0xC0005555; /* set up address to be C000:5555h  */
        *Temp = 0x10;                   /* write data 0x10 to the address   */
        Delay_100_Milli_Seconds();      /* Delay Tsce time                  */
}


/************************************************************************/
/* PROCEDURE:   Program_One_Byte                                        */
/*                                                                      */
/* This procedure can be used to program ONE byte of data to the        */
/* 39VF080.                                                             */
/*                                                                      */
/* NOTE:  It is necessary to first erase the sector containing the      */
/*        byte to be programmed.                                	*/
/*                                                                      */
/* Input:                                                               */
/*           Src     The BYTE which will be written to the 39VF080      */
/*           Dst     DESTINATION address which will be written with the */
/*                   data passed in from Src                            */
/*                                                                      */
/* Output:                                                              */
/*           None                                                       */
/************************************************************************/

void Program_One_Byte (BYTE Src, BYTE far *Dst)
{
	BYTE far *Temp;
        BYTE far *DestBuf;

        DestBuf = Dst;

        Temp =  (BYTE far *)0xC0005555; /* set up address to be C000:555h   */
        *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 = 0xA0;                   /* write data 0xA0 to the address   */
        *DestBuf = Src;                 /* transfer the byte to destination */
        Check_Toggle_Ready(DestBuf);    /* wait for TOGGLE bit to get ready */
}


/************************************************************************/
/* PROCEDURE:   Program_One_Sector                                      */
/*                                                                      */
/* This procedure can be used to program a total of 4096 bytes of data  */
/* to the SST39VF080.                                                   */
/*                                                                      */
/* NOTES: 1. It is necessary to first erase the sector before the	*/
/*        programming.                                			*/
/*        2. This sample code assumes the destination address passed	*/
/*        from the calling function is the starting address of the	*/
/*        sector.							*/
/*                                                                      */
/* Input:                                                               */
/*           Src     SOURCE address containing the data which will be   */
/*                   written to the 39VF080                             */
/*           Dst     DESTINATION address which will be written with the */
/*                   data passed in from Src                            */
/*                                                                      */
/* Output:                                                              */
/*           None                                                       */
/************************************************************************/

void Program_One_Sector (BYTE far *Src,    BYTE far *Dst)
{
        BYTE far *SourceBuf;
        BYTE far *DestBuf;
        int Index;

        SourceBuf = Src;
        DestBuf = Dst;

        Erase_One_Sector(Dst);          /* erase the sector first */

        for (Index = 0; Index < SECTOR_SIZE; Index++)
        {
	/* transfer data from source to destination */
	Program_One_Byte( *SourceBuf, DestBuf);
	++DestBuf;
	++SourceBuf;
        }
}


/************************************************************************/
/* PROCEDURE:   Program_One_Block                                       */
/*                                                                      */
/* This procedure can be used to program a total of 64k bytes of data   */
/* to the SST39VF080.                                                   */
/*                                                                      */
/* NOTES: 1. It is necessary to first erase the block before the	*/
/*        programming.                                			*/
/*        2. This sample code assumes the destination address passed	*/
/*        from the calling function is the starting address of the	*/
/*        block.							*/
/*									*/
/* Input:                                                               */
/*           Src     SOURCE address containing the data which will be   */
/*                   written to the 39VF080                             */
/*           Dst     DESTINATION address which will be written with the */
/*                   data passed in from Src                            */
/*                                                                      */
/* Output:                                                              */
/*           None                                                       */
/************************************************************************/

void Program_One_Block (BYTE far *Src,  BYTE far *Dst)
{
        BYTE far *SourceBuf;
        BYTE far *DestBuf;
        int Index;

        SourceBuf = Src;
        DestBuf = Dst;

        Erase_One_Block(Dst);          /* erase the sector first */

        for (Index = 0; Index < BLOCK_SIZE; Index++)
        {
	/* transfer data from source to destination */
	Program_One_Byte( *SourceBuf, DestBuf);
	++DestBuf;
	++SourceBuf;
        }
}


/************************************************************************/
/* PROCEDURE:    Check_Toggle_Ready                                     */
/*                                                                      */
/* During the internal program cycle, any consecutive read operation    */
/* on DQ6 will produce alternating 0's and 1's (i.e. toggling between   */
/* 0 and 1). When the program cycle is completed, DQ6 of the data will  */
/* stop toggling. After the DQ6 data bit stops toggling, the device is  */
/* ready for next operation.                                            */
/*                                                                      */
/* Input:                                                               */
/*           Dst        Must already be set-up by the caller            */
/*                                                                      */
/* Output:                                                              */
/*           None                                                       */
/************************************************************************/

void Check_Toggle_Ready (BYTE far  *Dst)
{
        BYTE Loop = TRUE;
        BYTE PreData;
        BYTE CurrData;
        unsigned long TimeOut = 0;

        PreData = *Dst;
        PreData = PreData & 0x40;
        while ((TimeOut< 0x07FFFFFF) && (Loop))
        {
            CurrData = *Dst;
            CurrData = CurrData & 0x40;
            if (PreData == CurrData)
                    Loop = FALSE;   /* ready to exit the while loop */
            PreData = CurrData;
            TimeOut++;
        }
}


/************************************************************************/
/* PROCEDURE:   Check_Data_Polling                                      */
/*                                                                      */
/* During the internal program cycle, any attempt to read DQ7 of the    */
/* last byte loaded during the page/byte-load cycle will receive the    */
/* complement of the true data.  Once the program cycle is completed,   */
/* DQ7 will show true data.                                             */
/*                                                                      */
/* Input:                                                               */
/*           Dst        Must already be set-up by the caller            */
/*           True       Data is the original (true) data                */
/*                                                                      */
/* Output:                                                              */
/*           None                                                       */
/************************************************************************/

void Check_Data_Polling (BYTE far  *Dst,  BYTE TrueData)
{
        BYTE Loop = TRUE;
        BYTE CurrData;
        unsigned long TimeOut = 0;

        TrueData = TrueData &  0x80;
        while ((TimeOut< 0x07FFFFFF) && (Loop))
        {
                CurrData = *Dst;
                CurrData = CurrData & 0x80;
                if (TrueData == CurrData)
                        Loop = FALSE;   /* ready to exit the while loop  */
                TimeOut++;
        }
}