// SPDX-License-Identifier: GPL-2.0+
/*
 * Porting to u-boot:
 *
 * (C) Copyright 2010
 * Stefano Babic, DENX Software Engineering, sbabic@denx.de.
 *
 * Lattice ispVME Embedded code to load Lattice's FPGA:
 *
 * Copyright 2009 Lattice Semiconductor Corp.
 *
 * ispVME Embedded allows programming of Lattice's suite of FPGA
 * devices on embedded systems through the JTAG port.  The software
 * is distributed in source code form and is open to re - distribution
 * and modification where applicable.
 *
 * Revision History of ivm_core.c module:
 * 4/25/06 ht   Change some variables from unsigned short or int
 *              to long int to make the code compiler independent.
 * 5/24/06 ht   Support using RESET (TRST) pin as a special purpose
 *              control pin such as triggering the loading of known
 *              state exit.
 * 3/6/07 ht added functions to support output to terminals
 *
 * 09/11/07 NN Type cast mismatch variables
 *		   Moved the sclock() function to hardware.c
 * 08/28/08 NN Added Calculate checksum support.
 * 4/1/09 Nguyen replaced the recursive function call codes on
 *        the ispVMLCOUNT function
 */

#include <common.h>
#include <linux/string.h>
#include <malloc.h>
#include <lattice.h>

#define vme_out_char(c)	printf("%c", c)
#define vme_out_hex(c)	printf("%x", c)
#define vme_out_string(s) printf("%s", s)

/*
 *
 * Global variables used to specify the flow control and data type.
 *
 *	g_usFlowControl:	flow control register. Each bit in the
 *                               register can potentially change the
 *                               personality of the embedded engine.
 *	g_usDataType:		holds the data type of the current row.
 *
 */

static unsigned short g_usFlowControl;
unsigned short g_usDataType;

/*
 *
 * Global variables used to specify the ENDDR and ENDIR.
 *
 *	g_ucEndDR:		the state that the device goes to after SDR.
 *	g_ucEndIR:		the state that the device goes to after SIR.
 *
 */

unsigned char g_ucEndDR = DRPAUSE;
unsigned char g_ucEndIR = IRPAUSE;

/*
 *
 * Global variables used to support header/trailer.
 *
 *	g_usHeadDR:		the number of lead devices in bypass.
 *	g_usHeadIR:		the sum of IR length of lead devices.
 *	g_usTailDR:		the number of tail devices in bypass.
 *	g_usTailIR:		the sum of IR length of tail devices.
 *
 */

static unsigned short g_usHeadDR;
static unsigned short g_usHeadIR;
static unsigned short g_usTailDR;
static unsigned short g_usTailIR;

/*
 *
 * Global variable to store the number of bits of data or instruction
 * to be shifted into or out from the device.
 *
 */

static unsigned short g_usiDataSize;

/*
 *
 * Stores the frequency. Default to 1 MHz.
 *
 */

static int g_iFrequency = 1000;

/*
 *
 * Stores the maximum amount of ram needed to hold a row of data.
 *
 */

static unsigned short g_usMaxSize;

/*
 *
 * Stores the LSH or RSH value.
 *
 */

static unsigned short g_usShiftValue;

/*
 *
 * Stores the current repeat loop value.
 *
 */

static unsigned short g_usRepeatLoops;

/*
 *
 * Stores the current vendor.
 *
 */

static signed char g_cVendor = LATTICE;

/*
 *
 * Stores the VME file CRC.
 *
 */

unsigned short g_usCalculatedCRC;

/*
 *
 * Stores the Device Checksum.
 *
 */
/* 08/28/08 NN Added Calculate checksum support. */
unsigned long g_usChecksum;
static unsigned int g_uiChecksumIndex;

/*
 *
 * Stores the current state of the JTAG state machine.
 *
 */

static signed char g_cCurrentJTAGState;

/*
 *
 * Global variables used to support looping.
 *
 *	g_pucHeapMemory:	holds the entire repeat loop.
 *	g_iHeapCounter:		points to the current byte in the repeat loop.
 *	g_iHEAPSize:		the current size of the repeat in bytes.
 *
 */

unsigned char *g_pucHeapMemory;
unsigned short g_iHeapCounter;
unsigned short g_iHEAPSize;
static unsigned short previous_size;

/*
 *
 * Global variables used to support intelligent programming.
 *
 *	g_usIntelDataIndex:     points to the current byte of the
 *                               intelligent buffer.
 *	g_usIntelBufferSize:	holds the size of the intelligent
 *                               buffer.
 *
 */

unsigned short g_usIntelDataIndex;
unsigned short g_usIntelBufferSize;

/*
 *
 * Supported VME versions.
 *
 */

const char *const g_szSupportedVersions[] = {
	"__VME2.0", "__VME3.0", "____12.0", "____12.1", 0};

/*
 *
 * Holds the maximum size of each respective buffer. These variables are used
 * to write the HEX files when converting VME to HEX.
 *
*/

static unsigned short g_usTDOSize;
static unsigned short g_usMASKSize;
static unsigned short g_usTDISize;
static unsigned short g_usDMASKSize;
static unsigned short g_usLCOUNTSize;
static unsigned short g_usHDRSize;
static unsigned short g_usTDRSize;
static unsigned short g_usHIRSize;
static unsigned short g_usTIRSize;
static unsigned short g_usHeapSize;

/*
 *
 * Global variables used to store data.
 *
 *	g_pucOutMaskData:	local RAM to hold one row of MASK data.
 *	g_pucInData:		local RAM to hold one row of TDI data.
 *	g_pucOutData:		local RAM to hold one row of TDO data.
 *	g_pucHIRData:		local RAM to hold the current SIR header.
 *	g_pucTIRData:		local RAM to hold the current SIR trailer.
 *	g_pucHDRData:		local RAM to hold the current SDR header.
 *	g_pucTDRData:		local RAM to hold the current SDR trailer.
 *	g_pucIntelBuffer:	local RAM to hold the current intelligent buffer
 *	g_pucOutDMaskData:	local RAM to hold one row of DMASK data.
 *
 */

unsigned char	*g_pucOutMaskData	= NULL,
		*g_pucInData		= NULL,
		*g_pucOutData		= NULL,
		*g_pucHIRData		= NULL,
		*g_pucTIRData		= NULL,
		*g_pucHDRData		= NULL,
		*g_pucTDRData		= NULL,
		*g_pucIntelBuffer	= NULL,
		*g_pucOutDMaskData	= NULL;

/*
 *
 * JTAG state machine transition table.
 *
 */

struct {
	 unsigned char  CurState;  /* From this state */
	 unsigned char  NextState; /* Step to this state */
	 unsigned char  Pattern;   /* The tragetory of TMS */
	 unsigned char  Pulses;    /* The number of steps */
} g_JTAGTransistions[25] = {
{ RESET,	RESET,		0xFC, 6 },	/* Transitions from RESET */
{ RESET,	IDLE,		0x00, 1 },
{ RESET,	DRPAUSE,	0x50, 5 },
{ RESET,	IRPAUSE,	0x68, 6 },
{ IDLE,		RESET,		0xE0, 3 },	/* Transitions from IDLE */
{ IDLE,		DRPAUSE,	0xA0, 4 },
{ IDLE,		IRPAUSE,	0xD0, 5 },
{ DRPAUSE,	RESET,		0xF8, 5 },	/* Transitions from DRPAUSE */
{ DRPAUSE,	IDLE,		0xC0, 3 },
{ DRPAUSE,	IRPAUSE,	0xF4, 7 },
{ DRPAUSE,	DRPAUSE,	0xE8, 6 },/* 06/14/06 Support POLL STATUS LOOP*/
{ IRPAUSE,	RESET,		0xF8, 5 },	/* Transitions from IRPAUSE */
{ IRPAUSE,	IDLE,		0xC0, 3 },
{ IRPAUSE,	DRPAUSE,	0xE8, 6 },
{ DRPAUSE,	SHIFTDR,	0x80, 2 }, /* Extra transitions using SHIFTDR */
{ IRPAUSE,	SHIFTDR,	0xE0, 5 },
{ SHIFTDR,	DRPAUSE,	0x80, 2 },
{ SHIFTDR,	IDLE,		0xC0, 3 },
{ IRPAUSE,	SHIFTIR,	0x80, 2 },/* Extra transitions using SHIFTIR */
{ SHIFTIR,	IRPAUSE,	0x80, 2 },
{ SHIFTIR,	IDLE,		0xC0, 3 },
{ DRPAUSE,	DRCAPTURE,	0xE0, 4 }, /* 11/15/05 Support DRCAPTURE*/
{ DRCAPTURE, DRPAUSE,	0x80, 2 },
{ IDLE,     DRCAPTURE,	0x80, 2 },
{ IRPAUSE,  DRCAPTURE,  0xE0, 4 }
};

/*
 *
 * List to hold all LVDS pairs.
 *
 */

LVDSPair *g_pLVDSList;
unsigned short g_usLVDSPairCount;

/*
 *
 * Function prototypes.
 *
 */

static signed char ispVMDataCode(void);
static long int ispVMDataSize(void);
static void ispVMData(unsigned char *Data);
static signed char ispVMShift(signed char Code);
static signed char ispVMAmble(signed char Code);
static signed char ispVMLoop(unsigned short a_usLoopCount);
static signed char ispVMBitShift(signed char mode, unsigned short bits);
static void ispVMComment(unsigned short a_usCommentSize);
static void ispVMHeader(unsigned short a_usHeaderSize);
static signed char ispVMLCOUNT(unsigned short a_usCountSize);
static void ispVMClocks(unsigned short Clocks);
static void ispVMBypass(signed char ScanType, unsigned short Bits);
static void ispVMStateMachine(signed char NextState);
static signed char ispVMSend(unsigned short int);
static signed char ispVMRead(unsigned short int);
static signed char ispVMReadandSave(unsigned short int);
static signed char ispVMProcessLVDS(unsigned short a_usLVDSCount);
static void ispVMMemManager(signed char types, unsigned short size);

/*
 *
 * External variables and functions in hardware.c module
 *
 */
static signed char g_cCurrentJTAGState;

#ifdef DEBUG

/*
 *
 * GetState
 *
 * Returns the state as a string based on the opcode. Only used
 * for debugging purposes.
 *
 */

const char *GetState(unsigned char a_ucState)
{
	switch (a_ucState) {
	case RESET:
		return "RESET";
	case IDLE:
		return "IDLE";
	case IRPAUSE:
		return "IRPAUSE";
	case DRPAUSE:
		return "DRPAUSE";
	case SHIFTIR:
		return "SHIFTIR";
	case SHIFTDR:
		return "SHIFTDR";
	case DRCAPTURE:/* 11/15/05 support DRCAPTURE*/
		return "DRCAPTURE";
	default:
		break;
	}

	return 0;
}

/*
 *
 * PrintData
 *
 * Prints the data. Only used for debugging purposes.
 *
 */

void PrintData(unsigned short a_iDataSize, unsigned char *a_pucData)
{
	/* 09/11/07 NN added local variables initialization */
	unsigned short usByteSize  = 0;
	unsigned short usBitIndex  = 0;
	signed short usByteIndex   = 0;
	unsigned char ucByte       = 0;
	unsigned char ucFlipByte   = 0;

	if (a_iDataSize % 8) {
		/* 09/11/07 NN Type cast mismatch variables */
		usByteSize = (unsigned short)(a_iDataSize / 8 + 1);
	} else {
		/* 09/11/07 NN Type cast mismatch variables */
		usByteSize = (unsigned short)(a_iDataSize / 8);
	}
	puts("(");
	/* 09/11/07 NN Type cast mismatch variables */
	for (usByteIndex = (signed short)(usByteSize - 1);
		usByteIndex >= 0; usByteIndex--) {
		ucByte = a_pucData[usByteIndex];
		ucFlipByte = 0x00;

		/*
		*
		* Flip each byte.
		*
		*/

		for (usBitIndex = 0; usBitIndex < 8; usBitIndex++) {
			ucFlipByte <<= 1;
			if (ucByte & 0x1) {
				ucFlipByte |= 0x1;
			}

			ucByte >>= 1;
		}

		/*
		*
		* Print the flipped byte.
		*
		*/

		printf("%.02X", ucFlipByte);
		if ((usByteSize - usByteIndex) % 40 == 39) {
			puts("\n\t\t");
		}
		if (usByteIndex < 0)
			break;
	}
	puts(")");
}
#endif /* DEBUG */

void ispVMMemManager(signed char cTarget, unsigned short usSize)
{
	switch (cTarget) {
	case XTDI:
	case TDI:
		if (g_pucInData != NULL) {
			if (previous_size == usSize) {/*memory exist*/
				break;
			} else {
				free(g_pucInData);
				g_pucInData = NULL;
			}
		}
		g_pucInData = (unsigned char *) malloc(usSize / 8 + 2);
		previous_size = usSize;
	case XTDO:
	case TDO:
		if (g_pucOutData != NULL) {
			if (previous_size == usSize) { /*already exist*/
				break;
			} else {
				free(g_pucOutData);
				g_pucOutData = NULL;
			}
		}
		g_pucOutData = (unsigned char *) malloc(usSize / 8 + 2);
		previous_size = usSize;
		break;
	case MASK:
		if (g_pucOutMaskData != NULL) {
			if (previous_size == usSize) {/*already allocated*/
				break;
			} else {
				free(g_pucOutMaskData);
				g_pucOutMaskData = NULL;
			}
		}
		g_pucOutMaskData = (unsigned char *) malloc(usSize / 8 + 2);
		previous_size = usSize;
		break;
	case HIR:
		if (g_pucHIRData != NULL) {
			free(g_pucHIRData);
			g_pucHIRData = NULL;
		}
		g_pucHIRData = (unsigned char *) malloc(usSize / 8 + 2);
		break;
	case TIR:
		if (g_pucTIRData != NULL) {
			free(g_pucTIRData);
			g_pucTIRData = NULL;
		}
		g_pucTIRData = (unsigned char *) malloc(usSize / 8 + 2);
		break;
	case HDR:
		if (g_pucHDRData != NULL) {
			free(g_pucHDRData);
			g_pucHDRData = NULL;
		}
		g_pucHDRData = (unsigned char *) malloc(usSize / 8 + 2);
		break;
	case TDR:
		if (g_pucTDRData != NULL) {
			free(g_pucTDRData);
			g_pucTDRData = NULL;
		}
		g_pucTDRData = (unsigned char *) malloc(usSize / 8 + 2);
		break;
	case HEAP:
		if (g_pucHeapMemory != NULL) {
			free(g_pucHeapMemory);
			g_pucHeapMemory = NULL;
		}
		g_pucHeapMemory = (unsigned char *) malloc(usSize + 2);
		break;
	case DMASK:
		if (g_pucOutDMaskData != NULL) {
			if (previous_size == usSize) { /*already allocated*/
				break;
			} else {
				free(g_pucOutDMaskData);
				g_pucOutDMaskData = NULL;
			}
		}
		g_pucOutDMaskData = (unsigned char *) malloc(usSize / 8 + 2);
		previous_size = usSize;
		break;
	case LHEAP:
		if (g_pucIntelBuffer != NULL) {
			free(g_pucIntelBuffer);
			g_pucIntelBuffer = NULL;
		}
		g_pucIntelBuffer = (unsigned char *) malloc(usSize + 2);
		break;
	case LVDS:
		if (g_pLVDSList != NULL) {
			free(g_pLVDSList);
			g_pLVDSList = NULL;
		}
		g_pLVDSList = (LVDSPair *) malloc(usSize * sizeof(LVDSPair));
		if (g_pLVDSList)
			memset(g_pLVDSList, 0, usSize * sizeof(LVDSPair));
		break;
	default:
		return;
    }
}

void ispVMFreeMem(void)
{
	if (g_pucHeapMemory != NULL) {
		free(g_pucHeapMemory);
		g_pucHeapMemory = NULL;
	}

	if (g_pucOutMaskData != NULL) {
		free(g_pucOutMaskData);
		g_pucOutMaskData = NULL;
	}

	if (g_pucInData != NULL) {
		free(g_pucInData);
		g_pucInData = NULL;
	}

	if (g_pucOutData != NULL) {
		free(g_pucOutData);
		g_pucOutData = NULL;
	}

	if (g_pucHIRData != NULL) {
		free(g_pucHIRData);
		g_pucHIRData = NULL;
	}

	if (g_pucTIRData != NULL) {
		free(g_pucTIRData);
		g_pucTIRData = NULL;
	}

	if (g_pucHDRData != NULL) {
		free(g_pucHDRData);
		g_pucHDRData = NULL;
	}

	if (g_pucTDRData != NULL) {
		free(g_pucTDRData);
		g_pucTDRData = NULL;
	}

	if (g_pucOutDMaskData != NULL) {
		free(g_pucOutDMaskData);
		g_pucOutDMaskData = NULL;
	}

	if (g_pucIntelBuffer != NULL) {
		free(g_pucIntelBuffer);
		g_pucIntelBuffer = NULL;
	}

	if (g_pLVDSList != NULL) {
		free(g_pLVDSList);
		g_pLVDSList = NULL;
	}
}


/*
 *
 * ispVMDataSize
 *
 * Returns a VME-encoded number, usually used to indicate the
 * bit length of an SIR/SDR command.
 *
 */

long int ispVMDataSize()
{
	/* 09/11/07 NN added local variables initialization */
	long int iSize           = 0;
	signed char cCurrentByte = 0;
	signed char cIndex       = 0;
	cIndex = 0;
	while ((cCurrentByte = GetByte()) & 0x80) {
		iSize |= ((long int) (cCurrentByte & 0x7F)) << cIndex;
		cIndex += 7;
	}
	iSize |= ((long int) (cCurrentByte & 0x7F)) << cIndex;
	return iSize;
}

/*
 *
 * ispVMCode
 *
 * This is the heart of the embedded engine. All the high-level opcodes
 * are extracted here. Once they have been identified, then it
 * will call other functions to handle the processing.
 *
 */

signed char ispVMCode()
{
	/* 09/11/07 NN added local variables initialization */
	unsigned short iRepeatSize = 0;
	signed char cOpcode	   = 0;
	signed char cRetCode       = 0;
	unsigned char ucState      = 0;
	unsigned short usDelay     = 0;
	unsigned short usToggle    = 0;
	unsigned char usByte       = 0;

	/*
	*
	* Check the compression flag only if this is the first time
	* this function is entered. Do not check the compression flag if
	* it is being called recursively from other functions within
	* the embedded engine.
	*
	*/

	if (!(g_usDataType & LHEAP_IN) && !(g_usDataType & HEAP_IN)) {
		usByte = GetByte();
		if (usByte == 0xf1) {
			g_usDataType |= COMPRESS;
		} else if (usByte == 0xf2) {
			g_usDataType &= ~COMPRESS;
		} else {
			return VME_INVALID_FILE;
		}
	}

	/*
	*
	* Begin looping through all the VME opcodes.
	*
	*/

	while ((cOpcode = GetByte()) >= 0) {

		switch (cOpcode) {
		case STATE:

			/*
			 * Step the JTAG state machine.
			 */

			ucState = GetByte();

			/*
			 * Step the JTAG state machine to DRCAPTURE
			 * to support Looping.
			 */

			if ((g_usDataType & LHEAP_IN) &&
				 (ucState == DRPAUSE) &&
				 (g_cCurrentJTAGState == ucState)) {
				ispVMStateMachine(DRCAPTURE);
			}

			ispVMStateMachine(ucState);

#ifdef DEBUG
			if (g_usDataType & LHEAP_IN) {
				debug("LDELAY %s ", GetState(ucState));
			} else {
				debug("STATE %s;\n", GetState(ucState));
			}
#endif /* DEBUG */
			break;
		case SIR:
		case SDR:
		case XSDR:

#ifdef DEBUG
			switch (cOpcode) {
			case SIR:
				puts("SIR ");
				break;
			case SDR:
			case XSDR:
				if (g_usDataType & LHEAP_IN) {
					puts("LSDR ");
				} else {
					puts("SDR ");
				}
				break;
			}
#endif /* DEBUG */
			/*
			*
			* Shift in data into the device.
			*
			*/

			cRetCode = ispVMShift(cOpcode);
			if (cRetCode != 0) {
				return cRetCode;
			}
			break;
		case WAIT:

			/*
			*
			* Observe delay.
			*
			*/

			/* 09/11/07 NN Type cast mismatch variables */
			usDelay = (unsigned short) ispVMDataSize();
			ispVMDelay(usDelay);

#ifdef DEBUG
			if (usDelay & 0x8000) {

				/*
				 * Since MSB is set, the delay time must be
				 * decoded to millisecond. The SVF2VME encodes
				 * the MSB to represent millisecond.
				 */

				usDelay &= ~0x8000;
				if (g_usDataType & LHEAP_IN) {
					printf("%.2E SEC;\n",
						(float) usDelay / 1000);
				} else {
					printf("RUNTEST %.2E SEC;\n",
						(float) usDelay / 1000);
				}
			} else {
				/*
				 * Since MSB is not set, the delay time
				 * is given as microseconds.
				 */

				if (g_usDataType & LHEAP_IN) {
					printf("%.2E SEC;\n",
						(float) usDelay / 1000000);
				} else {
					printf("RUNTEST %.2E SEC;\n",
						(float) usDelay / 1000000);
				}
			}
#endif /* DEBUG */
			break;
		case TCK:

			/*
			 * Issue clock toggles.
			*/

			/* 09/11/07 NN Type cast mismatch variables */
			usToggle = (unsigned short) ispVMDataSize();
			ispVMClocks(usToggle);

#ifdef DEBUG
			printf("RUNTEST %d TCK;\n", usToggle);
#endif /* DEBUG */
			break;
		case ENDDR:

			/*
			*
			* Set the ENDDR.
			*
			*/

			g_ucEndDR = GetByte();

#ifdef DEBUG
			printf("ENDDR %s;\n", GetState(g_ucEndDR));
#endif /* DEBUG */
			break;
		case ENDIR:

			/*
			*
			* Set the ENDIR.
			*
			*/

			g_ucEndIR = GetByte();

#ifdef DEBUG
			printf("ENDIR %s;\n", GetState(g_ucEndIR));
#endif /* DEBUG */
			break;
		case HIR:
		case TIR:
		case HDR:
		case TDR:

#ifdef DEBUG
			switch (cOpcode) {
			case HIR:
				puts("HIR ");
				break;
			case TIR:
				puts("TIR ");
				break;
			case HDR:
				puts("HDR ");
				break;
			case TDR:
				puts("TDR ");
				break;
			}
#endif /* DEBUG */
			/*
			 * Set the header/trailer of the device in order
			 * to bypass
			 * successfully.
			 */

			cRetCode = ispVMAmble(cOpcode);
			if (cRetCode != 0) {
				return cRetCode;
			}

#ifdef DEBUG
			puts(";\n");
#endif /* DEBUG */
			break;
		case MEM:

			/*
			 * The maximum RAM required to support
			 * processing one row of the VME file.
			 */

			/* 09/11/07 NN Type cast mismatch variables */
			g_usMaxSize = (unsigned short) ispVMDataSize();

#ifdef DEBUG
			printf("// MEMSIZE %d\n", g_usMaxSize);
#endif /* DEBUG */
			break;
		case VENDOR:

			/*
			*
			* Set the VENDOR type.
			*
			*/

			cOpcode = GetByte();
			switch (cOpcode) {
			case LATTICE:
#ifdef DEBUG
				puts("// VENDOR LATTICE\n");
#endif /* DEBUG */
				g_cVendor = LATTICE;
				break;
			case ALTERA:
#ifdef DEBUG
				puts("// VENDOR ALTERA\n");
#endif /* DEBUG */
				g_cVendor = ALTERA;
				break;
			case XILINX:
#ifdef DEBUG
				puts("// VENDOR XILINX\n");
#endif /* DEBUG */
				g_cVendor = XILINX;
				break;
			default:
				break;
			}
			break;
		case SETFLOW:

			/*
			 * Set the flow control. Flow control determines
			 * the personality of the embedded engine.
			 */

			/* 09/11/07 NN Type cast mismatch variables */
			g_usFlowControl |= (unsigned short) ispVMDataSize();
			break;
		case RESETFLOW:

			/*
			*
			* Unset the flow control.
			*
			*/

			/* 09/11/07 NN Type cast mismatch variables */
			g_usFlowControl &= (unsigned short) ~(ispVMDataSize());
			break;
		case HEAP:

			/*
			*
			* Allocate heap size to store loops.
			*
			*/

			cRetCode = GetByte();
			if (cRetCode != SECUREHEAP) {
				return VME_INVALID_FILE;
			}
			/* 09/11/07 NN Type cast mismatch variables */
			g_iHEAPSize = (unsigned short) ispVMDataSize();

			/*
			 * Store the maximum size of the HEAP buffer.
			 * Used to convert VME to HEX.
			 */

			if (g_iHEAPSize > g_usHeapSize) {
				g_usHeapSize = g_iHEAPSize;
			}

			ispVMMemManager(HEAP, (unsigned short) g_iHEAPSize);
			break;
		case REPEAT:

			/*
			*
			* Execute loops.
			*
			*/

			g_usRepeatLoops = 0;

			/* 09/11/07 NN Type cast mismatch variables */
			iRepeatSize = (unsigned short) ispVMDataSize();

			cRetCode = ispVMLoop((unsigned short) iRepeatSize);
			if (cRetCode != 0) {
				return cRetCode;
			}
			break;
		case ENDLOOP:

			/*
			*
			* Exit point from processing loops.
			*
			*/

			return cRetCode;
		case ENDVME:

			/*
			 * The only valid exit point that indicates
			 * end of programming.
			 */

			return cRetCode;
		case SHR:

			/*
			*
			* Right-shift address.
			*
			*/

			g_usFlowControl |= SHIFTRIGHT;

			/* 09/11/07 NN Type cast mismatch variables */
			g_usShiftValue = (unsigned short) (g_usRepeatLoops *
				(unsigned short)GetByte());
			break;
		case SHL:

			/*
			 * Left-shift address.
			 */

			g_usFlowControl |= SHIFTLEFT;

			/* 09/11/07 NN Type cast mismatch variables */
			g_usShiftValue = (unsigned short) (g_usRepeatLoops *
				(unsigned short)GetByte());
			break;
		case FREQUENCY:

			/*
			*
			* Set the frequency.
			*
			*/

			/* 09/11/07 NN Type cast mismatch variables */
			g_iFrequency = (int) (ispVMDataSize() / 1000);
			if (g_iFrequency == 1)
				g_iFrequency = 1000;

#ifdef DEBUG
			printf("FREQUENCY %.2E HZ;\n",
				(float) g_iFrequency * 1000);
#endif /* DEBUG */
			break;
		case LCOUNT:

			/*
			*
			* Process LCOUNT command.
			*
			*/

			cRetCode = ispVMLCOUNT((unsigned short)ispVMDataSize());
			if (cRetCode != 0) {
				return cRetCode;
			}
			break;
		case VUES:

			/*
			*
			* Set the flow control to verify USERCODE.
			*
			*/

			g_usFlowControl |= VERIFYUES;
			break;
		case COMMENT:

			/*
			*
			* Display comment.
			*
			*/

			ispVMComment((unsigned short) ispVMDataSize());
			break;
		case LVDS:

			/*
			*
			* Process LVDS command.
			*
			*/

			ispVMProcessLVDS((unsigned short) ispVMDataSize());
			break;
		case HEADER:

			/*
			*
			* Discard header.
			*
			*/

			ispVMHeader((unsigned short) ispVMDataSize());
			break;
		/* 03/14/06 Support Toggle ispENABLE signal*/
		case ispEN:
			ucState = GetByte();
			if ((ucState == ON) || (ucState == 0x01))
				writePort(g_ucPinENABLE, 0x01);
			else
				writePort(g_ucPinENABLE, 0x00);
			ispVMDelay(1);
			break;
		/* 05/24/06 support Toggle TRST pin*/
		case TRST:
			ucState = GetByte();
			if (ucState == 0x01)
				writePort(g_ucPinTRST, 0x01);
			else
				writePort(g_ucPinTRST, 0x00);
			ispVMDelay(1);
			break;
		default:

			/*
			*
			* Invalid opcode encountered.
			*
			*/

#ifdef DEBUG
			printf("\nINVALID OPCODE: 0x%.2X\n", cOpcode);
#endif /* DEBUG */

			return VME_INVALID_FILE;
		}
	}

	/*
	*
	* Invalid exit point. Processing the token 'ENDVME' is the only
	* valid way to exit the embedded engine.
	*
	*/

	return VME_INVALID_FILE;
}

/*
 *
 * ispVMDataCode
 *
 * Processes the TDI/TDO/MASK/DMASK etc of an SIR/SDR command.
 *
 */

signed char ispVMDataCode()
{
	/* 09/11/07 NN added local variables initialization */
	signed char cDataByte    = 0;
	signed char siDataSource = 0;  /*source of data from file by default*/

	if (g_usDataType & HEAP_IN) {
		siDataSource = 1;  /*the source of data from memory*/
	}

	/*
	*
	* Clear the data type register.
	*
	**/

	g_usDataType &= ~(MASK_DATA + TDI_DATA +
		TDO_DATA + DMASK_DATA + CMASK_DATA);

	/*
	 * Iterate through SIR/SDR command and look for TDI,
	 * TDO, MASK, etc.
	 */

	while ((cDataByte = GetByte()) >= 0) {
			ispVMMemManager(cDataByte, g_usMaxSize);
			switch (cDataByte) {
			case TDI:

				/*
				 * Store the maximum size of the TDI buffer.
				 * Used to convert VME to HEX.
				 */

				if (g_usiDataSize > g_usTDISize) {
					g_usTDISize = g_usiDataSize;
				}
				/*
				 * Updated data type register to indicate that
				 * TDI data is currently being used. Process the
				 * data in the VME file into the TDI buffer.
				 */

				g_usDataType |= TDI_DATA;
				ispVMData(g_pucInData);
				break;
			case XTDO:

				/*
				 * Store the maximum size of the TDO buffer.
				 * Used to convert VME to HEX.
				 */

				if (g_usiDataSize > g_usTDOSize) {
					g_usTDOSize = g_usiDataSize;
				}

				/*
				 * Updated data type register to indicate that
				 * TDO data is currently being used.
				 */

				g_usDataType |= TDO_DATA;
				break;
			case TDO:

				/*
				 * Store the maximum size of the TDO buffer.
				 * Used to convert VME to HEX.
				 */

				if (g_usiDataSize > g_usTDOSize) {
					g_usTDOSize = g_usiDataSize;
				}

				/*
				 * Updated data type register to indicate
				 * that TDO data is currently being used.
				 * Process the data in the VME file into the
				 * TDO buffer.
				 */

				g_usDataType |= TDO_DATA;
				ispVMData(g_pucOutData);
				break;
			case MASK:

				/*
				 * Store the maximum size of the MASK buffer.
				 * Used to convert VME to HEX.
				 */

				if (g_usiDataSize > g_usMASKSize) {
					g_usMASKSize = g_usiDataSize;
				}

				/*
				 * Updated data type register to indicate that
				 * MASK data is currently being used. Process
				 * the data in the VME file into the MASK buffer
				 */

				g_usDataType |= MASK_DATA;
				ispVMData(g_pucOutMaskData);
				break;
			case DMASK:

				/*
				 * Store the maximum size of the DMASK buffer.
				 * Used to convert VME to HEX.
				 */

				if (g_usiDataSize > g_usDMASKSize) {
					g_usDMASKSize = g_usiDataSize;
				}

				/*
				 * Updated data type register to indicate that
				 * DMASK data is currently being used. Process
				 * the data in the VME file into the DMASK
				 * buffer.
				 */

				g_usDataType |= DMASK_DATA;
				ispVMData(g_pucOutDMaskData);
				break;
			case CMASK:

				/*
				 * Updated data type register to indicate that
				 * MASK data is currently being used. Process
				 * the data in the VME file into the MASK buffer
				 */

				g_usDataType |= CMASK_DATA;
				ispVMData(g_pucOutMaskData);
				break;
			case CONTINUE:
				return 0;
			default:
				/*
				 * Encountered invalid opcode.
				 */
				return VME_INVALID_FILE;
			}

			switch (cDataByte) {
			case TDI:

				/*
				 * Left bit shift. Used when performing
				 * algorithm looping.
				 */

				if (g_usFlowControl & SHIFTLEFT) {
					ispVMBitShift(SHL, g_usShiftValue);
					g_usFlowControl &= ~SHIFTLEFT;
				}

				/*
				 * Right bit shift. Used when performing
				 * algorithm looping.
				 */

				if (g_usFlowControl & SHIFTRIGHT) {
					ispVMBitShift(SHR, g_usShiftValue);
					g_usFlowControl &= ~SHIFTRIGHT;
				}
			default:
				break;
			}

			if (siDataSource) {
				g_usDataType |= HEAP_IN; /*restore from memory*/
			}
	}

	if (siDataSource) {  /*fetch data from heap memory upon return*/
		g_usDataType |= HEAP_IN;
	}

	if (cDataByte < 0) {

		/*
		 * Encountered invalid opcode.
		 */

		return VME_INVALID_FILE;
	} else {
		return 0;
	}
}

/*
 *
 * ispVMData
 * Extract one row of data operand from the current data type opcode. Perform
 * the decompression if necessary. Extra RAM is not required for the
 * decompression process. The decompression scheme employed in this module
 * is on row by row basis. The format of the data stream:
 * [compression code][compressed data stream]
 * 0x00    --No compression
 * 0x01    --Compress by 0x00.
 *           Example:
 *           Original stream:   0x000000000000000000000001
 *           Compressed stream: 0x01000901
 *           Detail:            0x01 is the code, 0x00 is the key,
 *                              0x09 is the count of 0x00 bytes,
 *                              0x01 is the uncompressed byte.
 * 0x02    --Compress by 0xFF.
 *           Example:
 *           Original stream:   0xFFFFFFFFFFFFFFFFFFFFFF01
 *           Compressed stream: 0x02FF0901
 *           Detail:            0x02 is the code, 0xFF is the key,
 *                              0x09 is the count of 0xFF bytes,
 *                              0x01 is the uncompressed byte.
 * 0x03
 * : :
 * 0xFE   -- Compress by nibble blocks.
 *           Example:
 *           Original stream:   0x84210842108421084210
 *           Compressed stream: 0x0584210
 *           Detail:            0x05 is the code, means 5 nibbles block.
 *                              0x84210 is the 5 nibble blocks.
 *                              The whole row is 80 bits given by g_usiDataSize.
 *                              The number of times the block repeat itself
 *                              is found by g_usiDataSize/(4*0x05) which is 4.
 * 0xFF   -- Compress by the most frequently happen byte.
 *           Example:
 *           Original stream:   0x04020401030904040404
 *           Compressed stream: 0xFF04(0,1,0x02,0,1,0x01,1,0x03,1,0x09,0,0,0)
 *                          or: 0xFF044090181C240
 *           Detail:            0xFF is the code, 0x04 is the key.
 *                              a bit of 0 represent the key shall be put into
 *                              the current bit position and a bit of 1
 *                              represent copying the next of 8 bits of data
 *                              in.
 *
 */

void ispVMData(unsigned char *ByteData)
{
	/* 09/11/07 NN added local variables initialization */
	unsigned short size               = 0;
	unsigned short i, j, m, getData   = 0;
	unsigned char cDataByte           = 0;
	unsigned char compress            = 0;
	unsigned short FFcount            = 0;
	unsigned char compr_char          = 0xFF;
	unsigned short index              = 0;
	signed char compression           = 0;

	/*convert number in bits to bytes*/
	if (g_usiDataSize % 8 > 0) {
		/* 09/11/07 NN Type cast mismatch variables */
		size = (unsigned short)(g_usiDataSize / 8 + 1);
	} else {
		/* 09/11/07 NN Type cast mismatch variables */
		size = (unsigned short)(g_usiDataSize / 8);
	}

	/*
	 * If there is compression, then check if compress by key
	 * of 0x00 or 0xFF or by other keys or by nibble blocks
	 */

	if (g_usDataType & COMPRESS) {
		compression = 1;
		compress = GetByte();
		if ((compress  == VAR) && (g_usDataType & HEAP_IN)) {
			getData = 1;
			g_usDataType &= ~(HEAP_IN);
			compress = GetByte();
		}

		switch (compress) {
		case 0x00:
			/* No compression */
			compression = 0;
			break;
		case 0x01:
			/* Compress by byte 0x00 */
			compr_char = 0x00;
			break;
		case 0x02:
			/* Compress by byte 0xFF */
			compr_char = 0xFF;
			break;
		case 0xFF:
			/* Huffman encoding */
			compr_char = GetByte();
			i = 8;
			for (index = 0; index < size; index++) {
				ByteData[index] = 0x00;
				if (i > 7) {
					cDataByte = GetByte();
					i = 0;
				}
				if ((cDataByte << i++) & 0x80)
					m = 8;
				else {
					ByteData[index] = compr_char;
					m = 0;
				}

				for (j = 0; j < m; j++) {
					if (i > 7) {
						cDataByte = GetByte();
						i = 0;
					}
					ByteData[index] |=
					((cDataByte << i++) & 0x80) >> j;
				}
			}
			size = 0;
			break;
		default:
			for (index = 0; index < size; index++)
				ByteData[index] = 0x00;
			for (index = 0; index < compress; index++) {
				if (index % 2 == 0)
					cDataByte = GetByte();
				for (i = 0; i < size * 2 / compress; i++) {
					j = (unsigned short)(index +
						(i * (unsigned short)compress));
					/*clear the nibble to zero first*/
					if (j%2) {
						if (index % 2)
							ByteData[j/2] |=
								cDataByte & 0xF;
						else
							ByteData[j/2] |=
								cDataByte >> 4;
					} else {
						if (index % 2)
							ByteData[j/2] |=
								cDataByte << 4;
						else
							ByteData[j/2] |=
							cDataByte & 0xF0;
					}
				}
			}
			size = 0;
			break;
		}
	}

	FFcount = 0;

	/* Decompress by byte 0x00 or 0xFF */
	for (index = 0; index < size; index++) {
		if (FFcount <= 0) {
			cDataByte = GetByte();
			if ((cDataByte == VAR) && (g_usDataType&HEAP_IN) &&
				!getData && !(g_usDataType&COMPRESS)) {
				getData = 1;
				g_usDataType &= ~(HEAP_IN);
				cDataByte = GetByte();
			}
			ByteData[index] = cDataByte;
			if ((compression) && (cDataByte == compr_char))
				/* 09/11/07 NN Type cast mismatch variables */
				FFcount = (unsigned short) ispVMDataSize();
				/*The number of 0xFF or 0x00 bytes*/
		} else {
			FFcount--; /*Use up the 0xFF chain first*/
			ByteData[index] = compr_char;
		}
	}

	if (getData) {
		g_usDataType |= HEAP_IN;
		getData = 0;
	}
}

/*
 *
 * ispVMShift
 *
 * Processes the SDR/XSDR/SIR commands.
 *
 */

signed char ispVMShift(signed char a_cCode)
{
	/* 09/11/07 NN added local variables initialization */
	unsigned short iDataIndex  = 0;
	unsigned short iReadLoop   = 0;
	signed char cRetCode       = 0;

	cRetCode = 0;
	/* 09/11/07 NN Type cast mismatch variables */
	g_usiDataSize = (unsigned short) ispVMDataSize();

	/*clear the flags first*/
	g_usDataType &= ~(SIR_DATA + EXPRESS + SDR_DATA);
	switch (a_cCode) {
	case SIR:
		g_usDataType |= SIR_DATA;
		/*
		 * 1/15/04 If performing cascading, then go directly to SHIFTIR.
		 *  Else, go to IRPAUSE before going to SHIFTIR
		 */
		if (g_usFlowControl & CASCADE) {
			ispVMStateMachine(SHIFTIR);
		} else {
			ispVMStateMachine(IRPAUSE);
			ispVMStateMachine(SHIFTIR);
			if (g_usHeadIR > 0) {
				ispVMBypass(HIR, g_usHeadIR);
				sclock();
			}
		}
		break;
	case XSDR:
		g_usDataType |= EXPRESS; /*mark simultaneous in and out*/
	case SDR:
		g_usDataType |= SDR_DATA;
		/*
		 * 1/15/04 If already in SHIFTDR, then do not move state or
		 * shift in header.  This would imply that the previously
		 * shifted frame was a cascaded frame.
		 */
		if (g_cCurrentJTAGState != SHIFTDR) {
			/*
			 * 1/15/04 If performing cascading, then go directly
			 * to SHIFTDR.  Else, go to DRPAUSE before going
			 * to SHIFTDR
			 */
			if (g_usFlowControl & CASCADE) {
				if (g_cCurrentJTAGState == DRPAUSE) {
					ispVMStateMachine(SHIFTDR);
					/*
					 * 1/15/04 If cascade flag has been seat
					 * and the current state is DRPAUSE,
					 * this implies that the first cascaded
					 * frame is about to be shifted in.  The
					 * header must be shifted prior to
					 * shifting the first cascaded frame.
					 */
					if (g_usHeadDR > 0) {
						ispVMBypass(HDR, g_usHeadDR);
						sclock();
					}
				} else {
					ispVMStateMachine(SHIFTDR);
				}
			} else {
				ispVMStateMachine(DRPAUSE);
				ispVMStateMachine(SHIFTDR);
				if (g_usHeadDR > 0) {
					ispVMBypass(HDR, g_usHeadDR);
					sclock();
				}
			}
		}
		break;
	default:
		return VME_INVALID_FILE;
	}

	cRetCode = ispVMDataCode();

	if (cRetCode != 0) {
		return VME_INVALID_FILE;
	}

#ifdef DEBUG
	printf("%d ", g_usiDataSize);

	if (g_usDataType & TDI_DATA) {
		puts("TDI ");
		PrintData(g_usiDataSize, g_pucInData);
	}

	if (g_usDataType & TDO_DATA) {
		puts("\n\t\tTDO ");
		PrintData(g_usiDataSize, g_pucOutData);
	}

	if (g_usDataType & MASK_DATA) {
		puts("\n\t\tMASK ");
		PrintData(g_usiDataSize, g_pucOutMaskData);
	}

	if (g_usDataType & DMASK_DATA) {
		puts("\n\t\tDMASK ");
		PrintData(g_usiDataSize, g_pucOutDMaskData);
	}

	puts(";\n");
#endif /* DEBUG */

	if (g_usDataType & TDO_DATA || g_usDataType & DMASK_DATA) {
		if (g_usDataType & DMASK_DATA) {
			cRetCode = ispVMReadandSave(g_usiDataSize);
			if (!cRetCode) {
				if (g_usTailDR > 0) {
					sclock();
					ispVMBypass(TDR, g_usTailDR);
				}
				ispVMStateMachine(DRPAUSE);
				ispVMStateMachine(SHIFTDR);
				if (g_usHeadDR > 0) {
					ispVMBypass(HDR, g_usHeadDR);
					sclock();
				}
				for (iDataIndex = 0;
					iDataIndex < g_usiDataSize / 8 + 1;
					iDataIndex++)
					g_pucInData[iDataIndex] =
						g_pucOutData[iDataIndex];
				g_usDataType &= ~(TDO_DATA + DMASK_DATA);
				cRetCode = ispVMSend(g_usiDataSize);
			}
		} else {
			cRetCode = ispVMRead(g_usiDataSize);
			if (cRetCode == -1 && g_cVendor == XILINX) {
				for (iReadLoop = 0; iReadLoop < 30;
					iReadLoop++) {
					cRetCode = ispVMRead(g_usiDataSize);
					if (!cRetCode) {
						break;
					} else {
						/* Always DRPAUSE */
						ispVMStateMachine(DRPAUSE);
						/*
						 * Bypass other devices
						 * when appropriate
						 */
						ispVMBypass(TDR, g_usTailDR);
						ispVMStateMachine(g_ucEndDR);
						ispVMStateMachine(IDLE);
						ispVMDelay(1000);
					}
				}
			}
		}
	} else { /*TDI only*/
		cRetCode = ispVMSend(g_usiDataSize);
	}

	/*transfer the input data to the output buffer for the next verify*/
	if ((g_usDataType & EXPRESS) || (a_cCode == SDR)) {
		if (g_pucOutData) {
			for (iDataIndex = 0; iDataIndex < g_usiDataSize / 8 + 1;
				iDataIndex++)
				g_pucOutData[iDataIndex] =
					g_pucInData[iDataIndex];
		}
	}

	switch (a_cCode) {
	case SIR:
		/* 1/15/04 If not performing cascading, then shift ENDIR */
		if (!(g_usFlowControl & CASCADE)) {
			if (g_usTailIR > 0) {
				sclock();
				ispVMBypass(TIR, g_usTailIR);
			}
			ispVMStateMachine(g_ucEndIR);
		}
		break;
	case XSDR:
	case SDR:
		/* 1/15/04 If not performing cascading, then shift ENDDR */
		if (!(g_usFlowControl & CASCADE)) {
			if (g_usTailDR > 0) {
				sclock();
				ispVMBypass(TDR, g_usTailDR);
			}
			ispVMStateMachine(g_ucEndDR);
		}
		break;
	default:
		break;
	}

	return cRetCode;
}

/*
 *
 * ispVMAmble
 *
 * This routine is to extract Header and Trailer parameter for SIR and
 * SDR operations.
 *
 * The Header and Trailer parameter are the pre-amble and post-amble bit
 * stream need to be shifted into TDI or out of TDO of the devices. Mostly
 * is for the purpose of bypassing the leading or trailing devices. ispVM
 * supports only shifting data into TDI to bypass the devices.
 *
 * For a single device, the header and trailer parameters are all set to 0
 * as default by ispVM. If it is for multiple devices, the header and trailer
 * value will change as specified by the VME file.
 *
 */

signed char ispVMAmble(signed char Code)
{
	signed char compress = 0;
	/* 09/11/07 NN Type cast mismatch variables */
	g_usiDataSize = (unsigned short)ispVMDataSize();

#ifdef DEBUG
	printf("%d", g_usiDataSize);
#endif /* DEBUG */

	if (g_usiDataSize) {

		/*
		 * Discard the TDI byte and set the compression bit in the data
		 * type register to false if compression is set because TDI data
		 * after HIR/HDR/TIR/TDR is not compressed.
		 */

		GetByte();
		if (g_usDataType & COMPRESS) {
			g_usDataType &= ~(COMPRESS);
			compress = 1;
		}
	}

	switch (Code) {
	case HIR:

		/*
		 * Store the maximum size of the HIR buffer.
		 * Used to convert VME to HEX.
		 */

		if (g_usiDataSize > g_usHIRSize) {
			g_usHIRSize = g_usiDataSize;
		}

		/*
		 * Assign the HIR value and allocate memory.
		 */

		g_usHeadIR = g_usiDataSize;
		if (g_usHeadIR) {
			ispVMMemManager(HIR, g_usHeadIR);
			ispVMData(g_pucHIRData);

#ifdef DEBUG
			puts(" TDI ");
			PrintData(g_usHeadIR, g_pucHIRData);
#endif /* DEBUG */
		}
		break;
	case TIR:

		/*
		 * Store the maximum size of the TIR buffer.
		 * Used to convert VME to HEX.
		 */

		if (g_usiDataSize > g_usTIRSize) {
			g_usTIRSize = g_usiDataSize;
		}

		/*
		 * Assign the TIR value and allocate memory.
		 */

		g_usTailIR = g_usiDataSize;
		if (g_usTailIR) {
			ispVMMemManager(TIR, g_usTailIR);
			ispVMData(g_pucTIRData);

#ifdef DEBUG
			puts(" TDI ");
			PrintData(g_usTailIR, g_pucTIRData);
#endif /* DEBUG */
		}
		break;
	case HDR:

		/*
		 * Store the maximum size of the HDR buffer.
		 * Used to convert VME to HEX.
		 */

		if (g_usiDataSize > g_usHDRSize) {
			g_usHDRSize = g_usiDataSize;
		}

		/*
		 * Assign the HDR value and allocate memory.
		 *
		 */

		g_usHeadDR = g_usiDataSize;
		if (g_usHeadDR) {
			ispVMMemManager(HDR, g_usHeadDR);
			ispVMData(g_pucHDRData);

#ifdef DEBUG
			puts(" TDI ");
			PrintData(g_usHeadDR, g_pucHDRData);
#endif /* DEBUG */
		}
		break;
	case TDR:

		/*
		 * Store the maximum size of the TDR buffer.
		 * Used to convert VME to HEX.
		 */

		if (g_usiDataSize > g_usTDRSize) {
			g_usTDRSize = g_usiDataSize;
		}

		/*
		 * Assign the TDR value and allocate memory.
		 *
		 */

		g_usTailDR = g_usiDataSize;
		if (g_usTailDR) {
			ispVMMemManager(TDR, g_usTailDR);
			ispVMData(g_pucTDRData);

#ifdef DEBUG
			puts(" TDI ");
			PrintData(g_usTailDR, g_pucTDRData);
#endif /* DEBUG */
		}
		break;
	default:
		break;
	}

	/*
	*
	* Re-enable compression if it was previously set.
	*
	**/

	if (compress) {
		g_usDataType |= COMPRESS;
	}

	if (g_usiDataSize) {
		Code = GetByte();
		if (Code == CONTINUE) {
			return 0;
		} else {

			/*
			 * Encountered invalid opcode.
			 */

			return VME_INVALID_FILE;
		}
	}

	return 0;
}

/*
 *
 * ispVMLoop
 *
 * Perform the function call upon by the REPEAT opcode.
 * Memory is to be allocated to store the entire loop from REPEAT to ENDLOOP.
 * After the loop is stored then execution begin. The REPEATLOOP flag is set
 * on the g_usFlowControl register to indicate the repeat loop is in session
 * and therefore fetch opcode from the memory instead of from the file.
 *
 */

signed char ispVMLoop(unsigned short a_usLoopCount)
{
	/* 09/11/07 NN added local variables initialization */
	signed char cRetCode      = 0;
	unsigned short iHeapIndex = 0;
	unsigned short iLoopIndex = 0;

	g_usShiftValue = 0;
	for (iHeapIndex = 0; iHeapIndex < g_iHEAPSize; iHeapIndex++) {
		g_pucHeapMemory[iHeapIndex] = GetByte();
	}

	if (g_pucHeapMemory[iHeapIndex - 1] != ENDLOOP) {
		return VME_INVALID_FILE;
	}

	g_usFlowControl |= REPEATLOOP;
	g_usDataType |= HEAP_IN;

	for (iLoopIndex = 0; iLoopIndex < a_usLoopCount; iLoopIndex++) {
		g_iHeapCounter = 0;
		cRetCode = ispVMCode();
		g_usRepeatLoops++;
		if (cRetCode < 0) {
			break;
		}
	}

	g_usDataType &= ~(HEAP_IN);
	g_usFlowControl &= ~(REPEATLOOP);
	return cRetCode;
}

/*
 *
 * ispVMBitShift
 *
 * Shift the TDI stream left or right by the number of bits. The data in
 * *g_pucInData is of the VME format, so the actual shifting is the reverse of
 * IEEE 1532 or SVF format.
 *
 */

signed char ispVMBitShift(signed char mode, unsigned short bits)
{
	/* 09/11/07 NN added local variables initialization */
	unsigned short i       = 0;
	unsigned short size    = 0;
	unsigned short tmpbits = 0;

	if (g_usiDataSize % 8 > 0) {
		/* 09/11/07 NN Type cast mismatch variables */
		size = (unsigned short)(g_usiDataSize / 8 + 1);
	} else {
		/* 09/11/07 NN Type cast mismatch variables */
		size = (unsigned short)(g_usiDataSize / 8);
	}

	switch (mode) {
	case SHR:
		for (i = 0; i < size; i++) {
			if (g_pucInData[i] != 0) {
				tmpbits = bits;
				while (tmpbits > 0) {
					g_pucInData[i] <<= 1;
					if (g_pucInData[i] == 0) {
						i--;
						g_pucInData[i] = 1;
					}
					tmpbits--;
				}
			}
		}
		break;
	case SHL:
		for (i = 0; i < size; i++) {
			if (g_pucInData[i] != 0) {
				tmpbits = bits;
				while (tmpbits > 0) {
					g_pucInData[i] >>= 1;
					if (g_pucInData[i] == 0) {
						i--;
						g_pucInData[i] = 8;
					}
					tmpbits--;
				}
			}
		}
		break;
	default:
		return VME_INVALID_FILE;
	}

	return 0;
}

/*
 *
 * ispVMComment
 *
 * Displays the SVF comments.
 *
 */

void ispVMComment(unsigned short a_usCommentSize)
{
	char cCurByte = 0;
	for (; a_usCommentSize > 0; a_usCommentSize--) {
		/*
		*
		* Print character to the terminal.
		*
		**/
		cCurByte = GetByte();
		vme_out_char(cCurByte);
	}
	cCurByte = '\n';
	vme_out_char(cCurByte);
}

/*
 *
 * ispVMHeader
 *
 * Iterate the length of the header and discard it.
 *
 */

void ispVMHeader(unsigned short a_usHeaderSize)
{
	for (; a_usHeaderSize > 0; a_usHeaderSize--) {
		GetByte();
	}
}

/*
 *
 * ispVMCalculateCRC32
 *
 * Calculate the 32-bit CRC.
 *
 */

void ispVMCalculateCRC32(unsigned char a_ucData)
{
	/* 09/11/07 NN added local variables initialization */
	unsigned char ucIndex          = 0;
	unsigned char ucFlipData       = 0;
	unsigned short usCRCTableEntry = 0;
	unsigned int crc_table[16] = {
		0x0000, 0xCC01, 0xD801,
		0x1400, 0xF001, 0x3C00,
		0x2800, 0xE401, 0xA001,
		0x6C00, 0x7800, 0xB401,
		0x5000, 0x9C01, 0x8801,
		0x4400
	};

	for (ucIndex = 0; ucIndex < 8; ucIndex++) {
		ucFlipData <<= 1;
		if (a_ucData & 0x01) {
			ucFlipData |= 0x01;
		}
		a_ucData >>= 1;
	}

	/* 09/11/07 NN Type cast mismatch variables */
	usCRCTableEntry = (unsigned short)(crc_table[g_usCalculatedCRC & 0xF]);
	g_usCalculatedCRC = (unsigned short)((g_usCalculatedCRC >> 4) & 0x0FFF);
	g_usCalculatedCRC = (unsigned short)(g_usCalculatedCRC ^
			usCRCTableEntry ^ crc_table[ucFlipData & 0xF]);
	usCRCTableEntry = (unsigned short)(crc_table[g_usCalculatedCRC & 0xF]);
	g_usCalculatedCRC = (unsigned short)((g_usCalculatedCRC >> 4) & 0x0FFF);
	g_usCalculatedCRC = (unsigned short)(g_usCalculatedCRC ^
		usCRCTableEntry ^ crc_table[(ucFlipData >> 4) & 0xF]);
}

/*
 *
 * ispVMLCOUNT
 *
 * Process the intelligent programming loops.
 *
 */

signed char ispVMLCOUNT(unsigned short a_usCountSize)
{
	unsigned short usContinue	  = 1;
	unsigned short usIntelBufferIndex = 0;
	unsigned short usCountIndex       = 0;
	signed char cRetCode              = 0;
	signed char cRepeatHeap           = 0;
	signed char cOpcode               = 0;
	unsigned char ucState             = 0;
	unsigned short usDelay            = 0;
	unsigned short usToggle           = 0;

	g_usIntelBufferSize = (unsigned short)ispVMDataSize();

	/*
	 * Allocate memory for intel buffer.
	 *
	 */

	ispVMMemManager(LHEAP, g_usIntelBufferSize);

	/*
	 * Store the maximum size of the intelligent buffer.
	 * Used to convert VME to HEX.
	 */

	if (g_usIntelBufferSize > g_usLCOUNTSize) {
		g_usLCOUNTSize = g_usIntelBufferSize;
	}

	/*
	 * Copy intel data to the buffer.
	 */

	for (usIntelBufferIndex = 0; usIntelBufferIndex < g_usIntelBufferSize;
		usIntelBufferIndex++) {
		g_pucIntelBuffer[usIntelBufferIndex] = GetByte();
	}

	/*
	 * Set the data type register to get data from the intelligent
	 * data buffer.
	 */

	g_usDataType |= LHEAP_IN;

	/*
	*
	* If the HEAP_IN flag is set, temporarily unset the flag so data will be
	* retrieved from the status buffer.
	*
	**/

	if (g_usDataType & HEAP_IN) {
		g_usDataType &= ~HEAP_IN;
		cRepeatHeap = 1;
	}

#ifdef DEBUG
	printf("LCOUNT %d;\n", a_usCountSize);
#endif /* DEBUG */

	/*
	 * Iterate through the intelligent programming command.
	*/

	for (usCountIndex = 0; usCountIndex < a_usCountSize; usCountIndex++) {

		/*
		*
		* Initialize the intel data index to 0 before each iteration.
		*
		**/

		g_usIntelDataIndex = 0;
		cOpcode            = 0;
		ucState            = 0;
		usDelay            = 0;
		usToggle           = 0;
		usContinue		   = 1;

		/*
		*
		* Begin looping through all the VME opcodes.
		*
		*/
		/*
		* 4/1/09 Nguyen replaced the recursive function call codes on
		*        the ispVMLCOUNT function
		*
		*/
		while (usContinue) {
			cOpcode = GetByte();
			switch (cOpcode) {
			case HIR:
			case TIR:
			case HDR:
			case TDR:
				/*
				 * Set the header/trailer of the device in order
				 * to bypass successfully.
				 */

				ispVMAmble(cOpcode);
			break;
			case STATE:

				/*
				 * Step the JTAG state machine.
				 */

				ucState = GetByte();
				/*
				 * Step the JTAG state machine to DRCAPTURE
				 * to support Looping.
				 */

				if ((g_usDataType & LHEAP_IN) &&
					 (ucState == DRPAUSE) &&
					 (g_cCurrentJTAGState == ucState)) {
					ispVMStateMachine(DRCAPTURE);
				}
				ispVMStateMachine(ucState);
#ifdef DEBUG
				printf("LDELAY %s ", GetState(ucState));
#endif /* DEBUG */
				break;
			case SIR:
#ifdef DEBUG
				printf("SIR ");
#endif /* DEBUG */
				/*
				 * Shift in data into the device.
				 */

				cRetCode = ispVMShift(cOpcode);
				break;
			case SDR:

#ifdef DEBUG
				printf("LSDR ");
#endif /* DEBUG */
				/*
				 * Shift in data into the device.
				 */

				cRetCode = ispVMShift(cOpcode);
				break;
			case WAIT:

				/*
				*
				* Observe delay.
				*
				*/

				usDelay = (unsigned short)ispVMDataSize();
				ispVMDelay(usDelay);

#ifdef DEBUG
				if (usDelay & 0x8000) {

					/*
					 * Since MSB is set, the delay time must
					 * be decoded to millisecond. The
					 * SVF2VME encodes the MSB to represent
					 * millisecond.
					 */

					usDelay &= ~0x8000;
					printf("%.2E SEC;\n",
						(float) usDelay / 1000);
				} else {
					/*
					 * Since MSB is not set, the delay time
					 * is given as microseconds.
					 */

					printf("%.2E SEC;\n",
						(float) usDelay / 1000000);
				}
#endif /* DEBUG */
				break;
			case TCK:

				/*
				 * Issue clock toggles.
				 */

				usToggle = (unsigned short)ispVMDataSize();
				ispVMClocks(usToggle);

#ifdef DEBUG
				printf("RUNTEST %d TCK;\n", usToggle);
#endif /* DEBUG */
				break;
			case ENDLOOP:

				/*
				 * Exit point from processing loops.
				 */
				usContinue = 0;
				break;

			case COMMENT:

				/*
				 * Display comment.
				 */

				ispVMComment((unsigned short) ispVMDataSize());
				break;
			case ispEN:
				ucState = GetByte();
				if ((ucState == ON) || (ucState == 0x01))
					writePort(g_ucPinENABLE, 0x01);
				else
					writePort(g_ucPinENABLE, 0x00);
				ispVMDelay(1);
				break;
			case TRST:
				if (GetByte() == 0x01)
					writePort(g_ucPinTRST, 0x01);
				else
					writePort(g_ucPinTRST, 0x00);
				ispVMDelay(1);
				break;
			default:

				/*
				 * Invalid opcode encountered.
				 */

				debug("\nINVALID OPCODE: 0x%.2X\n", cOpcode);

				return VME_INVALID_FILE;
			}
		}
		if (cRetCode >= 0) {
			/*
			 * Break if intelligent programming is successful.
			 */

			break;
		}

	}
	/*
	 * If HEAP_IN flag was temporarily disabled,
	 * re-enable it before exiting
	 */

	if (cRepeatHeap) {
		g_usDataType |= HEAP_IN;
	}

	/*
	 * Set the data type register to not get data from the
	 * intelligent data buffer.
	 */

	g_usDataType &= ~LHEAP_IN;
	return cRetCode;
}
/*
 *
 * ispVMClocks
 *
 * Applies the specified number of pulses to TCK.
 *
 */

void ispVMClocks(unsigned short Clocks)
{
	unsigned short iClockIndex = 0;
	for (iClockIndex = 0; iClockIndex < Clocks; iClockIndex++) {
		sclock();
	}
}

/*
 *
 * ispVMBypass
 *
 * This procedure takes care of the HIR, HDR, TIR, TDR for the
 * purpose of putting the other devices into Bypass mode. The
 * current state is checked to find out if it is at DRPAUSE or
 * IRPAUSE. If it is at DRPAUSE, perform bypass register scan.
 * If it is at IRPAUSE, scan into instruction registers the bypass
 * instruction.
 *
 */

void ispVMBypass(signed char ScanType, unsigned short Bits)
{
	/* 09/11/07 NN added local variables initialization */
	unsigned short iIndex       = 0;
	unsigned short iSourceIndex = 0;
	unsigned char cBitState     = 0;
	unsigned char cCurByte      = 0;
	unsigned char *pcSource    = NULL;

	if (Bits <= 0) {
		return;
	}

	switch (ScanType) {
	case HIR:
		pcSource = g_pucHIRData;
		break;
	case TIR:
		pcSource = g_pucTIRData;
		break;
	case HDR:
		pcSource = g_pucHDRData;
		break;
	case TDR:
		pcSource = g_pucTDRData;
		break;
	default:
		break;
	}

	iSourceIndex = 0;
	cBitState = 0;
	for (iIndex = 0; iIndex < Bits - 1; iIndex++) {
		/* Scan instruction or bypass register */
		if (iIndex % 8 == 0) {
			cCurByte = pcSource[iSourceIndex++];
		}
		cBitState = (unsigned char) (((cCurByte << iIndex % 8) & 0x80)
			? 0x01 : 0x00);
		writePort(g_ucPinTDI, cBitState);
		sclock();
	}

	if (iIndex % 8 == 0)  {
		cCurByte = pcSource[iSourceIndex++];
	}

	cBitState = (unsigned char) (((cCurByte << iIndex % 8) & 0x80)
		? 0x01 : 0x00);
	writePort(g_ucPinTDI, cBitState);
}

/*
 *
 * ispVMStateMachine
 *
 * This procedure steps all devices in the daisy chain from a given
 * JTAG state to the next desirable state. If the next state is TLR,
 * the JTAG state machine is brute forced into TLR by driving TMS
 * high and pulse TCK 6 times.
 *
 */

void ispVMStateMachine(signed char cNextJTAGState)
{
	/* 09/11/07 NN added local variables initialization */
	signed char cPathIndex  = 0;
	signed char cStateIndex = 0;

	if ((g_cCurrentJTAGState == cNextJTAGState) &&
		(cNextJTAGState != RESET)) {
		return;
	}

	for (cStateIndex = 0; cStateIndex < 25; cStateIndex++) {
		if ((g_cCurrentJTAGState ==
			 g_JTAGTransistions[cStateIndex].CurState) &&
			(cNextJTAGState ==
				 g_JTAGTransistions[cStateIndex].NextState)) {
			break;
		}
	}

	g_cCurrentJTAGState = cNextJTAGState;
	for (cPathIndex = 0;
		cPathIndex < g_JTAGTransistions[cStateIndex].Pulses;
		cPathIndex++) {
		if ((g_JTAGTransistions[cStateIndex].Pattern << cPathIndex)
			& 0x80) {
			writePort(g_ucPinTMS, (unsigned char) 0x01);
		} else {
			writePort(g_ucPinTMS, (unsigned char) 0x00);
		}
		sclock();
	}

	writePort(g_ucPinTDI, 0x00);
	writePort(g_ucPinTMS, 0x00);
}

/*
 *
 * ispVMStart
 *
 * Enable the port to the device and set the state to RESET (TLR).
 *
 */

void ispVMStart()
{
#ifdef DEBUG
	printf("// ISPVM EMBEDDED ADDED\n");
	printf("STATE RESET;\n");
#endif
	g_usFlowControl	= 0;
	g_usDataType = g_uiChecksumIndex = g_cCurrentJTAGState = 0;
	g_usHeadDR = g_usHeadIR = g_usTailDR = g_usTailIR = 0;
	g_usMaxSize = g_usShiftValue = g_usRepeatLoops = 0;
	g_usTDOSize =  g_usMASKSize = g_usTDISize = 0;
	g_usDMASKSize = g_usLCOUNTSize = g_usHDRSize = 0;
	g_usTDRSize = g_usHIRSize = g_usTIRSize =  g_usHeapSize	= 0;
	g_pLVDSList = NULL;
	g_usLVDSPairCount = 0;
	previous_size = 0;

	ispVMStateMachine(RESET);    /*step devices to RESET state*/
}

/*
 *
 * ispVMEnd
 *
 * Set the state of devices to RESET to enable the devices and disable
 * the port.
 *
 */

void ispVMEnd()
{
#ifdef DEBUG
	printf("// ISPVM EMBEDDED ADDED\n");
	printf("STATE RESET;\n");
	printf("RUNTEST 1.00E-001 SEC;\n");
#endif

	ispVMStateMachine(RESET);   /*step devices to RESET state */
	ispVMDelay(1000);              /*wake up devices*/
}

/*
 *
 * ispVMSend
 *
 * Send the TDI data stream to devices. The data stream can be
 * instructions or data.
 *
 */

signed char ispVMSend(unsigned short a_usiDataSize)
{
	/* 09/11/07 NN added local variables initialization */
	unsigned short iIndex       = 0;
	unsigned short iInDataIndex = 0;
	unsigned char cCurByte      = 0;
	unsigned char cBitState     = 0;

	for (iIndex = 0; iIndex < a_usiDataSize - 1; iIndex++) {
		if (iIndex % 8 == 0) {
			cCurByte = g_pucInData[iInDataIndex++];
		}
		cBitState = (unsigned char)(((cCurByte << iIndex % 8) & 0x80)
			? 0x01 : 0x00);
		writePort(g_ucPinTDI, cBitState);
		sclock();
	}

	if (iIndex % 8 == 0) {
		/* Take care of the last bit */
		cCurByte = g_pucInData[iInDataIndex];
	}

	cBitState = (unsigned char) (((cCurByte << iIndex % 8) & 0x80)
		? 0x01 : 0x00);

	writePort(g_ucPinTDI, cBitState);
	if (g_usFlowControl & CASCADE) {
		/*1/15/04 Clock in last bit for the first n-1 cascaded frames */
		sclock();
	}

	return 0;
}

/*
 *
 * ispVMRead
 *
 * Read the data stream from devices and verify.
 *
 */

signed char ispVMRead(unsigned short a_usiDataSize)
{
	/* 09/11/07 NN added local variables initialization */
	unsigned short usDataSizeIndex    = 0;
	unsigned short usErrorCount       = 0;
	unsigned short usLastBitIndex     = 0;
	unsigned char cDataByte           = 0;
	unsigned char cMaskByte           = 0;
	unsigned char cInDataByte         = 0;
	unsigned char cCurBit             = 0;
	unsigned char cByteIndex          = 0;
	unsigned short usBufferIndex      = 0;
	unsigned char ucDisplayByte       = 0x00;
	unsigned char ucDisplayFlag       = 0x01;
	char StrChecksum[256]            = {0};
	unsigned char g_usCalculateChecksum = 0x00;

	/* 09/11/07 NN Type cast mismatch variables */
	usLastBitIndex = (unsigned short)(a_usiDataSize - 1);

#ifndef DEBUG
	/*
	 * If mask is not all zeros, then set the display flag to 0x00,
	 * otherwise it shall be set to 0x01 to indicate that data read
	 * from the device shall be displayed. If DEBUG is defined,
	 * always display data.
	 */

	for (usDataSizeIndex = 0; usDataSizeIndex < (a_usiDataSize + 7) / 8;
		usDataSizeIndex++) {
		if (g_usDataType & MASK_DATA) {
			if (g_pucOutMaskData[usDataSizeIndex] != 0x00) {
				ucDisplayFlag = 0x00;
				break;
			}
		} else if (g_usDataType & CMASK_DATA) {
			g_usCalculateChecksum = 0x01;
			ucDisplayFlag = 0x00;
			break;
		} else {
			ucDisplayFlag = 0x00;
			break;
		}
	}
#endif /* DEBUG */

	/*
	*
	* Begin shifting data in and out of the device.
	*
	**/

	for (usDataSizeIndex = 0; usDataSizeIndex < a_usiDataSize;
		usDataSizeIndex++) {
		if (cByteIndex == 0) {

			/*
			 * Grab byte from TDO buffer.
			 */

			if (g_usDataType & TDO_DATA) {
				cDataByte = g_pucOutData[usBufferIndex];
			}

			/*
			 * Grab byte from MASK buffer.
			 */

			if (g_usDataType & MASK_DATA) {
				cMaskByte = g_pucOutMaskData[usBufferIndex];
			} else {
				cMaskByte = 0xFF;
			}

			/*
			 * Grab byte from CMASK buffer.
			 */

			if (g_usDataType & CMASK_DATA) {
				cMaskByte = 0x00;
				g_usCalculateChecksum = 0x01;
			}

			/*
			 * Grab byte from TDI buffer.
			 */

			if (g_usDataType & TDI_DATA) {
				cInDataByte = g_pucInData[usBufferIndex];
			}

			usBufferIndex++;
		}

		cCurBit = readPort();

		if (ucDisplayFlag) {
			ucDisplayByte <<= 1;
			ucDisplayByte |= cCurBit;
		}

		/*
		 * Check if data read from port matches with expected TDO.
		 */

		if (g_usDataType & TDO_DATA) {
			/* 08/28/08 NN Added Calculate checksum support. */
			if (g_usCalculateChecksum) {
				if (cCurBit == 0x01)
					g_usChecksum +=
						(1 << (g_uiChecksumIndex % 8));
				g_uiChecksumIndex++;
			} else {
				if ((((cMaskByte << cByteIndex) & 0x80)
					? 0x01 : 0x00)) {
					if (cCurBit != (unsigned char)
					(((cDataByte << cByteIndex) & 0x80)
						? 0x01 : 0x00)) {
						usErrorCount++;
					}
				}
			}
		}

		/*
		 * Write TDI data to the port.
		 */

		writePort(g_ucPinTDI,
			(unsigned char)(((cInDataByte << cByteIndex) & 0x80)
				? 0x01 : 0x00));

		if (usDataSizeIndex < usLastBitIndex) {

			/*
			 * Clock data out from the data shift register.
			 */

			sclock();
		} else if (g_usFlowControl & CASCADE) {

			/*
			 * Clock in last bit for the first N - 1 cascaded frames
			 */

			sclock();
		}

		/*
		 * Increment the byte index. If it exceeds 7, then reset it back
		 * to zero.
		 */

		cByteIndex++;
		if (cByteIndex >= 8) {
			if (ucDisplayFlag) {

			/*
			 * Store displayed data in the TDO buffer. By reusing
			 * the TDO buffer to store displayed data, there is no
			 * need to allocate a buffer simply to hold display
			 * data. This will not cause any false verification
			 * errors because the true TDO byte has already
			 * been consumed.
			 */

				g_pucOutData[usBufferIndex - 1] = ucDisplayByte;
				ucDisplayByte = 0;
			}

			cByteIndex = 0;
		}
		/* 09/12/07 Nguyen changed to display the 1 bit expected data */
		else if (a_usiDataSize == 1) {
			if (ucDisplayFlag) {

				/*
				 * Store displayed data in the TDO buffer.
				 * By reusing the TDO buffer to store displayed
				 * data, there is no need to allocate
				 * a buffer simply to hold display data. This
				 * will not cause any false verification errors
				 * because the true TDO byte has already
				 * been consumed.
				 */

				/*
				 * Flip ucDisplayByte and store it in cDataByte.
				 */
				cDataByte = 0x00;
				for (usBufferIndex = 0; usBufferIndex < 8;
					usBufferIndex++) {
					cDataByte <<= 1;
					if (ucDisplayByte & 0x01) {
						cDataByte |= 0x01;
					}
					ucDisplayByte >>= 1;
				}
				g_pucOutData[0] = cDataByte;
				ucDisplayByte = 0;
			}

			cByteIndex = 0;
		}
	}

	if (ucDisplayFlag) {

#ifdef DEBUG
		debug("RECEIVED TDO (");
#else
		vme_out_string("Display Data: 0x");
#endif /* DEBUG */

		/* 09/11/07 NN Type cast mismatch variables */
		for (usDataSizeIndex = (unsigned short)
				((a_usiDataSize + 7) / 8);
			usDataSizeIndex > 0 ; usDataSizeIndex--) {
			cMaskByte = g_pucOutData[usDataSizeIndex - 1];
			cDataByte = 0x00;

			/*
			 * Flip cMaskByte and store it in cDataByte.
			 */

			for (usBufferIndex = 0; usBufferIndex < 8;
				usBufferIndex++) {
				cDataByte <<= 1;
				if (cMaskByte & 0x01) {
					cDataByte |= 0x01;
				}
				cMaskByte >>= 1;
			}
#ifdef DEBUG
			printf("%.2X", cDataByte);
			if ((((a_usiDataSize + 7) / 8) - usDataSizeIndex)
				% 40 == 39) {
				printf("\n\t\t");
			}
#else
			vme_out_hex(cDataByte);
#endif /* DEBUG */
		}

#ifdef DEBUG
		printf(")\n\n");
#else
		vme_out_string("\n\n");
#endif /* DEBUG */
		/* 09/02/08 Nguyen changed to display the data Checksum */
		if (g_usChecksum != 0) {
			g_usChecksum &= 0xFFFF;
			sprintf(StrChecksum, "Data Checksum: %.4lX\n\n",
				g_usChecksum);
			vme_out_string(StrChecksum);
			g_usChecksum = 0;
		}
	}

	if (usErrorCount > 0) {
		if (g_usFlowControl & VERIFYUES) {
			vme_out_string(
				"USERCODE verification failed.   "
				"Continue programming......\n\n");
			g_usFlowControl &= ~(VERIFYUES);
			return 0;
		} else {

#ifdef DEBUG
			printf("TOTAL ERRORS: %d\n", usErrorCount);
#endif /* DEBUG */

			return VME_VERIFICATION_FAILURE;
		}
	} else {
		if (g_usFlowControl & VERIFYUES) {
			vme_out_string("USERCODE verification passed.    "
				"Programming aborted.\n\n");
			g_usFlowControl &= ~(VERIFYUES);
			return 1;
		} else {
			return 0;
		}
	}
}

/*
 *
 * ispVMReadandSave
 *
 * Support dynamic I/O.
 *
 */

signed char ispVMReadandSave(unsigned short int a_usiDataSize)
{
	/* 09/11/07 NN added local variables initialization */
	unsigned short int usDataSizeIndex = 0;
	unsigned short int usLastBitIndex  = 0;
	unsigned short int usBufferIndex   = 0;
	unsigned short int usOutBitIndex   = 0;
	unsigned short int usLVDSIndex     = 0;
	unsigned char cDataByte            = 0;
	unsigned char cDMASKByte           = 0;
	unsigned char cInDataByte          = 0;
	unsigned char cCurBit              = 0;
	unsigned char cByteIndex           = 0;
	signed char cLVDSByteIndex         = 0;

	/* 09/11/07 NN Type cast mismatch variables */
	usLastBitIndex = (unsigned short) (a_usiDataSize - 1);

	/*
	*
	* Iterate through the data bits.
	*
	*/

	for (usDataSizeIndex = 0; usDataSizeIndex < a_usiDataSize;
		usDataSizeIndex++) {
		if (cByteIndex == 0) {

			/*
			 * Grab byte from DMASK buffer.
			 */

			if (g_usDataType & DMASK_DATA) {
				cDMASKByte = g_pucOutDMaskData[usBufferIndex];
			} else {
				cDMASKByte = 0x00;
			}

			/*
			 * Grab byte from TDI buffer.
			 */

			if (g_usDataType & TDI_DATA) {
				cInDataByte = g_pucInData[usBufferIndex];
			}

			usBufferIndex++;
		}

		cCurBit = readPort();
		cDataByte = (unsigned char)(((cInDataByte << cByteIndex) & 0x80)
			? 0x01 : 0x00);

		/*
		 * Initialize the byte to be zero.
		 */

		if (usOutBitIndex % 8 == 0) {
			g_pucOutData[usOutBitIndex / 8] = 0x00;
		}

		/*
		 * Use TDI, DMASK, and device TDO to create new TDI (actually
		 * stored in g_pucOutData).
		 */

		if ((((cDMASKByte << cByteIndex) & 0x80) ? 0x01 : 0x00)) {

			if (g_pLVDSList) {
				for (usLVDSIndex = 0;
					 usLVDSIndex < g_usLVDSPairCount;
					usLVDSIndex++) {
					if (g_pLVDSList[usLVDSIndex].
						usNegativeIndex ==
						usDataSizeIndex) {
						g_pLVDSList[usLVDSIndex].
							ucUpdate = 0x01;
						break;
					}
				}
			}

			/*
			 * DMASK bit is 1, use TDI.
			 */

			g_pucOutData[usOutBitIndex / 8] |= (unsigned char)
				(((cDataByte & 0x1) ? 0x01 : 0x00) <<
				(7 - usOutBitIndex % 8));
		} else {

			/*
			 * DMASK bit is 0, use device TDO.
			 */

			g_pucOutData[usOutBitIndex / 8] |= (unsigned char)
				(((cCurBit & 0x1) ? 0x01 : 0x00) <<
				(7 - usOutBitIndex % 8));
		}

		/*
		 * Shift in TDI in order to get TDO out.
		 */

		usOutBitIndex++;
		writePort(g_ucPinTDI, cDataByte);
		if (usDataSizeIndex < usLastBitIndex) {
			sclock();
		}

		/*
		 * Increment the byte index. If it exceeds 7, then reset it back
		 * to zero.
		 */

		cByteIndex++;
		if (cByteIndex >= 8) {
			cByteIndex = 0;
		}
	}

	/*
	 * If g_pLVDSList exists and pairs need updating, then update
	 * the negative-pair to receive the flipped positive-pair value.
	 */

	if (g_pLVDSList) {
		for (usLVDSIndex = 0; usLVDSIndex < g_usLVDSPairCount;
			usLVDSIndex++) {
			if (g_pLVDSList[usLVDSIndex].ucUpdate) {

				/*
				 * Read the positive value and flip it.
				 */

				cDataByte = (unsigned char)
				 (((g_pucOutData[g_pLVDSList[usLVDSIndex].
					usPositiveIndex / 8]
					<< (g_pLVDSList[usLVDSIndex].
					usPositiveIndex % 8)) & 0x80) ?
					0x01 : 0x00);
				/* 09/11/07 NN Type cast mismatch variables */
				cDataByte = (unsigned char) (!cDataByte);

				/*
				 * Get the byte that needs modification.
				 */

				cInDataByte =
				g_pucOutData[g_pLVDSList[usLVDSIndex].
					usNegativeIndex / 8];

				if (cDataByte) {

					/*
					 * Copy over the current byte and
					 * set the negative bit to 1.
					 */

					cDataByte = 0x00;
					for (cLVDSByteIndex = 7;
						cLVDSByteIndex >= 0;
						cLVDSByteIndex--) {
						cDataByte <<= 1;
						if (7 -
						(g_pLVDSList[usLVDSIndex].
							usNegativeIndex % 8) ==
							cLVDSByteIndex) {

							/*
							 * Set negative bit to 1
							 */

							cDataByte |= 0x01;
						} else if (cInDataByte & 0x80) {
							cDataByte |= 0x01;
						}

						cInDataByte <<= 1;
					}

					/*
					 * Store the modified byte.
					 */

					g_pucOutData[g_pLVDSList[usLVDSIndex].
					usNegativeIndex / 8] = cDataByte;
				} else {

					/*
					 * Copy over the current byte and set
					 * the negative bit to 0.
					 */

					cDataByte = 0x00;
					for (cLVDSByteIndex = 7;
						cLVDSByteIndex >= 0;
						cLVDSByteIndex--) {
						cDataByte <<= 1;
						if (7 -
						(g_pLVDSList[usLVDSIndex].
						usNegativeIndex % 8) ==
						cLVDSByteIndex) {

							/*
							 * Set negative bit to 0
							 */

							cDataByte |= 0x00;
						} else if (cInDataByte & 0x80) {
							cDataByte |= 0x01;
						}

						cInDataByte <<= 1;
					}

					/*
					 * Store the modified byte.
					 */

					g_pucOutData[g_pLVDSList[usLVDSIndex].
					usNegativeIndex / 8] = cDataByte;
				}

				break;
			}
		}
	}

	return 0;
}

signed char ispVMProcessLVDS(unsigned short a_usLVDSCount)
{
	unsigned short usLVDSIndex = 0;

	/*
	 * Allocate memory to hold LVDS pairs.
	 */

	ispVMMemManager(LVDS, a_usLVDSCount);
	g_usLVDSPairCount = a_usLVDSCount;

#ifdef DEBUG
	printf("LVDS %d (", a_usLVDSCount);
#endif /* DEBUG */

	/*
	 * Iterate through each given LVDS pair.
	 */

	for (usLVDSIndex = 0; usLVDSIndex < g_usLVDSPairCount; usLVDSIndex++) {

		/*
		 * Assign the positive and negative indices of the LVDS pair.
		 */

		/* 09/11/07 NN Type cast mismatch variables */
		g_pLVDSList[usLVDSIndex].usPositiveIndex =
			(unsigned short) ispVMDataSize();
		/* 09/11/07 NN Type cast mismatch variables */
		g_pLVDSList[usLVDSIndex].usNegativeIndex =
			(unsigned short)ispVMDataSize();

#ifdef DEBUG
		if (usLVDSIndex < g_usLVDSPairCount - 1) {
			printf("%d:%d, ",
				g_pLVDSList[usLVDSIndex].usPositiveIndex,
				g_pLVDSList[usLVDSIndex].usNegativeIndex);
		} else {
			printf("%d:%d",
				g_pLVDSList[usLVDSIndex].usPositiveIndex,
				g_pLVDSList[usLVDSIndex].usNegativeIndex);
		}
#endif /* DEBUG */

	}

#ifdef DEBUG
	printf(");\n");
#endif /* DEBUG */

	return 0;
}