/*
*****************************************************************************************************
*
*  File name: flash.c
*****************************************************************************************************
*/

#include "..\head\includes.h"



/*
*****************************************************************************************************
* 
*****************************************************************************************************
*/
#ifdef _F_W_W_P

unsigned char flash_write_with_poll(volatile uchar xdata* addr, uchar dat)
{
	unsigned char done;
	unsigned char error;
	unsigned char err;
	unsigned char poll;

	done = FALSE;
   	err = FALSE;
	
	*(FLASH_COMMON_X555) = 0xAA;     // unlock main flash, write 0xAA to addess 0xX555
	*(FLASH_COMMON_XAAA) = 0x55;     // unlock main flash, write 0x55 to addess 0xXAAA
	*(FLASH_COMMON_X555) = 0xA0;     // write 0xA0 command to program

	*(addr) = dat;                   // write byte to flash   
	
	dat = dat & NVM_DATA_POLL;       // get bit DQ7 of original dat   
	
	do                               // now use dat polling method to verify successful write
    {  

   		poll = *(addr);               // Read the location that was just programmed

		error = poll & NVM_ERROR;     // save timeout error bit at DQ5

		poll = poll & NVM_DATA_POLL;  // get DQ7 of poll byte read from flash  

		if (dat == poll)              // compare DQ7 

			done = TRUE;              // dat byte programmed into flash OK,
                                         // indicate successful exit criteria

		else if (error ==  NVM_ERROR )	 // check for timeout error   
			err = TRUE;                  // indicate timeout error occurred

    } while((done == FALSE) && (err == FALSE)); 


	if (err == TRUE)                     // make sure timeout error and dat poll didn't 
                                         // occur simultaneously
	{
		poll = *(addr);                  // Read location in flash again

		poll = poll & NVM_DATA_POLL;     // get DQ7 of poll byte read from flash  

		if (dat == poll)                 // compare DQ7 

			done = TRUE;                 // dat byte programmed into flash OK at the same
                                         // time timout error occured, indicate successful 
		                                 // exit criteria

		*(FLASH_COMMON_X555) = 0xF0;     // reset the flash array (short reset instruction) 
		                                 // now delay 3 msec per dat sheet
    }

   	return(done);                        // a successful flash write returns 1, timeout error returns 0
}
#endif


/*
*****************************************************************************************************
* 
*****************************************************************************************************
*/
#ifdef _F_B_W_W_P

unsigned char flash_boot_write_with_poll(volatile unsigned char xdata* addr, unsigned char dat)
{
	unsigned char done;
	unsigned char error;
	unsigned char err;
	unsigned char poll;

	done = FALSE;
   	err = FALSE;
	
	*(FLASH_BOOT_X555) = 0xAA;     // unlock main flash, write 0xAA to addess 0xX555
	*(FLASH_BOOT_XAAA) = 0x55;     // unlock main flash, write 0x55 to addess 0xXAAA
	*(FLASH_BOOT_X555) = 0xA0;     // write 0xA0 command to program

	*(addr) = dat;                   // write byte to flash   
	
	dat = dat & NVM_DATA_POLL;       // get bit DQ7 of original dat   
	
	do                               // now use dat polling method to verify successful write
    {  

   		poll = *(addr);              // Read the location that was just programmed

		error = poll & NVM_ERROR;    // save timeout error bit at DQ5

		poll = poll & NVM_DATA_POLL;  // get DQ7 of poll byte read from flash  

		if (dat == poll)              // compare DQ7 

			done = TRUE;              // dat byte programmed into flash OK,
                                         // indicate successful exit criteria

		else if (error ==  NVM_ERROR )	 // check for timeout error   
			err = TRUE;                  // indicate timeout error occurred

    } while((done == FALSE) && (err == FALSE)); 


	if (err == TRUE)                     // make sure timeout error and dat poll didn't 
                                         // occur simultaneously
	{
		poll = *(addr);                  // Read location in flash again

		poll = poll & NVM_DATA_POLL;     // get DQ7 of poll byte read from flash  

		if (dat == poll)        // compare DQ7 

			done = TRUE;        // dat byte programmed into flash OK at the same
                                // time timout error occured, indicate successful 
		                        // exit criteria

		*(FLASH_BOOT_X555) = 0xF0;  // reset the flash array (short reset instruction) 
		                            // now delay 3 msec per dat sheet
    }

   	return(done);                   // a successful flash write returns 1, timeout error returns 0
}
#endif


/*
*****************************************************************************************************
* 
*****************************************************************************************************
*/
#ifdef _F_W_W_T

unsigned char flash_write_with_toggle(addr,dat)	
volatile unsigned char *addr;
unsigned char dat;

	{
	unsigned char done;
	unsigned char error;
	unsigned char err;
	volatile unsigned char toggle_A;
	volatile unsigned char toggle_B;

	done = FALSE;
   	err = FALSE;

	*(FLASH_BOOT_X555) = 0xAA;		// unlock main flash, write 0xAA to addess 0xX555
	*(FLASH_BOOT_XAAA) = 0x55;		// unlock main flash, write 0x55 to addess 0xXAAA
	*(FLASH_BOOT_X555) = 0xA0;		// write 0xA0 command to program

	*(addr) = dat;		// write byte to flash   

		// now use toggling method to verify successful write

	toggle_A = *(addr);			// Read the location that was just programmed

	toggle_A = toggle_A & NVM_DATA_TOGGLE;	// mask toggle bit at DQ6
   		  								
	do
		{  
   		toggle_B = *(addr);		// Again read the location that was just programmed

		error = toggle_B & NVM_ERROR;	// save timeout error flag at DQ5

		toggle_B = toggle_B & NVM_DATA_TOGGLE;	// mask toggle bit at DQ6
   		  								
		if (toggle_A == toggle_B)	// compare toggle bit DQ6

			done = TRUE;		// bit did not toggle, dat byte programmed into 
						// flash OK, indicate successful exit criteria
		else
			{
	 		 if (error ==  NVM_ERROR )	// check for timeout error   
				err = TRUE; 	// indicate timeout error occurred

			toggle_A = toggle_B;  	// save most recent sample of toggle bit 
						// to compare with next sample
			}

		} while((done == FALSE) && (err == FALSE)); 


	if (err == TRUE)			// make sure timeout error and dat toggle didn't 
						// occur simultaneously
		{
		toggle_B = *(addr);		// Read location in flash again

		toggle_B = toggle_B & NVM_DATA_TOGGLE;	// mask toggle bit at DQ6

		if (toggle_A == toggle_B)		// compare toggle bit DQ6

			done = TRUE;			// dat byte programmed into flash OK at the same
							// time timout error occured, indicate successful 
							// exit criteria

		*(FLASH_BOOT_X555) = 0xF0;  // reset the flash array (short reset instruction) 
		        // now delay 3 msec per dat sheet
		}

   	return(done);		// a successful flash write returns 1, timeout error returns 0
	}

#endif



/*
*****************************************************************************************************
* 
*****************************************************************************************************
*/

#ifdef _F_E_B

unsigned char flash_erase_sector(
    volatile unsigned char xdata* flash_bulk_erase_address)
{
	unsigned char done;
 	unsigned char poll;
 	unsigned char error;
 	unsigned char err;

	done = FALSE;
   	err = FALSE;

	//  Note:  the following constants (FLASH_COMMON_XXXX)
	//     are declared type volatile in the header file 
	//	   so they are not optimized away by the compiler

	*(FLASH_COMMON_X555) = 0xAA;		// unlock main flash, write 0xAA to addess 0xX555
	*(FLASH_COMMON_XAAA) = 0x55;		// unlock main flash, write 0x55 to addess 0xXAAA