sst39vf3201.c

SST flash driver,已经经过测试

/************************************************************************/
/* PROCEDURE:   Erase_One_Sector                                        */
/*                                                                      */
/* This procedure can be used to erase a total of 2048 words.           */
/*                                                                      */
/* Input:                                                               */
/*      Dst     DESTINATION address of sector to be erased              */
/*                                                                      */
/* Output:                                                              */
/*          return TRUE:  indicates success in sector-erase             */
/*          return FALSE: indicates timeout in sector-erase             */
/************************************************************************/
BYTE Erase_One_Sector(DWORD Dst)
{
    BYTE    ReturnStatus=TRUE;

	*(WORD *) (BaseAddrs + 0x5555 * AddrsShift) = 0x00AA;     // 1st write data 0x00AA to device addr 5555H
	*(WORD *) (BaseAddrs + 0x2AAA * AddrsShift) = 0x0055;     // 2nd write data 0x0055 to device addr 2AAAH
	*(WORD *) (BaseAddrs + 0x5555 * AddrsShift) = 0x0080;     // 3rd write data 0x0080 to device addr 5555H
	*(WORD *) (BaseAddrs + 0x5555 * AddrsShift) = 0x00AA;     // 4th write data 0x00AA to device addr 5555H
	*(WORD *) (BaseAddrs + 0x2AAA * AddrsShift) = 0x0055;     // 5th write data 0x0055 to device addr 2AAAH
	*(WORD *) (BaseAddrs +    Dst * AddrsShift) = 0x0030;     // 6th write data 0x0030 to device sector addr Dst
//  ReturnStatus = Check_Toggle_Ready(Dst,SectorEraseTime);	         // wait TOGGLE bit stops toggling
    ReturnStatus = Check_Data_Polling(Dst, 0xFFFF, SectorEraseTime); // wait until DQ7 outputs 1
    return ReturnStatus;
}


/************************************************************************/
/* PROCEDURE:   Erase_One_Block                                         */
/*                                                                      */
/* This procedure can be used to erase a total of 32K words.            */
/*                                                                      */
/* Input:                                                               */
/*      Dst     DESTINATION address where the erase operation starts    */
/*                                                                      */
/* Output:                                                              */
/*          return TRUE:  indicates success in block-erase              */
/*          return FALSE: indicates timeout in block-erase              */
/************************************************************************/
BYTE Erase_One_Block (DWORD Dst)
{
    BYTE  ReturnStatus=TRUE;

	*(WORD *) (BaseAddrs + 0x5555 * AddrsShift) = 0x00AA;     // 1st write data 0x00AA to device addr 5555H
	*(WORD *) (BaseAddrs + 0x2AAA * AddrsShift) = 0x0055;     // 2nd write data 0x0055 to device addr 2AAAH
	*(WORD *) (BaseAddrs + 0x5555 * AddrsShift) = 0x0080;     // 3rd write data 0x0080 to device addr 5555H
	*(WORD *) (BaseAddrs + 0x5555 * AddrsShift) = 0x00AA;     // 4th write data 0x00AA to device addr 5555H
	*(WORD *) (BaseAddrs + 0x2AAA * AddrsShift) = 0x0055;     // 5th write data 0x0055 to device addr 2AAAH
	*(WORD *) (BaseAddrs +   Dst  * AddrsShift) = 0x0050;     // 6th write data 0x0050 to device sector addr Dst

    ReturnStatus = Check_Toggle_Ready(Dst, BlockEraseTime);	         // wait TOGGLE bit stops toggling
//  ReturnStatus = Check_Data_Polling(Dst, 0xFFFF, BlockEraseTime);  // wait until DQ7 outputs 1
    return ReturnStatus;
}


/************************************************************************/
/* PROCEDURE:   Erase_Entire_Chip                                       */
/*                                                                      */
/* This procedure can be used to erase the entire chip.                 */
/*                                                                      */
/* Input:                                                               */
/*      NONE                                                            */
/*                                                                      */
/* Output:                                                              */
/*          return TRUE:  indicates success in block-erase              */
/*          return FALSE: indicates timeout in block-erase              */
/************************************************************************/
BYTE Erase_Entire_Chip(void)
{
    BYTE  ReturnStatus=TRUE;

	*(WORD *) (BaseAddrs + 0x5555 * AddrsShift) = 0x00AA;     // write data 0x00AA to device addr 5555H
	*(WORD *) (BaseAddrs + 0x2AAA * AddrsShift) = 0x0055;     // write data 0x0055 to device addr 2AAAH
	*(WORD *) (BaseAddrs + 0x5555 * AddrsShift) = 0x0080;     // write data 0x0080 to device addr 5555H
	*(WORD *) (BaseAddrs + 0x5555 * AddrsShift) = 0x00AA;     // write data 0x00AA to device addr 5555H
	*(WORD *) (BaseAddrs + 0x2AAA * AddrsShift) = 0x0055;     // write data 0x0055 to device addr 2AAAH
	*(WORD *) (BaseAddrs + 0x5555 * AddrsShift) = 0x0010;     // write data 0x0010 to device addr 5555H
    ReturnStatus = Check_Toggle_Ready(0, ChipEraseTime);        // wait TOGGLE bit stops toggling
//  ReturnStatus = Check_Data_Polling(0, 0xFFFF, ChipEraseTime);// wait until DQ7 outputs 1
    return ReturnStatus;
}


/************************************************************************/
/* PROCEDURE:   Program_One_Word                                        */
/*                                                                      */
/* This procedure programs one word of data into SST39VF320X.           */
/*                                                                      */
/* NOTE:  It is necessary to first erase the sector containing the      */
/*        word to be programmed.                                    	*/
/*                                                                      */
/* Input:                                                               */
/*           SrcWord data word to be written into SST39VF320X.          */
/*           Dst     DESTINATION address where to be written into.      */
/*                                                                      */
/* Output:                                                              */
/*          return TRUE:  indicates success in word-program             */
/*          return FALSE: indicates timeout in word-program             */
/************************************************************************/
BYTE Program_One_Word (WORD SrcWord, DWORD Dst)
{
    BYTE  ReturnStatus=TRUE;

    *(WORD *) (BaseAddrs + 0x5555 * AddrsShift) = 0x00AA;  // 1st write data 0x00AA to device addr 5555H
    *(WORD *) (BaseAddrs + 0x2AAA * AddrsShift) = 0x0055;  // 2nd write data 0x0055 to device addr 2AAAH
    *(WORD *) (BaseAddrs + 0x5555 * AddrsShift) = 0x00A0;  // 3rd write data 0x00A0 to device addr 5555H
    *(WORD *) (BaseAddrs +   Dst  * AddrsShift) = SrcWord; // 4th write data word into destination address Dst
    ReturnStatus = Check_Toggle_Ready(Dst, WordProgramTime);           // wait TOGGLE bit stops toggling
//  ReturnStatus = Check_Data_Polling(Dst, SrcWord, WordProgramTime);  // wait until DQ7 outputs true data
    return ReturnStatus;
}

/************************************************************************/
/* PROCEDURE:   SecID_Lock_Status                                       */
/*                                                                      */
/* This procedure should be used to check the Lock Status of SecID	*/
/*                                                                      */
/* Input:                                                               */
/*          None                                                        */
/*                                                                      */
/* Output:                                                              */
/*          return TRUE:  indicates SecID is Locked  		            */
/*          return FALSE: indicates SecID is not locked	            */
/************************************************************************/
BYTE SecID_Lock_Status(void)
{
    WORD SecID_Status;

//  Issue the Sec ID Entry code to 39VF320X
    *(WORD *) (BaseAddrs + 0x5555 * AddrsShift) = 0x00AA;  // 1st write data 0x00AA to device addr 5555H
    *(WORD *) (BaseAddrs + 0x2AAA * AddrsShift) = 0x0055;  // 2nd write data 0x0055 to device addr 2AAAH
    *(WORD *) (BaseAddrs + 0x5555 * AddrsShift) = 0x0088;  // 3rd write data 0x0088 to device addr 5555H
    Delay_150_Nano_Seconds();                              // insert delay time = Tida

//  Read Lock Status of SecID segment
    SecID_Status = *(WORD *) (BaseAddrs+ 0xFF * AddrsShift );   // Lock Status address at 0000FFh
    SecID_Status &= 0x0008;                                     // get data bit DQ3 only

// Issue Sec ID Exit code for SST39VF320X to return to read mode.
    *(WORD *) (BaseAddrs + 0x5555 * AddrsShift) = 0x00AA;  // 1st write data 0x00AA to device addr 5555H
    *(WORD *) (BaseAddrs + 0x2AAA * AddrsShift) = 0x0055;  // 2nd write data 0x0055 to device addr 2AAAH
    *(WORD *) (BaseAddrs + 0x5555 * AddrsShift) = 0x00F0;  // 3rd write data 0x00F0 to device addr 5555H
    Delay_150_Nano_Seconds();                              // insert delay time = Tida

    if (!SecID_Status)
   	     return TRUE;	        	                       // SecID segment is Locked
    else return FALSE;   		                       // SecID segment is NOT locked
}


/************************************************************************/
/* PROCEDURE:   User_SecID_Word_Program                                 */
/*                                                                      */
/* This procedure can be used to program data into the User SecID       */
/* segment (from 000010H--000017H) in SST39VF320X.          	 	*/
/*                                                                      */
/* NOTE:                                                                */
/*  1. Before run this subroutine, call above SecID_Lock_Status( )to    */
/*     make sure User SecID segment is not locked.                      */
/*  2. It's recommended to lock out the SecID segment after programming.*/
/*  3. There's no way to unlock the SecID segment once it's	locked.     */
/*  4. Call SecID_Query(WORD *SST_SecID, WORD *User_SecID) to read back */
/*     all programmed data in order to verify if they match.            */
/*                                                                      */
/* Input:                                                               */
/*   *SrcWord  pointer to source data			                  */
/*   Dst       Must be address in User Sec ID from 000010h to 000017h.  */
/*   length    number of word needs to be programmed		            */
/*                                                                      */
/* Output:                                                              */
/*          TRUE  for successful programming.                           */
/*          FALSE for timeout error or invalid parameter Dst or length. */
/************************************************************************/
BYTE User_SecID_Word_Program (WORD *SrcWord, DWORD Dst, BYTE length)
{
    BYTE  ReturnStatus=TRUE;
	if (Dst<0x10 || Dst>0x17 ) return FALSE;
	if (length>8 || (Dst+length)>0x17) return FALSE;