/* FLSHEXMP.C
 *
 *
 *      (c) 1998 Micro/sys, Inc.
 *      Glendale, CA
 *      All rights reserved
 *
 * Routines for accessing the 8k parameter block of the Intel Boot Block
 * flash on the SBC1190
 *
 * Characteristics:
 *
 *                              Erased when EXE
 * Blk size    Address Range    file is loaded?
 * --------    -------------    ---------------
 *    8k     E000:0-E000:1FFF         No
 *
 * Note: These routines assume that the flash is visible in the
 * memory map.  In order to do this, the chip-select for the flash
 * is programmed to access 128k starting at address E000:0000.
 *
 * The 8k block is accessed between E000:0000 and E000:1FFF.
 * Do not attempt to program any block outside of this range.
 * If a memory-mapped card is installed in the range of E000:0000 to
 * E000:FFFF, it will be inaccessible while the chip-selects
 * are reprogrammed.
 *
 * The characteristics of flash memory are such that each bit can be
 * programmed from a 1 (erased) to a 0 (programmed), but the only way
 * to return a bit to a 1 is to erase the entire block.  Another
 * important thing to remember is that flash memory has a limited number
 * of write/erase cycles.  A lifetime of at least 100,000 cycles is
 * a large number if the only write/erase cycles occur during program
 * downloads, but it is a short lifetime if a program is constantly
 * writing to and erasing the same locations.
 *
 *
 */

#include <conio.h>
#include <stdio.h>
#include <dos.h>
#include <stdlib.h>

#define PCB          0x0FF00       /*  default base address after reset */
#define GCS5SP       PCB+0x096
#define UCSST        PCB+0x0A4     /*  flash */
#define P1LTCH       PCB+0x056     /* input/output port unit register */

#ifdef __TURBOC__
#ifndef _enable
#define _enable enable
#endif
#ifndef _disable
#define _disable disable
#endif
#ifndef outpw
#define outpw outport
#endif
#ifndef inpw
#define inpw inport
#endif
#endif

#define VPPDISABLE       0x20
#define VPPENABLE        (~VPPDISABLE)


/*
------------------------------------------------------------------------------
 Flash Command Definitions

   These commands are written to the flash device to run the internal state
   machine.
------------------------------------------------------------------------------
*/

#define C_PROG          0x40    /* enter program state          */
#define C_ERASSUSP      0xB0    /* erase suspend                */
#define C_ERASSET       0x20    /* erase setup                  */
#define C_ERASCONF      0xD0    /* erase confirm                */
#define C_CLRSTAT       0x50    /* clear status register        */
#define C_RDSTATUS      0x70    /* read status register         */
#define C_READ          0xFF    /* enter read state             */
#define C_ID            0x90    /* enter ID state               */

/*
------------------------------------------------------------------------------
 Flash Status Register Definitions

   The status register bits show the status of various operations

------------------------------------------------------------------------------
*/

#define WRSTATE         0x80    /* write state machine status   */
#define ERSUSPSTAT      0x40    /* erase suspend status         */
#define ERASESTAT       0x20    /* erase status                 */
#define PROGSTAT        0x10    /* program status               */
#define VPPSTATUS       0x08    /* Vpp status                   */

/*
------------------------------------------------------------------------------
 Flash Program/Erase Errors

 Error return values for program or erase routines

------------------------------------------------------------------------------
*/

#define E_VPPLOW        -50
#define E_CMD           -51
#define E_BLKERAS       -52
#define E_BYTEPROG      -53

#define NOERROR         0

/*
------------------------------------------------------------------------------
 Flash Memory IDs

 ID number

------------------------------------------------------------------------------
*/

#define FL28F200        0x8974
#define FL28F400        0x8970


#define SEG1START       0x8000
#define SEG2START       0xA000
#define SEG3START       0xC000


/*
------------------------------------------------------------------------------
 Vpp On/Off

------------------------------------------------------------------------------
*/

#define VPPON              1
#define VPPOFF             0

/*
---------------------------------------------------------------------
	       WATCHDOG TIMER PORT
---------------------------------------------------------------------
*/
#define WDTMR        0xFE4C          /* write only */

/*---------------------------------------------------------------------------
 *      int Vpp(int vppstate)
 *
 *      This routine enables writes to the flash.
 *
 *
 *      On entry:    vppstate is 0 to disable writes to the flash or
 *                      1 to enable writes to the flash.
 *
 *      On exit:     -
 *
 *      Returns:     -
 *
 *--------------------------------------------------------------------------*/
int Vpp(int vppstate)
{
	if (vppstate == VPPON)
	{
		outp(P1LTCH, inp(P1LTCH) & VPPENABLE);
	}
	else
		outp(P1LTCH, inp(P1LTCH) | VPPDISABLE);

	return 0;
}

/*---------------------------------------------------------------------------
 *      unsigned GetFlashID(unsigned flshblkseg)
 *
 *      This routine gets the manufacturer ID of the flash device.
 *
 *
 *      On entry:    flshblkseg is the segment at which the flash resides.
 *
 *      On exit:     -
 *
 *      Returns:     the flash ID
 *
 *--------------------------------------------------------------------------*/
unsigned GetFlashID(unsigned flshblkseg)
{
	unsigned char mfg, device;
	unsigned int id;
	unsigned char far *EPROM;
	
	EPROM =(unsigned char far *)((unsigned long)flshblkseg<<16);
	
	_disable();     /* disable interrupts */

	Vpp(VPPON);     /* writes must be enabled to send commands */

	*(EPROM+3) = C_ID;        /* send the command to read the ID */

	mfg = *EPROM;         /* read the manufacturer code */

	*(EPROM+3) = C_ID;        /* send the command to read the ID */

	device = *(EPROM+2);      /* read the device type */

	id = ((unsigned int)mfg<<8) + (unsigned int)device;

	*EPROM = C_READ;      /* put flash back in read mode */

	Vpp(VPPOFF);     /* disable writes to protect the flash */

	_enable();      /* enable interrupts */
	return(id);       /* get flash ID */
}



/*---------------------------------------------------------------------------
 *      int EraseBlock(unsigned flshblkseg)
 *
 *      This routine erases a block in the flash.
 *
 *
 *      On entry:    flshblkseg is the segment of the flash block that should
 *                      be erased.
 *
 *      On exit:     -
 *
 *      Returns:     0 if no error
 *                   an error code if an error occurs
 *
 *--------------------------------------------------------------------------*/
int EraseBlock(unsigned flshblkseg)
{
	unsigned char status;
	unsigned char far *flshblk;
	int error, n;

	flshblk =(unsigned char far *)((unsigned long)flshblkseg<<16);

	Vpp(VPPON);
	_disable();     /* disable interrupts */

	*flshblk = C_ERASSET;           /* erase setup */
	*flshblk = C_ERASCONF;          /* erase confirm */

	for(n=0;;n++)
	{
                outp(WDTMR, 0); /* strobe watchdog timer */
		status = *flshblk;      /* read the status */
		if (status & WRSTATE) /* keep polling register until done */
		{
			#ifdef DEBUG
			printf("status = %02X, n=%d\n", status, n);
			#endif
			break;
		}
	}


	if (status & VPPSTATUS)
		error = E_VPPLOW;
	else if ((status & PROGSTAT) &&(status & ERASESTAT))
		error = E_CMD;
	else if (status & ERASESTAT)
		error = E_BLKERAS;
	else
		error = NOERROR;

	if (error)
		*flshblk = C_CLRSTAT;   /* clear status register if needed */

	*flshblk = C_READ;      /* put flash back in read mode */

	_enable();      /* enable interrupts */
	Vpp(VPPOFF);

	return(error);
}



/*---------------------------------------------------------------------------
 *      int ProgFlash(unsigned char *datablk, unsigned flshblkseg, int numbytes)
 *
 *      This routine programs a block of data into the flash.
 *
 *
 *      On entry:    datablk is a pointer to an array of data to program into
 *                      the flash.
 *                   flshblkseg is the segment of the flash into which
 *                      the data should be programmed.
 *                   numbytes is the number of bytes of data that should
 *                      be programmed.
 *
 *      On exit:     -
 *
 *      Returns:     0 if no error
 *                   an error code if an error occurs
 *
 *--------------------------------------------------------------------------*/
int ProgFlash(unsigned char *datablk, unsigned flshblkseg, int numbytes)
{
	unsigned char status;
	unsigned char far *flshaddr;
	int error, n, m;

	Vpp(VPPON);
	flshaddr =(unsigned char far *)((unsigned long)flshblkseg<<16);

	_disable();     /* disable interrupts */


	for (n=0; n<numbytes;n++)
	{
		*(flshaddr+n) = C_PROG;           /* program setup */

		*(flshaddr+n) = datablk[n];       /* write data */

		*(flshaddr+n) = C_RDSTATUS;          /* read status */

		for(m=0;;m++)
		{
			outp(WDTMR, 0); /* strobe watchdog timer */

			status = *(flshaddr+n);      /* read the status */
			/* keep polling register until done */
			if (status & WRSTATE)
				break;
		}

		#ifdef DEBUG
		printf("status = %02X, m=%d\n", status, m);
		#endif

		if (status & VPPSTATUS)
			error = E_VPPLOW;
		else if (status & PROGSTAT)
			error = E_BYTEPROG;
		else
			error = NOERROR;

		*(flshaddr+n) = C_READ;      /* put flash back in read mode */

		if (!error)
			if(*(flshaddr+n) != datablk[n])
				error = E_BYTEPROG;

		if (error)
			break;
	}

	if (error)
		*flshaddr = C_CLRSTAT;   /* clear status register if needed */

	*flshaddr = C_READ;      /* put flash back in read mode */

	_enable();      /* enable interrupts */
	Vpp(VPPOFF);


	return(error);
}

/*---------------------------------------------------------------------------
 *      int ProgByte (unsigned char far * flshaddr, unsigned char databyte)
 *
 *      This routine programs a single byte into the flash.
 *
 *
 *      On entry:    flshaddr is a pointer to an address in flash
 *                   databyte is the data to program into flash
 *
 *      On exit:     -
 *
 *      Returns:     0 if no error
 *                   an error code if an error occurs
 *
 *--------------------------------------------------------------------------*/
int ProgByte (unsigned char far * flshaddr, unsigned char databyte)
{
	unsigned char status;
	int error, m;

	Vpp(VPPON);

	_disable();     /* disable interrupts */


	*(flshaddr) = C_PROG;           /* program setup */

	*(flshaddr) = databyte;         /* write data */

	*(flshaddr) = C_RDSTATUS;          /* read status */

	for(m=0;;m++)
	{
		outp(WDTMR,0); /* strobe watchdog timer */

		status = *(flshaddr);      /* read the status */
		/* keep polling register until done */
		if (status & WRSTATE)
			break;
	}

	if (status & VPPSTATUS)
		error = E_VPPLOW;
	else if (status & PROGSTAT)
		error = E_BYTEPROG;
	else
		error = NOERROR;

	if (error)
		*flshaddr = C_CLRSTAT;   /* clear status register if needed */

	*flshaddr = C_READ;      /* put flash back in read mode */

	_enable();      /* enable interrupts */
	Vpp(VPPOFF);

	return(error);
}


/*---------------------------------------------------------------------------
 *      OpenChipSelect
 *
 *      This routine makes the entire flash device visible in the memory
 *      map.  During normal operation, the flash is only visible in the
 *      top 64k of the map (F000:0-F000:FFFF).  In order to access data
 *      in the lower part of the flash, this routine reprograms the
 *      chip-selects so that the flash is visible in the top 128k
 *      (E000:0-F000:FFFF).
 *
 *
 *      On entry:    -
 *
 *      On exit:     -
 *
 *      Returns:     -
 *
 *--------------------------------------------------------------------------*/
void OpenChipSelect(void)
{

	/* clear bit 3 to disable offboard memory */
	outpw(GCS5SP, inpw(GCS5SP) & 0xFFF7);

	/* set UCS start to E000:0, use previous number of wait-states */
	outpw(UCSST, (inpw(UCSST) & 0x000F) + 0xE000);

}

/*---------------------------------------------------------------------------
 *      RestoreChipSelect
 *
 *      This routine makes only the top 64k of the flash device visible
 *      in the memory map.  (F000:0-F000:FFFF).  This is the default
 *      state of the flash during normal operation.
 *
 *
 *      On entry:    -
 *
 *      On exit:     -
 *
 *      Returns:     -
 *
 *--------------------------------------------------------------------------*/
void RestoreChipSelect(void)
{
	/* now restore the registers */

	/* set UCS start to F000:0, use previous number of wait-states */
	outpw(UCSST, (inpw(UCSST) & 0x000F) + 0xF000);

	/* set bit 3 to enable offboard memory */
	outpw(GCS5SP, inpw(GCS5SP) | 8);
}

void main(void)
{
	unsigned id;
	int retval, key, n;
	unsigned char dtabuff[30];


	id = GetFlashID(0xF000);
	printf("The flash id is %04X\n", id);


	for(;;)
	{
		printf("-------------------------------------\n");
		printf("1. Read block\n");
		printf("2. Program block\n");
		printf("3. Erase block\n");

		key = getch();

		switch(key)
		{
			case '1':
				printf("Bottom 10 bytes of flash\n");

				OpenChipSelect();

				/* the 8k parameter block of the flash is now
				   visible in segment E000 */
				id = GetFlashID(0xE000);

				for(n=0;n<10;n++)
				{
					dtabuff[n] = *(((unsigned char far *)0xE0000000L)+n);
				}
				RestoreChipSelect();

				printf("The flash id is %04X\n", id);

				for(n=0;n<10;n++)
					printf("%02X ", dtabuff[n]);

				printf("\n");
				break;
			case '2':
				dtabuff[0]= 0x12;
				dtabuff[1]= 0x34;
				dtabuff[2]= 0x56;
				dtabuff[3]= 0x78;
				dtabuff[4]= 0x9A;
				dtabuff[5]= 0xBC;
				dtabuff[6]= 0x5A;
				dtabuff[7]= 0x5A;
				dtabuff[8]= 0x43;
				dtabuff[9]= 0x21;
				printf("Programming flash\n");

				OpenChipSelect();

				/* the 8k parameter block of the flash is now
				   visible at segment E000 */

				/* any programming of the flash can now be done */

				retval = ProgFlash((unsigned char *)dtabuff,
					0xE000,
					10);
				RestoreChipSelect();

				if(retval)
					printf("return value = %d\n", retval);
				else
					printf("Flash programmed\n");
				break;
			case '3':
				printf("Erasing flash\n");

				OpenChipSelect();

				/* the 8k parameter block of the flash is now
				   visible at segment E000 */

				retval = EraseBlock(0xE000);

				RestoreChipSelect();

				if(retval)
					printf("return value = %d\n", retval);
				else
					printf("Flash erased\n");

				break;

			default:
				printf("Invalid selection\n");
		}
	}

}