/* s29gl512n_16x1.c
 * Device interface for Spansion S29GL512N flash device configured for
 * x16 mode with 1 device in parallel.  
 * The device contains 512 128Kbyte sectors.
 * There are four different memory configurations that this driver
 * handles:
 * 1. A single S29GL512N_16x1 device 
 * 2. Piggybacked S29GL512N_16x1 devices (2 devices).
 * 3. 70GL01GN: 2 S29GL512N_16x1 devices in one package.
 * 4. GL01GP: This is a single device with double the density of the 
 *    S29GL512N_16x1 device.
 */
#include "config.h"

#if INCLUDE_FLASH

#define WRITE_BUFFER_SIZE	32
#define WRITE_BUFFER_ADDR_MASK		(~(WRITE_BUFFER_SIZE-1))

#include "stddefs.h"
#include "genlib.h"	
#include "cpu.h"
#include "cpuio.h"
#include "flash.h"			/* Part of monitor common code */
#include "s29gl512n_16x1.h"

#define ftype 					volatile unsigned short
#define Is_ff(add)			   	(*(ftype *)add == 0xffff)
#define Is_not_ff(add)	    	(*(ftype *)add != 0xffff)
#define Is_Equal(p1,p2) 	    (*(ftype *)p1 == *(ftype *)p2)
#define Is_Equal_d7(p1,p2) 	    ((*(ftype *)p1&0x80) == (*(ftype *)p2&0x80))
#define Is_Not_Equal(p1,p2)		(*(ftype *)p1 != *(ftype *)p2)
#define Is_Not_Equal_d7(p1,p2) 	((*(ftype *)p1&0x80) != (*(ftype *)p2&0x80))
#define Fwrite(to,frm)  	    (*(ftype *)to = *(ftype *)frm)
#define D5_Timeout(add)	   		((*(ftype *)(add) & 0x0020) == 0x0020)

#define SECTOR_TOTAL			(512*2)
#define SECTOR_SIZE				0x20000
#define SPANSION_29GL512N_ID	0x00012223
#define SPANSION_29GL1024N_ID	0x00012228

#define D6	0x0040
#define D5	0x0020
#define D3	0x0008

#define SECTOR_ERASE(add)		{ \
	*(ftype *)((fdev->base+(0x555<<1))) = 0x00aa; \
	*(ftype *)((fdev->base+(0x2aa<<1))) = 0x0055; \
	*(ftype *)((fdev->base+(0x555<<1))) = 0x0080; \
	*(ftype *)((fdev->base+(0x555<<1))) = 0x00aa; \
	*(ftype *)((fdev->base+(0x2aa<<1))) = 0x0055; \
	*(ftype *)(add) = 0x0030; }
	

#define FLASH_WRITE(dest,src)	{ 	\
	*(ftype *)((fdev->base+(0x555<<1))) = 0x00aa; \
	*(ftype *)((fdev->base+(0x2aa<<1))) = 0x0055; \
	*(ftype *)((fdev->base+(0x555<<1))) = 0x00a0; \
	Fwrite((ftype *)(dest),src); }

#define AUTO_SELECT()			{	\
	*(ftype *)((fdev->base+(0x555<<1))) = 0x00aa; \
	*(ftype *)((fdev->base+(0x2aa<<1))) = 0x0055; \
	*(ftype *)((fdev->base+(0x555<<1))) = 0x0090; }

#define READ_RESET() 			{	\
	ftype val;	\
	*(ftype *)(fdev->base) = 0x00f0; \
	val = *(ftype *)(fdev->base); \
	val = val; }	// eliminate "variable unused warning"

#define WHILE_D6_TOGGLES(a) \
	while ((*(ftype *)(a) & D6) != (*(ftype *)(a) & D6))


/* S29gl512n_16x1_erase():
 * Based on the 'snum' value, erase the appropriate sector(s).
 * Return 0 if success, else -1.
 */
int
S29gl512n_16x1_erase(struct flashinfo *fdev,int snum)
{
	ulong	add;
	int		ret;

	ret = 0;
	add = (ulong)(fdev->sectors[snum].begin);


	SECTOR_ERASE(add);

	/* Wait for sector erase to complete or timeout..
	 * DQ7 polling: wait for D7 to be 1.
	 * DQ6 toggling: wait for D6 to not toggle.
	 * DQ5 timeout: if DQ7 is 0, and DQ5 = 1, timeout.
	 */
	while(1) {
		WATCHDOG_MACRO;
		if (*(ftype *)(add) == 0xffff) {
			if (*(ftype *)(add) == 0xffff) 
				break;
		}
		if (D5_Timeout(add)) {
			if (*(ftype *)(add) != 0xffff) 
				ret = -1;
			break;
		}
	}

	/* If the erase failed for some reason, then issue the read/reset
	 * command sequence prior to returning...
	 */
	if (ret == -1)  
		READ_RESET();

	return(ret);
}

/* EndS29gl512n_16x1_erase():
 * Function place holder to determine the end of the above function.
 */
void
EndS29gl512n_16x1_erase(void)
{
}

#ifdef BUFFERED_WRITE

/* S29gl512n_16x1_write():
 * Copy specified number of bytes from source to destination.  The destination
 * address is assumed to be flash space.
 */
int
S29gl512n_16x1_write(struct flashinfo *fdev,
	uchar *dest,uchar *src,long bytecnt)
{
	ftype	val;
	int		i, ret;
	ulong   cnt;
	uchar 	*src1;

	ret = 0;
	src1 = (uchar *)&val;

	/* Since we are working on a 2-byte wide device, every write to the
	 * device must be aligned on a 2-byte boundary.  If our incoming
	 * destination address is odd, then decrement the destination by one
	 * and build a fake source using *dest-1 and src[0]...
	 */
	if (((ulong)dest)&1) {
		dest--;
		
		src1[0] = *dest;
		src1[1] = *src;

		FLASH_WRITE(dest,src1);

		/* Wait for write to complete or timeout. */
		while(1) {
			if (Is_Equal_d7(dest,src1)) {
				if (Is_Equal_d7(dest,src1))
					break;
			}
			/* Check D5 for timeout... */
			if (D5_Timeout(dest)) {
				if (Is_Not_Equal_d7(dest,src1)) {
					ret = -1;
					goto done;
				}
				break;
			}
		}

		dest += 2;
		src++;
		bytecnt--;
	}

	/* Now determine how many whole words can be written to the destination.
	 * We try to take advantage of buffer writes.
	 */
	for(cnt=bytecnt; cnt>1; ) {
		ulong tmpLen;
		uchar buf[WRITE_BUFFER_SIZE];
		tmpLen=(((ulong)dest&WRITE_BUFFER_ADDR_MASK)+WRITE_BUFFER_SIZE)-
			(ulong)dest;
		if (tmpLen > cnt) {
			tmpLen=cnt;
		}
		if (tmpLen&1) {
			tmpLen--;
		}
		/* Because the source might be the flash itself, first copy the
		 * bytes to a RAM-based buffer just to be safe.
		 */
		for(i=0; i<tmpLen; ++i) {
			buf[i]=src[i];
		}

		/* Buffered write...
		 */
		{
			long	b_cnt;
			int		i, rc;
			uchar	*b_src, *saddr, *eaddr;

			rc = 0;
			b_src = buf;
			saddr = dest;
			b_cnt = tmpLen;
			eaddr = saddr + b_cnt - 1;

			if (!b_cnt) return 0;

			if (((ulong)eaddr&WRITE_BUFFER_ADDR_MASK) != 
				((ulong)saddr&WRITE_BUFFER_ADDR_MASK)) {
				/* Overall buffer straddles a boundary */
				return -1;
			}

			if (b_cnt&1) {
				ret = -1;
				goto done;
			}

			*(ftype *)(fdev->base+(0x555<<1)) = 0x00aa; 
			*(ftype *)(fdev->base+(0x2aa<<1)) = 0x0055; 
			*(ftype *)(saddr) = 0x0025; 
			*(ftype *)(saddr) = (b_cnt/2)-1; 

			for(i=0; i<b_cnt/2; i++) {
				Fwrite(saddr,b_src);
				saddr+=2;
				b_src+=2;
			}
			/* We'll poll the last adress that was written */
			saddr-=2;
			b_src-=2;

			*(ftype *)(saddr) = 0x0029; 

			/* Wait for write to complete or timeout. */
			while(1) {
				if (Is_Equal_d7(saddr,b_src)) {
					if (Is_Equal_d7(saddr,b_src))
						break;
				}
				/* Check D5 for timeout... */
				if (D5_Timeout(saddr)) {
					if (Is_Not_Equal_d7(saddr,b_src)) {
						if (*(ftype *)saddr & 0x2) {
							/* Reset the operation */
							*(ftype *)(fdev->base+(0x555<<1)) = 0x00aa; 
							*(ftype *)(fdev->base+(0x2aa<<1)) = 0x0055; 
							*(ftype *)(fdev->base+(0x555<<1)) = 0x00F0; 
						}
						ret = -1;
						goto done;
					}
					break;
				}
			}

			if (rc) {
				READ_RESET();
			}
			//return rc;
		}

		dest+=tmpLen;
		src+=tmpLen;
		cnt-=tmpLen;
	}

    /* We still have to deal with the possibility that there might be a trailing
	 * byte that might have to be written
	 */
	if (cnt) {
		/* One additional byte left */
		src1[0] = *src;
		src1[1] = dest[1];

		FLASH_WRITE(dest,src1);

		/* Wait for write to complete or timeout. */
		while(1) {
			if (Is_Equal_d7(dest,src1)) {
				if (Is_Equal_d7(dest,src1))
					break;
			}
			/* Check D5 for timeout... */
			if (D5_Timeout(dest)) {
				if (Is_Not_Equal_d7(dest,src1)) {
					ret = -1;
					goto done;
				}
				break;
			}
		}
	}

done:
	if (ret) {
		READ_RESET();
	}
	return(ret);
}

#else

/* S29gl512n_16x1_write():
 * Copy specified number of bytes from source to destination.  The destination
 * address is assumed to be flash space.
 */
int
S29gl512n_16x1_write(struct flashinfo *fdev,
	uchar *dest,uchar *src,long bytecnt)
{
	ftype	val;
	int		cnt, ret;
	uchar 	*src1;

	ret = 0;
	cnt = bytecnt & ~1;
	src1 = (uchar *)&val;

	/* Since we are working on a 2-byte wide device, every write to the
	 * device must be aligned on a 2-byte boundary.  If our incoming
	 * destination address is odd, then decrement the destination by one
	 * and build a fake source using *dest-1 and src[0]...
	 */
	if (NotAligned16(dest)) {
		dest--;
		
		src1[0] = *dest;
		src1[1] = *src;

		FLASH_WRITE(dest,src1);

		/* Wait for write to complete or timeout. */
		while(1) {
			WATCHDOG_MACRO;

			if (*(ftype *)(dest) == *(ushort *)src1) {
				if (*(ftype *)(dest) == *(ushort *)src1)
					break;
			}
			/* Check D5 for timeout... */
			if (D5_Timeout(dest)) {
				if (*(ftype *)(dest) != *(ushort *)src1) {
					ret = -1;
					goto done;
				}
				break;
			}
		}

		dest += 2;
		src++;
		bytecnt--;
	}

	/* Each pass through this loop writes 'fdev->width' bytes...
	 */

	while (bytecnt >= fdev->width) {

		/* Just in case src is not aligned... */
		src1[0] = src[0];
		src1[1] = src[1];


		FLASH_WRITE(dest,src1);
		
		/* Wait for write to complete or timeout. */
		while(1) {
			WATCHDOG_MACRO;

			if (*(ftype *)(dest) == *(ushort *)src1) {
				if (*(ftype *)(dest) == *(ushort *)src1)
					break;
			}
			/* Check D5 for timeout... */
			if (D5_Timeout(dest)) {
				if (*(ftype *)(dest) != *(ushort *)src1) {
					ret = -1;
					goto done;
				}
				break;
			}
		}
		dest += fdev->width; 
		src += fdev->width;
		bytecnt -= 2;
	}

	/* Similar to the front end of this function, if the byte count is not
	 * even, then we have one byte left to write, so we need to write a 
	 * 16-bit value by writing the last byte, plus whatever is already in
	 * the next flash location.
	 */
	if (bytecnt) {
		src1[0] = *src;
		src1[1] = dest[1];


		FLASH_WRITE(dest,src1);

		/* Wait for write to complete or timeout. */
		while(1) {
			WATCHDOG_MACRO;
			if (*(ftype *)(dest) == *(ushort *)src1) {
				if (*(ftype *)(dest) == *(ushort *)src1)
					break;
			}
			/* Check D5 for timeout... */
			if (D5_Timeout(dest)) {
				if (*(ftype *)(dest) != *(ushort *)src1) {
					ret = -1;
					goto done;
				}
				break;
			}
		}
	}

done:
	READ_RESET();

	return(ret);
}
#endif

/* EndS29gl512n_16x1_write():
 * Function place holder to determine the end of the above function.
 */
void
EndS29gl512n_16x1_write(void)
{}

/* S29gl512n_16x1_ewrite():
 * Erase all sectors that are part of the address space to be written,
 * then write the data to that address space.
 * This function is optimized for speed by using the write buffer and
 * erase delay timer.  It assumes the incoming destination address is
 * aligned on a 32-byte boundary and that the bytecount will be even.
 */
int
S29gl512n_16x1_ewrite(struct flashinfo *fdev,
	uchar *dest,uchar *src,long bytecnt)
{
	int		i;
	ulong	add;

	add = (ulong)(fdev->base);

	/* For each sector, if it overlaps any of the destination space
	 * then erase that sector.
	 */
	for (i=0;i<fdev->sectorcnt;i++) {
		long size;
		long *begin, *end;
		struct sectorinfo *sip;

		sip = &(fdev->sectors[i]);
		begin = (long *)(sip->begin);
		end = (long *)(sip->end);
		size = sip->size;

		/* If this sector is not overlapping the destination, then
		 * don't erase it...
		 */
		if ((((uchar *)dest) > (uchar *)end) ||
		    (((uchar *)dest+bytecnt-1) < (uchar *)begin)) {
			add += size;
			continue;
		}

		/* If this sector is already erased, then don't erase it...
		 */
		while(begin < end) {
			if (*begin != 0xffffffff)
				break;
			begin++;
		}
		if (begin >= end) {
			add += size;
			continue;
		}
		SECTOR_ERASE(add);

		WHILE_D6_TOGGLES(add);

		add += size;
	}

	READ_RESET();

	while(bytecnt > 0) {
		int tot, tot1;
		uchar *sa;

		sa = dest;
		*(ftype *)((fdev->base+(0x555<<1))) = 0x00aa;
		*(ftype *)((fdev->base+(0x2aa<<1))) = 0x0055;

		*(ftype *)(sa) = 0x0025;
		if (bytecnt >= 32)
			tot = tot1 = 32;
		else
			tot = tot1 = bytecnt;
		*(ftype *)(dest) = (tot/2 - 1);
		while(tot > 0) {
			Fwrite((ftype *)(dest),src); 
			dest+=2; 
			src+=2;
			tot -= 2;
		}
  	    *(ftype *)(sa) = 0x0029;

		WHILE_D6_TOGGLES(sa);

		bytecnt -= tot1;
	}

	READ_RESET();

    /* Now that the re-programming of flash is complete, reset: */
	{
#ifdef RESETMACRO
	RESETMACRO();
#else
    void    (*reset)();
    reset = RESETFUNC();
    reset();
#endif
	}

	return(0);	/* won't get here */
}

/* EndS29gl512n_16x1_ewrite():
 * Function place holder to determine the end of the above function.
 */
void
EndS29gl512n_16x1_ewrite(void)
{}


/* S29gl512n_16x1_type():
 * Run the AUTOSELECT algorithm to retrieve the manufacturer and
 * device id of the flash.
 */
int
S29gl512n_16x1_type(struct flashinfo *fdev)
{
	ushort	man, dev;
	ulong	id;


	AUTO_SELECT();

	man = *(ftype *)(fdev->base);			/* manufacturer ID */
	dev = *(ftype *)((fdev->base + 28));	/* device ID */
	id = man;
	id <<= 16;
	id |= dev;

	fdev->id = id;

	READ_RESET();

	return((int)(fdev->id));
}

/* EndS29gl512n_16x1_type():
 * Function place holder to determine the end of the above function.
 */
void
EndS29gl512n_16x1_type(void)
{}

/**************************************************************************
 **************************************************************************
 *
 * The remainder of the code in this file should only included if the
 * target configuration is such that this AM29F040 device is the only
 * real flash device in the system that is to be visible to the monitor.
 *
 **************************************************************************
 **************************************************************************
 */
#ifdef SINGLE_FLASH_DEVICE

/* FlashXXXFbuf[]:
 * If FLASH_COPY_TO_RAM is defined then these arrays will contain the
 * flash operation functions above.  To operate on most flash devices,
 * you cannot be executing out of it (there are exceptions, but
 * in general, we do not assume the flash supports this).  The flash
 * functions are copied here, then executed through the function
 * pointers established in the flashinfo structure below.
 * One obvious requirement...  The size of each array must be at least
 * as large as the function that it will contain.
 */
#ifdef FLASH_COPY_TO_RAM
ulong    FlashTypeFbuf[400];
ulong    FlashEraseFbuf[400];
#ifdef BUFFERED_WRITE
ulong    FlashWriteFbuf[600];
#else
ulong    FlashWriteFbuf[400];
#endif
ulong    FlashEwriteFbuf[400];
#endif

/* FlashNamId[]:
 * Used to correlate between the ID and a string representing the name
 * of the flash device.
 */
struct flashdesc FlashNamId[] = {
	{ SPANSION_29GL512N_ID,		"Spansion-29GL512N" },
	{ SPANSION_29GL1024N_ID,	"Spansion-29GL1024N" },
	{ 0, (char *)0 },
};


struct sectorinfo sinfo_bank0[SECTOR_TOTAL];
struct sectorinfo sinfo_bank1[SECTOR_TOTAL];

int
flashBankInit(int banknum, int snum, struct sectorinfo *sinfotbl)
{
	int		i;
	uchar	*begin;
	struct	flashinfo *fbnk;

	fbnk = &FlashBank[banknum];
	if (banknum == 0)
		fbnk->base = (unsigned char *)FLASH_BANK0_BASE_ADDR;
	else
		fbnk->base = (unsigned char *)FLASH_BANK0_BASE_ADDR+0x04000000;

	fbnk->width = 2;

#ifdef FLASH_COPY_TO_RAM
	fbnk->fltype = (int(*)())FlashTypeFbuf;
	fbnk->flerase = (int(*)())FlashEraseFbuf;
	fbnk->flwrite = (int(*)())FlashWriteFbuf;
	fbnk->flewrite = (int(*)())FlashEwriteFbuf;
#else
	fbnk->fltype = S29gl512n_16x1_type;
	fbnk->flerase = S29gl512n_16x1_erase;
	fbnk->flwrite = S29gl512n_16x1_write;
	fbnk->flewrite = S29gl512n_16x1_ewrite;
#endif

	/* This device doesn't support flash lock, so set the pointer
	 * to the default FlashLockNotSupported() function...
	 */
	fbnk->fllock = FlashLockNotSupported;

	fbnk->sectors = sinfotbl;
	fbnk->id = flashtype(fbnk);
	switch(fbnk->id) {
		case SPANSION_29GL512N_ID:
			fbnk->end = fbnk->base + 0x04000000 - 1;
			fbnk->sectorcnt = SECTOR_TOTAL/2;
			break;
		case SPANSION_29GL1024N_ID:
			fbnk->end = fbnk->base + 0x08000000 - 1;
			fbnk->sectorcnt = SECTOR_TOTAL;
			break;
		default:
			/* The second bank may legitimately not be populated, so if it
			 * isn't found, indicate unavailable, don't claim an error...
			 */
			printf("Flash bank %d: ",banknum);
			if (banknum == 0)
				printf("invalid id: 0x%lx.\n",fbnk->id);
			else
				printf("not available.\n");
			return(-1);
	}

	begin = fbnk->base;
	for(i=0;i<fbnk->sectorcnt;i++,snum++) {
		fbnk->sectors[i].snum = snum;
		fbnk->sectors[i].size = SECTOR_SIZE;
		fbnk->sectors[i].begin = begin;
		fbnk->sectors[i].end = fbnk->sectors[i].begin + SECTOR_SIZE - 1;
		fbnk->sectors[i].protected = 0;
		begin += SECTOR_SIZE;
	}
	return(snum);
}

/* FlashInit():
 * Initialize data structures for each bank of flash...
 */
int
FlashInit()
{
	int	snum;

	FlashCurrentBank = 0;

	/* If code is in flash, then we must copy the flash ops to RAM.
	 * Note that this MUST be done when cache is disabled to assure
	 * that the RAM is occupied by the designated block of code.
	 */

#ifdef FLASH_COPY_TO_RAM
	if (flashopload((ulong *)S29gl512n_16x1_type,
		(ulong *)EndS29gl512n_16x1_type,
		FlashTypeFbuf,sizeof(FlashTypeFbuf)) < 0)
		return(-1);
	
	if (flashopload((ulong *)S29gl512n_16x1_erase,
		(ulong *)EndS29gl512n_16x1_erase,
		FlashEraseFbuf,sizeof(FlashEraseFbuf)) < 0)
		return(-1);
	
	if (flashopload((ulong *)S29gl512n_16x1_ewrite,
		(ulong *)EndS29gl512n_16x1_ewrite,
		FlashEwriteFbuf,sizeof(FlashEwriteFbuf)) < 0)
		return(-1);
	
	if (flashopload((ulong *)S29gl512n_16x1_write,
		(ulong *)EndS29gl512n_16x1_write,
		FlashWriteFbuf,sizeof(FlashWriteFbuf)) < 0)
		return(-1);
#endif

#ifdef IS_MONOLITHIC_FLASH
	ActiveFlashBanks = 1;
	snum = flashBankInit(0,0,sinfo_bank0);

	if (!IS_MONOLITHIC_FLASH()) {
		if (flashBankInit(1,snum,sinfo_bank1) != -1)
			ActiveFlashBanks++;
	}
#else
	snum = flashBankInit(0,0,sinfo_bank0);
#endif

	if (snum < 0)
		return(-1);

#ifdef FLASH_PROTECT_RANGE
	sectorProtect(FLASH_PROTECT_RANGE,1);
#endif

#if FLASHRAM_BASE
	FlashRamInit(snum, FLASHRAM_SECTORCOUNT, &FlashBank[FLASHRAM_BANKNUM],
		sinfoRAM, 0);
#endif

	return(0);
}

#endif	/* SINGLE_FLASH_DEVICE */

#endif	/* INCLUDE_FLASH */