{ 	// transfer data from source to destination
	ReturnStatus = Program_One_Word( SourceBuf, DestBuf);
	++DestBuf;
	++SourceBuf;

        if (!ReturnStatus)
    	return ReturnStatus;
    }

    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 Unlocked  	  	 */
/************************************************************************/
int SecID_Lock_Status(void)
{
    WORD SecID_Status;

         //  Issue the Sec ID Entry code to 39VF640X
    *sysAddress(0x555) = 0x00AA;  // write data 0x00AA to device addr 0x555
    *sysAddress(0x2AA) = 0x0055;  // write data 0x0055 to device addr 0x2AA
    *sysAddress(0x555) = 0x0088;  // write data 0x0088 to device addr 0x555
    Delay_150_Nano_Seconds();      // insert delay time = Tida

    	//  Read Lock Status of SecID segment
    SecID_Status = *sysAddress(0x00FF);
    SecID_Status &= 0x0008; // Unlocked: DQ3=1; Locked: DQ3=0

        // Issue the Sec ID Exit code thus returning the 39VF640X
        // to the read operating mode
    *sysAddress(0x555) = 0x00AA;  // write data 0x00AA to device addr 0x555
    *sysAddress(0x2AA) = 0x0055;  // write data 0x0055 to device addr 0x2AA
    *sysAddress(0x555) = 0x00F0;  // write data 0x00F0 to device addr 0x555
    Delay_150_Nano_Seconds();      // insert delay time = Tida

    if (!SecID_Status)
    	return TRUE;		   // SecID segment is Locked

    return FALSE;   		   // SecID segment is Unlocked
}


/************************************************************************/
/* PROCEDURE:   User_SecID_Word_Program                                 */
/*                                                                      */
/* This procedure can be used to program data into the User SecID       */
/* segment (from 000010H--000017H) in 39VF640XB.       			*/
/*                                                                      */
/* NOTE:  1. It's recommended to lock out the SecID segment after the 	*/
/*	  completion of program.					*/
/*	  2. There's no way to unlock the SecID segment once it's	*/
/*	  locked.							*/
/*                                                                      */
/* Input:                                                               */
/*           SrcWord	Source address to fetch data			*/
/*           Dst  	Destination address to write data		*/
/*           length  	number of word needs to be programmed		*/
/*                                                                      */
/* Output:                                                              */
/*          return TRUE:  indicates SecID program is successful         */
/*          return FALSE: indicates SecID program is failed or SecID    */
/*			  is locked.					*/
/************************************************************************/
int User_SecID_Word_Program (WORD *SrcWord, WORD *Dst, int length)
{
    WORD *DestBuf;
    WORD *SourceBuf;
    int test, index=length;

    DestBuf = Dst;
    SourceBuf = SrcWord;

    test = SecID_Lock_Status ();  // check whether the SecID is Locked or not
    if (test)                     // TRUE: SecID is Locked
    	return FALSE;

    while (index--)
    {
    	*sysAddress(0x555) = 0x00AA; // write data 0x00AA to device addr 0x555
    	*sysAddress(0x2AA) = 0x0055; // write data 0x0055 to device addr 0x2AA
    	*sysAddress(0x555) = 0x00A5; // write data 0x00A5 to device addr 0x555
    	*sysAddress(DestBuf) = *SourceBuf; // transfer the WORD to destination
      ++DestBuf;
      ++SourceBuf;
    	// Read the toggle bit to detect end-of-write for the Sec ID.
      	// Do Not use Data# Polling for User_SecID_Word_Program.
      test = Check_Toggle_Ready((Uint32)DestBuf); // wait for TOGGLE bit to get ready
      if (!test)
    	return FALSE;   // SecID Word-Program failed!
    }

    return TRUE;
}


/************************************************************************/
/* PROCEDURE:   User_SecID_Lock_Out                                     */
/*                                                                      */
/* This procedure can be used to Lock Out the User Seccurity ID.        */
/* User Security ID segment, from 000010H--000017H, in 39VF640XB.        */
/*                                                                      */
/* NOTE:  1. Call SecID_Lock_Status() first to verify the SecID is 	*/
/*	  unlocked.							*/
/*	  2. SecID segment can't be erased.				*/
/*	  3. SecID segment can't be unlocked once it's locked.		*/
/*                                                                      */
/* Input:    None                                                       */
/*                                                                      */
/* Output:   None                                                       */
/************************************************************************/
void User_SecID_Lock_Out (void)
{
    *sysAddress(0x555) = 0x00AA; // write data 0x00AA to device addr 0x555
    *sysAddress(0x2AA) = 0x0055; // write data 0x0055 to device addr 0x2AA
    *sysAddress(0x555) = 0x0085; // write data 0x0085 to device addr 0x555
    *sysAddress(0x00FF) = 0x0000; // write data 0x0000 to any addr

    Delay_10_Micro_Seconds();	// Wait for Word-Program timeout, Tbp=10us
}


/************************************************************************/
/* PROCEDURE:   Erase_Suspend		                		*/
/*                                                                      */
/* This procedure can be used to temporarily suspend a Sector/Block-	*/
/* Erase operation in 39VF640XB.  					*/
/*                                                                      */
/* Input:    None                                                       */
/*                                                                      */
/* Output:   None                                                       */
/************************************************************************/
void Erase_Suspend (void)
{
    *sysAddress(0x555) = 0x00B0; // write data 0x00B0 to any addr, i.e. 0x555

    Delay_20_Micro_Seconds();	// The device automatically enters read mode
    		// typically within 20 us after the Erase-Suspend command issued.
}


/************************************************************************/
/* PROCEDURE:   Erase_Resume		              			*/
/*                                                                      */
/* This procedure can be used to resume a Sector-Erase or Block-Erase   */
/* operation that had been suspended in 39VF640XB.  	 		*/
/*                                                                      */
/* Input:    None                                                       */
/*                                                                      */
/* Output:   None                                                       */
/************************************************************************/
void Erase_Resume (void)
{
    *sysAddress(0x555) = 0x0030; // write data 0x0030 to any addr, i.e. 0x555
}


/************************************************************************/
/* 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:   TRUE   Data toggling success                               */
/*           FALSE  Time out                                            */
/************************************************************************/
int Check_Toggle_Ready (Uint32 Dst)
{
    WORD PreData;
    WORD CurrData;
    unsigned long TimeOut = 0;

    PreData = *sysAddress(Dst);
    PreData = PreData & 0x0040;          // read DQ6
    while (TimeOut < MAX_TIMEOUT)	 // MAX_TIMEOUT=0x07FFFFFF
    {
        CurrData = *sysAddress(Dst);
        CurrData = CurrData & 0x0040;    // read DQ6 again
        if (PreData == CurrData)
        {
	    return TRUE;
        }
	PreData = CurrData;
        TimeOut++;
    }
    return FALSE;
}


/************************************************************************/
/* 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            */
/*           TrueData 	this is the original (true) data            	*/
/*                                                                      */
/* Output:                                                              */
/*           TRUE   Data polling success                                */
/*           FALSE  Time out                                            */
/************************************************************************/
int Check_Data_Polling (Uint32 Dst, WORD TrueData)
{
    WORD CurrData;
    unsigned long int TimeOut = 0;

    TrueData = TrueData & 0x0080; 	// read D7
    while (TimeOut < MAX_TIMEOUT)	// MAX_TIMEOUT=0x07FFFFFF
    {
	 CurrData = *sysAddress(Dst);
	 CurrData = CurrData & 0x0080;   // read DQ7
	 if (TrueData == CurrData)
         {
	    return TRUE;
         }
	 TimeOut++;
    }
    return FALSE;
}