/*
 * File:		amd29f016.c
 * Purpose:		Device driver for the AMD 29F016 Flash.
 *
 * Notes:       This driver supports a single type (AMD29F016) and
 *              width of FLASH.  The width support is done during
 *              compilation.  It can support multiple banks of
 *              same-width ADM29F016 FLASH.
 *
 *              If different types and width of FLASH are required,
 *              see driver amd29f0x0.c.
 *
 * Author:		Eric DeVolder
 * Date:		12-3-95
 *
 * Modifications:
 *
 */

#include "src/include/dbug.h"
#include "src/dev/flash/amd29f016.h"

/*
 * The AMD29F016 FLASH devices.  These devices are 2M x 8 devices.
 *
 * Note:  This driver supports one of the following configurations
 * for these devices.  Possible configurations are:
 *
 *      1 AMD29F016  as a single  8-bit memory device
 *      2 AMD29F016s as a single 16-bit memory device
 *      4 AMD29F016s as a single 32-bit memory device
 *
 * One of the following C pre-processor define statements must
 * exist prior to compilation:
 *
 * #define AMD29F016_8BIT_WIDE
 * #define AMD29F016_16BIT_WIDE
 * #define AMD29F016_32BIT_WIDE
 *
 * IMPORTANT:  It is not possible to execute any of these routines
 * if the code for these routines is in the FLASH itself.  This is
 * because these routines change the mode of the device so that reads
 * from it are not always possible.  The code must be executed out of
 * DRAM.
 */

/*
 * WARNING:  To eliminate playing alot of games with the linker
 * to properly treat this PIC driver, the two routines/symbols
 * amd29f016_start and amd29f016_end are used to determine the 
 * start and end of the FLASH PIC driver in ROM/FLASH so that it
 * can be copied out to DRAM and then executed.  In other words,
 * any modifications/additions must be between these two functions!
 */
/*****************************************************************/
void
amd29f016_start (void)
{
}

/*****************************************************************/
void
amd29f016_read (AMD29F016 *amd29f016)
{
	/*
	 * This routine places the FLASH in the read/reset mode.
	 */
	amd29f016->device.cmdreg1 = AMD29F016_READ_CMD1;
	amd29f016->device.cmdreg2 = AMD29F016_READ_CMD2;
	amd29f016->device.cmdreg1 = AMD29F016_READ_CMD3;
}

/*****************************************************************/
int
amd29f016_sector_erase (AMD29F016 *amd29f016, AMD29F016_SECTOR sector)
{
	/*
	 * This routine erases one sector in the FLASH.
	 */
	AMD29F016_CELL	*s;

	/*
	 * Point to beginning of the desired sector
	 */
	s = (AMD29F016_CELL *)&(amd29f016->sector[sector]);

	/*
	 * Perform the Sector Erase command sequence.
	 */
	amd29f016->device.cmdreg1 = AMD29F016_SECTORERASE_CMD1;
	amd29f016->device.cmdreg2 = AMD29F016_SECTORERASE_CMD2;
	amd29f016->device.cmdreg1 = AMD29F016_SECTORERASE_CMD3;
	amd29f016->device.cmdreg1 = AMD29F016_SECTORERASE_CMD4;
	amd29f016->device.cmdreg2 = AMD29F016_SECTORERASE_CMD5;
	*s = AMD29F016_SECTORERASE_CMD6;

	/*
	 * Wait for the device to erase the sector
	 */

	while ((*s & AMD29F016_SECTORERASE_DONE) != AMD29F016_SECTORERASE_DONE)
		;

	/*
	 * Place the device back in the Read/Reset mode.
	 */
	amd29f016_read (amd29f016);

	return 1;
}


/*****************************************************************/
int
amd29f016_id (AMD29F016 *amd29f016)
{
	/*
	 * This routine extracts from the FLASH the manufacturer and
	 * and device code.  If the codes match those for the AMD29F016,
	 * then 1 is returned, else 0.
	 */
	volatile unsigned int manuf, device;

	/*
	 * Perform the Autoselect command sequence.
	 */
	amd29f016->device.cmdreg1 = AMD29F016_AUTOSELECT_CMD1;
	amd29f016->device.cmdreg2 = AMD29F016_AUTOSELECT_CMD2;
	amd29f016->device.cmdreg1 = AMD29F016_AUTOSELECT_CMD3;

	/*
	 * Read the manufacturer and device id codes.
	 */
	manuf = amd29f016->device.manuf;
	device = amd29f016->device.id;

	/*
	 * Place the device back in the Read/Reset mode.
	 */
	amd29f016_read (amd29f016);

	/*
	 * Determine if an AMD29F016 or not.
	 */
	if (device == AMD29F016_DEVICE_CODE)
		return TRUE;
	else
		return FALSE;
}


/*****************************************************************/
int
amd29f016_write (AMD29F016 *amd29f016,
	void *data, unsigned length, AMD29F016_SECTOR sector, void (*func)(void))
{
	/*
	 * This routine programs the device beginning at 'sector' with
	 * 'data' for 'length' bytes.  This routine is capable of
	 * programming multiple consecutive sectors.
	 */
	int index, written, done;
	AMD29F016_CELL *source;
	AMD29F016_CELL *target;
	AMD29F016_CELL rdata;

	/*
	 * Step 1)  ID the flash as a AMD29F016.
	 */
	if (!amd29f016_id(amd29f016))
		return 0;

	/*
	 * Step 2)  Point to the beginning sector.
	 */
	target = (AMD29F016_CELL *)&(amd29f016->sector[sector]);

	source = (AMD29F016_CELL *)data;

	done = 0;
	written = 0;
	while (!done)
	{
		/*
		 * Step 3)  Erase the sector.
		 */
		if (!amd29f016_sector_erase (amd29f016, sector))
			return -1;

		/*
		 * Step 5)  Program the FLASH with the sector(s) contained in RAM.
		 */
		for (index = 0; (index < AMD29F016_SECTOR_SIZE) && (written < length);
			++index)
		{
			/*
			 * Perform the Byte Program command sequence.
			 */
			amd29f016->device.cmdreg1 = AMD29F016_BYTEPROG_CMD1;
			amd29f016->device.cmdreg2 = AMD29F016_BYTEPROG_CMD2;
			amd29f016->device.cmdreg1 = AMD29F016_BYTEPROG_CMD3;
			*target = *source;

			/*
			 * Poll to make sure it is done before continuing...
			 */
			while (1)
			{
				int timeouts;

				timeouts = 0;

				rdata = *(AMD29F016_CELL *)target;

				if ((rdata & AMD29F016_DATA_POLL_MASK) ==
					(*source & AMD29F016_DATA_POLL_MASK))
				{
					break;
				}
				else
				{
					rdata = *(AMD29F016_CELL *)target;

					if (rdata & AMD29F016_TIME_EXCEEDED)
					{
						rdata = *(AMD29F016_CELL *)target;

						if ((rdata & AMD29F016_DATA_POLL_MASK) ==
							(*source & AMD29F016_DATA_POLL_MASK))
						{
							break;
						}

						if (++timeouts > 1024)
						{
							break;
						}
					}
				}
			}

			/*
			 * Verify write and increment bytes written counter.
			 */
			if (*target == *source)
			{
				written += sizeof(AMD29F016_CELL);

				++target;
				++source;
			}
			else
			{
				done = 1;
				break;
			}
		}

		if (++sector >= AMD29F016_SECTORS)
			done = 1;

		if (written >= length)
			done = 1;
	}

	/*
	 * Step 6)  Place the device back in the read mode.
	 */
	amd29f016_read (amd29f016);

	if (func != NULL)
	{
		func();
	}

	return written;
}

void
amd29f016_end(void)
{
	/*
	 * This function is empty and at the END of all code so that it
	 * can be used to compute the size of the code contained in this
	 * driver.
 	 */
}