/* * 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 * SPDX-License-Identifier: GPL-2.0+ */ #include #include #include #include #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", a_usLVDSCount); #endif /* DEBUG */ return 0; }