sst36vf1601c_x16mode.cpp

SST公司

/* Input:   *CFI  A pointer to store CFI data string (total 37 words).	*/
/*                                                                      */
/* Output:  The pointer points to CFI data string.                      */
/************************************************************************/
void QueryCFI_FromBank2(WORD *CFI)
{ 
//  Issue the CFI Query Entry command to SST36VF1601C
    *(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0xAA;            // 1st write data 0xAA to device addr 5555H for A14 to A0
    *(WORD *) (BaseAddrs + 0x2AAA*AddrsShift) = 0x55;            // 2nd write data 0x55 to device addr 2AAAH for A14 to A0
    *(WORD *) (BaseAddrs + (0x5555 + Bank2)*AddrsShift) = 0x98;  // 3rd write data 0x98 to device addr 5555H for A14 to A0
    Delay_150_Nanoseconds( );                                    // delay Tida (150ns)

//  retrieve all CFI data string from EVEN ADDRESS between 180010H and 180034H.
    for (BYTE i=0x10; i<=0x34; CFI++, i++)
     	 *CFI = *(WORD *) (BaseAddrs + (i + Bank2)*AddrsShift);  // save CFI data into user-defined pointer. 

//  Before exit CFI Query mode, all subsequent read with address within Bank 1 will return 
//	data in Bank 1 array, rather than CFI string.
//	For example, next read will return data at address 000020h and 000022h, not CFI string.
//	WORD ReadBank1;
//	ReadBank1 = *(WORD *) (BaseAddrs + 0x20*AddrsShift);  // read data at address 000020h in Bank 1 array
//  ReadBank1 = *(WORD *) (BaseAddrs + 0x22*AddrsShift);  // read data at address 000022h in Bank 1 array

// Issue CFI Exit command to return SST36VF1601C to read mode.

    *(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0xAA;  // 1st write data 0xAA to device addr 5555H for A14 to A0
    *(WORD *) (BaseAddrs + 0x2AAA*AddrsShift) = 0x55;  // 2nd write data 0x55 to device addr 2AAAH for A14 to A0
    *(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0xF0;  // 3rd write data 0xF0 to device addr 5555H for A14 to A0
    Delay_150_Nanoseconds( );                          // insert delay time = Tida
}

/************************************************************************/
/* PROCEDURE:   Query_SecID                                             */
/*                                                                      */
/* This procedure queries both SST Security ID and User Security ID.    */
/*                                                                      */
/* Input:  *SST_SecID	pointer to store SST SecID string (8 words).    */
/*         *User_SecID	pointer to store User SecID string(8 words).    */
/*                                                                      */
/* Output:  pointer SST_SecID points to SST security ID                 */
/*          pointer User_SecID points to User security ID               */
/************************************************************************/
void Query_SecID(WORD *SST_SecID, WORD *User_SecID)
{
//  Issue Query SecID command to SST36VF1601C
    *(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0xAA;  // 1st write data 0xAA to device addr 5555H for A14 to A0
    *(WORD *) (BaseAddrs + 0x2AAA*AddrsShift) = 0x55;  // 2nd write data 0x55 to device addr 2AAAH for A14 to A0
    *(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0x88;  // 3rd write data 0x88 to device addr 5555H for A14 to A0
    Delay_150_Nanoseconds( );                          // insert delay time = Tida
//  read all Security ID information:
//  SST  Security ID is from address 000000H to 000007H,
// 	User Security ID is from address 000010H to 000017H.
 
    for (BYTE i=0; i<8; i++)
    {  	 *SST_SecID = *(WORD *) (BaseAddrs + i*AddrsShift);  // read & save SST Security ID
         ++SST_SecID;                                        // point to next WORD

         *User_SecID = *(WORD *) (BaseAddrs + (i + 0x10)*AddrsShift);  // read & save User Security ID
         ++User_SecID;								                   // point to next WORD
    }    

//  Issue Sec ID Exit command to return SST36VF1601C to read mode
    *(WORD *) (BaseAddrs + 0x12345*AddrsShift) = 0xF0;  // writing F0h into any address such as 12345h
    Delay_150_Nanoseconds( );                           // insert delay time = Tida
}

/************************************************************************/
/* PROCEDURE:   Program_One_Word                                        */
/*                                                                      */
/* This procedure programs one WORD of data into SST36VF1601C.          */
/*                                                                      */
/* NOTE:  Prior to being programmed, the WORD must be blank (FFh) state.*/
/*                                                                      */
/* Input:    SrcWord   Data WORD to be written into SST36VF1601C.       */
/*           Dst       DeSTination address where to be written into.    */
/*                                                                      */
/* Output:  TRUE if success, otherwise FALSE if timeout.                */
/************************************************************************/
BYTE Program_One_Word(WORD SrcWord, U32 Dst)
{
    BYTE  ReturnStatus=TRUE;

    *(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0xAA;    // 1st write data 0xAA to device addr 5555H for A14 to A0
    *(WORD *) (BaseAddrs + 0x2AAA*AddrsShift) = 0x55;    // 2nd write data 0x55 to device addr 2AAAH for A14 to A0
    *(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0xA0;    // 3rd write data 0xA0 to device addr 5555H for A14 to A0
    *(WORD *) (BaseAddrs +    Dst*AddrsShift) = SrcWord; // 4th write data WORD into destination address Dst
//  Then there are three ways to determine when internal operation will be ready:
//  First check DQ6, Secondly check DQ7, Lastly delay 10us.
    ReturnStatus = Check_ToggleDQ6(Dst, WordProgramTime);                // wait TOGGLE bit stops toggling
//  ReturnStatus = Check_DataPollingDQ7(Dst, SrcWord, WordProgramTime);  // wait until DQ7 outputs true data
    return ReturnStatus;
}

/************************************************************************/
/* PROCEDURE:   Erase_One_Sector                                        */
/*                                                                      */
/* This procedure erases a sector of 2KWORD.                            */
/*                                                                      */
/* Input:   Dst     DESTINATION address of sector to be erased.         */
/*                                                                      */
/* Output:  TRUE if success, otherwise FALSE if timeout.                */
/************************************************************************/
BYTE Erase_One_Sector(U32 Dst)
{
    BYTE    ReturnStatus=TRUE;

	*(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0xAA;     // 1st write data 0xAA to device addr 5555H for A14 to A0
	*(WORD *) (BaseAddrs + 0x2AAA*AddrsShift) = 0x55;     // 2nd write data 0x55 to device addr 2AAAH for A14 to A0
	*(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0x80;     // 3rd write data 0x80 to device addr 5555H for A14 to A0
	*(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0xAA;     // 4th write data 0xAA to device addr 5555H for A14 to A0
	*(WORD *) (BaseAddrs + 0x2AAA*AddrsShift) = 0x55;     // 5th write data 0x55 to device addr 2AAAH for A14 to A0
	*(WORD *) (BaseAddrs +    Dst*AddrsShift) = 0x30;     // 6th write data 0x30 to device sector addr Dst
//  Then there are three ways to determine when internal operation will be ready:
//  First check DQ6, Secondly check DQ7, Lastly delay 25ms.
//  ReturnStatus = Check_ToggleDQ6(Dst,SectorEraseTime);	             // wait TOGGLE bit stops toggling
    ReturnStatus = Check_DataPollingDQ7(Dst, 0xFFFF, SectorEraseTime);   // wait until DQ7 outputs 1
    return ReturnStatus;
}


/************************************************************************/
/* PROCEDURE:   Erase_One_Block                                         */
/*                                                                      */
/* This procedure erases a block of 32KWORD.                            */
/*                                                                      */
/* Input:   Dst     DESTINATION address of block to be erased.          */
/*                                                                      */
/* Output:  TRUE if success, otherwise FALSE if timeout.                */
/************************************************************************/
BYTE Erase_One_Block(U32 Dst)
{
    BYTE  ReturnStatus=TRUE;

	*(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0xAA;     // 1st write data 0xAA to device addr 5555H for A14 to A0
	*(WORD *) (BaseAddrs + 0x2AAA*AddrsShift) = 0x55;     // 2nd write data 0x55 to device addr 2AAAH for A14 to A0
	*(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0x80;     // 3rd write data 0x80 to device addr 5555H for A14 to A0
	*(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0xAA;     // 4th write data 0xAA to device addr 5555H for A14 to A0
	*(WORD *) (BaseAddrs + 0x2AAA*AddrsShift) = 0x55;     // 5th write data 0x55 to device addr 2AAAH for A14 to A0
	*(WORD *) (BaseAddrs +    Dst*AddrsShift) = 0x50;     // 6th write data 0x50 to device sector addr Dst
//  Then there are three ways to determine when internal operation will be ready:
//  First check DQ6, Secondly check DQ7, Lastly delay 25ms.
    ReturnStatus = Check_ToggleDQ6(Dst, BlockEraseTime);	           // wait TOGGLE bit stops toggling
//  ReturnStatus = Check_DataPollingDQ7(Dst, 0xFFFF, BlockEraseTime);  // wait until DQ7 outputs 1
    return ReturnStatus;
}


/************************************************************************/
/* PROCEDURE:   Erase_Entire_Chip                                       */
/*                                                                      */
/* This procedure erases the entire chip.                               */
/*                                                                      */
/* Input:   NONE.                                                       */
/*                                                                      */
/* Output:  TRUE if success, otherwise FALSE if timeout.                */
/************************************************************************/
BYTE Erase_Entire_Chip(void)
{
    BYTE  ReturnStatus=TRUE;

	*(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0xAA;     // write data 0xAA to device addr 5555H for A14 to A0
	*(WORD *) (BaseAddrs + 0x2AAA*AddrsShift) = 0x55;     // write data 0x55 to device addr 2AAAH for A14 to A0
	*(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0x80;     // write data 0x80 to device addr 5555H for A14 to A0
	*(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0xAA;     // write data 0xAA to device addr 5555H for A14 to A0
	*(WORD *) (BaseAddrs + 0x2AAA*AddrsShift) = 0x55;     // write data 0x55 to device addr 2AAAH for A14 to A0
	*(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0x10;     // write data 0x10 to device addr 5555H for A14 to A0
//  Then there are three ways to determine when internal operation will be ready:
//  First check DQ6, Secondly check DQ7, Lastly delay 50ms.  
    ReturnStatus = Check_ToggleDQ6(0, ChipEraseTime);               // wait TOGGLE bit stops toggling
//  ReturnStatus = Check_DataPollingDQ7(0, 0xFFFF, ChipEraseTime);  // wait until DQ7 outputs 1
    return ReturnStatus;
}

/************************************************************************/
/* PROCEDURE:   SecID_Lock_Status                                       */
/*                                                                      */
/* This procedure checks the lock status of User SecID.             	*/
/*                                                                      */
/* Input:   NONE.                                                       */
/*                                                                      */
/* Output:  TRUE if Locked, FALSE if not locked.                        */
/************************************************************************/
BYTE SecID_Lock_Status(void)
{
    WORD LockStatus;

//  Issue the Sec ID Entry code to 39VF160XC
    *(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0xAA;  // 1st write data 0xAA to device addr 5555H for A14 to A0
    *(WORD *) (BaseAddrs + 0x2AAA*AddrsShift) = 0x55;  // 2nd write data 0x55 to device addr 2AAAH for A14 to A0
    *(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0x88;  // 3rd write data 0x88 to device addr 5555H for A14 to A0
    Delay_150_Nanoseconds();                           // insert delay time = Tida

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

//  Issue Sec ID Exit code for SST36VF1601C to return to read mode.
//  *(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0xAA;  // 1st write data 0xAA to device addr 5555H for A14 to A0
//  *(WORD *) (BaseAddrs + 0x2AAA*AddrsShift) = 0x55;  // 2nd write data 0x55 to device addr 2AAAH for A14 to A0
    *(WORD *) (BaseAddrs + 0x5555*AddrsShift) = 0xF0;  // 3rd write data 0xF0 to device addr 5555H for A14 to A0
    Delay_150_Nanoseconds();                           // insert delay time = Tida

    if (LockStatus==0)
   	     return TRUE;	           	                   // User SecID segment is Locked.
    else return FALSE;   		                       // User SecID segment is NOT locked.
}


/************************************************************************/
/* PROCEDURE:   User_SecID_Word_Program                                 */
/*                                                                      */
/* This procedure programs n words of data into the User SecID          */