|
|
@@ -0,0 +1,3167 @@
|
|
|
+/*
|
|
|
+ * 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
|
|
|
+ * See file CREDITS for list of people who contributed to this
|
|
|
+ * project.
|
|
|
+ *
|
|
|
+ * This program is free software; you can redistribute it and/or
|
|
|
+ * modify it under the terms of the GNU General Public License as
|
|
|
+ * published by the Free Software Foundation; either version 2 of
|
|
|
+ * the License, or (at your option) any later version.
|
|
|
+ *
|
|
|
+ * This program is distributed in the hope that it will be useful,
|
|
|
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
+ * GNU General Public License for more details.
|
|
|
+ *
|
|
|
+ * You should have received a copy of the GNU General Public License
|
|
|
+ * along with this program; if not, write to the Free Software
|
|
|
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
|
+ * MA 02111-1307 USA
|
|
|
+ */
|
|
|
+
|
|
|
+#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;
|
|
|
+ unsigned char usByte = 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;
|
|
|
+ usByte = 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", a_usLVDSCount);
|
|
|
+#endif /* DEBUG */
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
Wolfgang Denk