Merge branch 'master' of git@github.com:preble/P-ROC

CMakeLists.txt

@@ -14,5 +14,6 @@ set(FILES src/pinproc.cpp src/PRDevice.cpp src/PRHardware.cpp)
 add_library(pinproc ${FILES})
 
 add_executable(pinproctest examples/pinproctest/pinproctest.cpp examples/pinproctest/drivers.cpp examples/pinproctest/dmd.cpp examples/pinproctest/switches.cpp)
+add_executable(pinprocfw utils/pinprocfw/pinprocfw.cpp utils/pinprocfw/lenval.cpp)
 target_link_libraries(pinproctest pinproc usb ftdi yaml-cpp)
-
+target_link_libraries(pinprocfw pinproc usb ftdi)

include/pinproc.h

@@ -387,6 +387,41 @@ PR_EXPORT PRResult PRDMDDraw(PRHandle handle, uint8_t * dots);
 
 /** @} */ // End of DMD
 
+
+// JTAG
+
+/**
+ * @defgroup jtag JTAG interface control
+ * @{
+ */
+
+typedef struct PRJTAGStatus {
+    bool_t commandComplete;
+    bool_t tdi;
+} PRJTAGStatus;
+
+typedef struct PRJTAGOutputs {
+    bool_t tckMask;
+    bool_t tmsMask;
+    bool_t tdoMask;
+    bool_t tck;
+    bool_t tms;
+    bool_t tdo;
+} PRJTAGOutputs;
+
+/** Force JTAG outputs (TCK, TDO, TMS) to specific values. Optionally toggle the clock when driving only TDO and/or TMS.*/
+PR_EXPORT PRResult PRJTAGDriveOutputs(PRHandle handle, PRJTAGOutputs * jtagOutputs, bool_t toggleClk);
+/** Store data to be shifted out on TDO */
+PR_EXPORT PRResult PRJTAGWriteTDOMemory(PRHandle handle, uint16_t tableOffset, uint16_t numWords, uint32_t * tdoData);
+/** Shift stored TDO data onto the TDO pin, toggling TCK on every bit. */
+PR_EXPORT PRResult PRJTAGShiftTDOData(PRHandle handle, uint16_t numBits, bool_t dataBlockComplete);
+/** Get the contents of the TDI memory. */
+PR_EXPORT PRResult PRJTAGReadTDIMemory(PRHandle handle, uint16_t tableOffset, uint16_t numWords, uint32_t * tdiData);
+/** Read the JTAG status register for the command complete bit and JTAG pin states. */
+PR_EXPORT PRResult PRJTAGGetStatus(PRHandle handle, PRJTAGStatus * status);
+
+/** @} */ // End of DMD
+
 /** @cond */
 PR_EXTERN_C_END
 /** @endcond */

src/PRDevice.cpp

@@ -623,7 +623,51 @@ PRResult PRDevice::DMDDraw(uint8_t * dots)
     //}
 }
 
+PRResult PRDevice::PRJTAGDriveOutputs(PRJTAGOutputs * jtagOutputs, bool_t toggleClk)
+{
+    const int burstSize = 2;
+    uint32_t burst[burstSize];
 
+    if (toggleClk) CreateJTAGLatchOutputsBurst( burst, jtagOutputs );
+    else CreateJTAGForceOutputsBurst( burst, jtagOutputs );
+    return WriteData(burst, burstSize);
+}
+
+PRResult PRDevice::PRJTAGWriteTDOMemory(uint16_t tableOffset, uint16_t numWords, uint32_t * tdoData)
+{
+    int32_t i;
+    const int maxBurstSize = 513;
+    uint32_t burst[maxBurstSize];
+
+    burst[0] = CreateBurstCommand(P_ROC_BUS_JTAG_SELECT, P_ROC_JTAG_TDO_MEMORY_BASE_ADDR + tableOffset, numWords);
+    for (i=0; i<numWords; i++) {
+        burst[i+1] = tdoData[i];
+    }
+
+    return WriteData(burst, numWords + 1);
+}
+
+PRResult PRDevice::PRJTAGShiftTDOData(uint16_t numBits, bool_t dataBlockComplete)
+{
+    const int burstSize = 2;
+    uint32_t burst[burstSize];
+
+    CreateJTAGShiftTDODataBurst( burst, numBits, dataBlockComplete );
+    return WriteData(burst, burstSize);
+}
+
+PRResult PRDevice::PRJTAGReadTDIMemory(uint16_t tableOffset, uint16_t numWords, uint32_t * tdiData)
+{
+    ReadDataRaw (P_ROC_BUS_JTAG_SELECT, P_ROC_JTAG_TDI_MEMORY_BASE_ADDR + tableOffset, numWords, tdiData);
+}
+
+PRResult PRDevice::PRJTAGGetStatus(PRJTAGStatus * status)
+{
+    uint32_t rdBuffer[1];
+    ReadDataRaw (P_ROC_BUS_JTAG_SELECT, P_ROC_JTAG_STATUS_REG_BASE_ADDR, 1, rdBuffer);
+    status->commandComplete = rdBuffer[0] >> P_ROC_JTAG_STATUS_DONE_SHIFT;
+    status->tdi = rdBuffer[0] >> P_ROC_JTAG_STATUS_TDI_SHIFT;
+}
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 // Device I/O
@@ -800,7 +844,7 @@ PRResult PRDevice::WriteDataRaw(uint32_t moduleSelect, uint32_t startingAddr, in
 PRResult PRDevice::ReadDataRaw(uint32_t moduleSelect, uint32_t startingAddr, int32_t numReadWords, uint32_t * readBuffer)
 {
     uint32_t rc;
-    uint8_t i;
+    uint32_t i;
 
     // Send out the request.
     rc = RequestData(moduleSelect, startingAddr, numReadWords);

src/PRDevice.h

@@ -73,6 +73,12 @@ public:
     PRResult DMDUpdateConfig(PRDMDConfig *dmdConfig);
     PRResult DMDDraw(uint8_t * dots);
 
+    PRResult PRJTAGDriveOutputs(PRJTAGOutputs * jtagOutputs, bool_t toggleClk);
+    PRResult PRJTAGWriteTDOMemory(uint16_t tableOffset, uint16_t numWords, uint32_t * tdoData);
+    PRResult PRJTAGShiftTDOData(uint16_t numBits, bool_t dataBlockComplete);
+    PRResult PRJTAGReadTDIMemory(uint16_t tableOffset, uint16_t numWords, uint32_t * tdiData);
+    PRResult PRJTAGGetStatus(PRJTAGStatus * status);
+
 protected:
 
     // Device I/O

src/PRHardware.cpp

@@ -234,6 +234,44 @@ int32_t CreateDMDUpdateConfigBurst ( uint32_t * burst, PRDMDConfig *dmd_config)
     return kPRSuccess;
 }
 
+int32_t CreateJTAGForceOutputsBurst ( uint32_t * burst, PRJTAGOutputs *jtagOutputs) {
+    burst[0] = CreateBurstCommand (P_ROC_BUS_JTAG_SELECT, P_ROC_JTAG_COMMAND_REG_BASE_ADDR, 1 );
+    burst[1] = 0;
+    burst[1] = 1 << P_ROC_JTAG_CMD_START_SHIFT |
+               1 << P_ROC_JTAG_CMD_OE_SHIFT |
+               P_ROC_JTAG_CMD_SET_PORTS << P_ROC_JTAG_CMD_CMD_SHIFT |
+               jtagOutputs->tckMask << P_ROC_JTAG_TRANSITION_TCK_MASK_SHIFT | 
+               jtagOutputs->tdoMask << P_ROC_JTAG_TRANSITION_TDO_MASK_SHIFT | 
+               jtagOutputs->tmsMask << P_ROC_JTAG_TRANSITION_TMS_MASK_SHIFT | 
+               jtagOutputs->tck << P_ROC_JTAG_TRANSITION_TCK_SHIFT | 
+               jtagOutputs->tdo << P_ROC_JTAG_TRANSITION_TCK_SHIFT | 
+               jtagOutputs->tms << P_ROC_JTAG_TRANSITION_TCK_SHIFT; 
+    return kPRSuccess;
+
+}
+int32_t CreateJTAGLatchOutputsBurst ( uint32_t * burst, PRJTAGOutputs *jtagOutputs) {
+    burst[0] = CreateBurstCommand (P_ROC_BUS_JTAG_SELECT, P_ROC_JTAG_COMMAND_REG_BASE_ADDR, 1 );
+    burst[1] = 0;
+    burst[1] = 1 << P_ROC_JTAG_CMD_START_SHIFT |
+               1 << P_ROC_JTAG_CMD_OE_SHIFT |
+               P_ROC_JTAG_CMD_TRANSITION << P_ROC_JTAG_CMD_CMD_SHIFT |
+               jtagOutputs->tdoMask << P_ROC_JTAG_TRANSITION_TDO_MASK_SHIFT | 
+               jtagOutputs->tmsMask << P_ROC_JTAG_TRANSITION_TMS_MASK_SHIFT | 
+               jtagOutputs->tdo << P_ROC_JTAG_TRANSITION_TCK_SHIFT | 
+               jtagOutputs->tms << P_ROC_JTAG_TRANSITION_TMS_SHIFT; 
+    return kPRSuccess;
+
+}
+int32_t CreateJTAGShiftTDODataBurst ( uint32_t * burst, uint16_t numBits, bool_t dataBlockComplete) {
+    burst[0] = CreateBurstCommand (P_ROC_BUS_JTAG_SELECT, P_ROC_JTAG_COMMAND_REG_BASE_ADDR, 1 );
+    burst[1] = 0;
+    burst[1] = 1 << P_ROC_JTAG_CMD_START_SHIFT |
+               1 << P_ROC_JTAG_CMD_OE_SHIFT |
+               P_ROC_JTAG_CMD_SHIFT << P_ROC_JTAG_CMD_CMD_SHIFT |
+               dataBlockComplete << P_ROC_JTAG_SHIFT_EXIT_SHIFT |
+               numBits << P_ROC_JTAG_SHIFT_NUM_BITS_SHIFT; 
+    return kPRSuccess;
+}
 
 /**
  * This is where all FTDI driver-specific code should go.

src/PRHardware.h

@@ -64,7 +64,7 @@ const uint32_t P_ROC_REG_ADDR_SHIFT         = 0;
 const uint32_t P_ROC_MODULE_SELECT_SHIFT    = 16;
 
 const uint32_t P_ROC_MANAGER_SELECT               = 0;
-const uint32_t P_ROC_BUS_MASTER_SELECT            = 1;
+const uint32_t P_ROC_BUS_JTAG_SELECT              = 1;
 const uint32_t P_ROC_BUS_SWITCH_CTRL_SELECT       = 2;
 const uint32_t P_ROC_BUS_DRIVER_CTRL_SELECT       = 3;
 const uint32_t P_ROC_BUS_STATE_CHANGE_PROC_SELECT = 4;
@@ -80,6 +80,33 @@ const uint32_t P_ROC_MANAGER_WATCHDOG_EXPIRED_SHIFT        = 30;
 const uint32_t P_ROC_MANAGER_WATCHDOG_ENABLE_SHIFT         = 14;
 const uint32_t P_ROC_MANAGER_WATCHDOG_RESET_TIME_SHIFT     = 0;
 
+const uint32_t P_ROC_JTAG_SHIFT_EXIT_SHIFT                 = 16;
+const uint32_t P_ROC_JTAG_SHIFT_NUM_BITS_SHIFT             = 0;
+
+const uint32_t P_ROC_JTAG_CMD_CHANGE_STATE                 = 0;
+const uint32_t P_ROC_JTAG_CMD_SHIFT                        = 1;
+const uint32_t P_ROC_JTAG_CMD_TRANSITION                   = 2;
+const uint32_t P_ROC_JTAG_CMD_SET_PORTS                    = 3;
+
+const uint32_t P_ROC_JTAG_CMD_START_SHIFT                  = 31;
+const uint32_t P_ROC_JTAG_CMD_OE_SHIFT                     = 30;
+const uint32_t P_ROC_JTAG_CMD_CMD_SHIFT                    = 24;
+
+const uint32_t P_ROC_JTAG_TRANSITION_TCK_MASK_SHIFT        = 6;
+const uint32_t P_ROC_JTAG_TRANSITION_TDO_MASK_SHIFT        = 5;
+const uint32_t P_ROC_JTAG_TRANSITION_TMS_MASK_SHIFT        = 4;
+const uint32_t P_ROC_JTAG_TRANSITION_TCK_SHIFT             = 2;
+const uint32_t P_ROC_JTAG_TRANSITION_TDO_SHIFT             = 1;
+const uint32_t P_ROC_JTAG_TRANSITION_TMS_SHIFT             = 0;
+
+const uint32_t P_ROC_JTAG_STATUS_DONE_SHIFT                = 31;
+const uint32_t P_ROC_JTAG_STATUS_TDI_SHIFT                 = 16;
+
+const uint32_t P_ROC_JTAG_COMMAND_REG_BASE_ADDR            = 0x0;
+const uint32_t P_ROC_JTAG_STATUS_REG_BASE_ADDR             = 0x1;
+const uint32_t P_ROC_JTAG_TDO_MEMORY_BASE_ADDR             = 0x400;
+const uint32_t P_ROC_JTAG_TDI_MEMORY_BASE_ADDR             = 0x800;
+
 const uint32_t P_ROC_SWITCH_CTRL_STATE_BASE_ADDR           = 4;
 const uint32_t P_ROC_SWITCH_CTRL_DEBOUNCE_BASE_ADDR        = 11;
 
@@ -187,6 +214,10 @@ void ParseSwitchRuleIndex(uint16_t index, uint8_t *switchNum, PREventType *event
 int16_t CreateSwitchRuleIndex(uint8_t switchNum, PREventType eventType);
 int32_t CreateSwitchRuleAddr(uint8_t switchNum, PREventType eventType);
 
+int32_t CreateJTAGLatchOutputsBurst ( uint32_t * burst, PRJTAGOutputs *jtagOutputs);
+int32_t CreateJTAGForceOutputsBurst ( uint32_t * burst, PRJTAGOutputs *jtagOutputs);
+int32_t CreateJTAGShiftTDODataBurst ( uint32_t * burst, uint16_t numBits, bool_t dataBlockComplete);
+
 
 PRResult PRHardwareOpen();
 void PRHardwareClose();

src/pinproc.cpp

@@ -293,6 +293,8 @@ PR_EXPORT PRResult PRSwitchGetStates(PRHandle handle, PREventType * switchStates
     return handleAsDevice->SwitchGetStates(switchStates, numSwitches);
 }
 
+// DMD
+
 PR_EXPORT int32_t PRDMDUpdateConfig(PRHandle handle, PRDMDConfig *dmdConfig)
 {
     return handleAsDevice->DMDUpdateConfig(dmdConfig);
@@ -302,3 +304,29 @@ PR_EXPORT PRResult PRDMDDraw(PRHandle handle, uint8_t * dots)
     return handleAsDevice->DMDDraw(dots);
 }
 
+// JTAG
+
+PR_EXPORT PRResult PRJTAGDriveOutputs(PRHandle handle, PRJTAGOutputs * jtagOutputs, bool_t toggleClk)
+{
+    return handleAsDevice->PRJTAGDriveOutputs(jtagOutputs, toggleClk);
+}
+
+PR_EXPORT PRResult PRJTAGWriteTDOMemory(PRHandle handle, uint16_t tableOffset, uint16_t numWords, uint32_t * tdoData)
+{
+    return handleAsDevice->PRJTAGWriteTDOMemory(tableOffset, numWords, tdoData);
+}
+
+PR_EXPORT PRResult PRJTAGShiftTDOData(PRHandle handle, uint16_t numBits, bool_t dataBlockComplete)
+{
+    return handleAsDevice->PRJTAGShiftTDOData(numBits, dataBlockComplete);
+}
+
+PR_EXPORT PRResult PRJTAGReadTDIMemory(PRHandle handle, uint16_t tableOffset, uint16_t numWords, uint32_t * tdiData)
+{
+    return handleAsDevice->PRJTAGReadTDIMemory(tableOffset, numWords, tdiData);
+}
+
+PR_EXPORT PRResult PRJTAGGetStatus(PRHandle handle, PRJTAGStatus * status)
+{
+    return handleAsDevice->PRJTAGGetStatus(status);
+}

utils/pinprocfw/lenval.cpp

@@ -0,0 +1,190 @@
+/*******************************************************/
+/* file: lenval.c                                      */
+/* abstract:  This file contains routines for using    */
+/*            the lenVal data structure.               */
+/*******************************************************/
+#include "lenval.h"
+#include "pinprocfw.h"
+
+/*****************************************************************************
+* Function:     value
+* Description:  Extract the long value from the lenval array.
+* Parameters:   plvValue    - ptr to lenval.
+* Returns:      long        - the extracted value.
+*****************************************************************************/
+long value( lenVal*     plvValue )
+{
+	long    lValue;         /* result to hold the accumulated result */
+	short   sIndex;
+
+    lValue  = 0;
+	for ( sIndex = 0; sIndex < plvValue->len ; ++sIndex )
+	{
+		lValue <<= 8;                       /* shift the accumulated result */
+		lValue |= plvValue->val[ sIndex];   /* get the last byte first */
+	}
+
+	return( lValue );
+}
+
+/*****************************************************************************
+* Function:     initLenVal
+* Description:  Initialize the lenval array with the given value.
+*               Assumes lValue is less than 256.
+* Parameters:   plv         - ptr to lenval.
+*               lValue      - the value to set.
+* Returns:      void.
+*****************************************************************************/
+void initLenVal( lenVal*    plv,
+                 long       lValue )
+{
+	plv->len    = 1;
+	plv->val[0] = (unsigned char)lValue;
+}
+
+/*****************************************************************************
+* Function:     EqualLenVal
+* Description:  Compare two lenval arrays with an optional mask.
+* Parameters:   plvTdoExpected  - ptr to lenval #1.
+*               plvTdoCaptured  - ptr to lenval #2.
+*               plvTdoMask      - optional ptr to mask (=0 if no mask).
+* Returns:      short   - 0 = mismatch; 1 = equal.
+*****************************************************************************/
+short EqualLenVal( lenVal*  plvTdoExpected,
+                   lenVal*  plvTdoCaptured,
+                   lenVal*  plvTdoMask )
+{
+    short           sEqual;
+	short           sIndex;
+    unsigned char   ucByteVal1;
+    unsigned char   ucByteVal2;
+    unsigned char   ucByteMask;
+
+    sEqual  = 1;
+    sIndex  = plvTdoExpected->len;
+
+    while ( sEqual && sIndex-- )
+    {
+        ucByteVal1  = plvTdoExpected->val[ sIndex ];
+        ucByteVal2  = plvTdoCaptured->val[ sIndex ];
+        if ( plvTdoMask )
+        {
+            ucByteMask  = plvTdoMask->val[ sIndex ];
+            ucByteVal1  &= ucByteMask;
+            ucByteVal2  &= ucByteMask;
+        }
+        if ( ucByteVal1 != ucByteVal2 )
+        {
+            sEqual  = 0;
+        }
+    }
+
+	return( sEqual );
+}
+
+
+/*****************************************************************************
+* Function:     RetBit
+* Description:  return the (byte, bit) of lv (reading from left to right).
+* Parameters:   plv     - ptr to lenval.
+*               iByte   - the byte to get the bit from.
+*               iBit    - the bit number (0=msb)
+* Returns:      short   - the bit value.
+*****************************************************************************/
+short RetBit( lenVal*   plv,
+              int       iByte,
+              int       iBit )
+{
+    /* assert( ( iByte >= 0 ) && ( iByte < plv->len ) ); */
+    /* assert( ( iBit >= 0 ) && ( iBit < 8 ) ); */
+    return( (short)( ( plv->val[ iByte ] >> ( 7 - iBit ) ) & 0x1 ) );
+}
+
+/*****************************************************************************
+* Function:     SetBit
+* Description:  set the (byte, bit) of lv equal to val
+* Example:      SetBit("00000000",byte, 1) equals "01000000".
+* Parameters:   plv     - ptr to lenval.
+*               iByte   - the byte to get the bit from.
+*               iBit    - the bit number (0=msb).
+*               sVal    - the bit value to set.
+* Returns:      void.
+*****************************************************************************/
+void SetBit( lenVal*    plv,
+             int        iByte,
+             int        iBit,
+             short      sVal )
+{
+    unsigned char   ucByteVal;
+    unsigned char   ucBitMask;
+
+    ucBitMask   = (unsigned char)(1 << ( 7 - iBit ));
+    ucByteVal   = (unsigned char)(plv->val[ iByte ] & (~ucBitMask));
+
+    if ( sVal )
+    {
+        ucByteVal   |= ucBitMask;
+    }
+    plv->val[ iByte ]   = ucByteVal;
+}
+
+/*****************************************************************************
+* Function:     AddVal
+* Description:  add val1 to val2 and store in resVal;
+*               assumes val1 and val2  are of equal length.
+* Parameters:   plvResVal   - ptr to result.
+*               plvVal1     - ptr of addendum.
+*               plvVal2     - ptr of addendum.
+* Returns:      void.
+*****************************************************************************/
+void addVal( lenVal*    plvResVal,
+             lenVal*    plvVal1,
+             lenVal*    plvVal2 )
+{
+	unsigned char   ucCarry;
+    unsigned short  usSum;
+    unsigned short  usVal1;
+    unsigned short  usVal2;
+	short           sIndex;
+	
+	plvResVal->len  = plvVal1->len;         /* set up length of result */
+	
+	/* start at least significant bit and add bytes    */
+    ucCarry = 0;
+    sIndex  = plvVal1->len;
+    while ( sIndex-- )
+    {
+		usVal1  = plvVal1->val[ sIndex ];   /* i'th byte of val1 */
+		usVal2  = plvVal2->val[ sIndex ];   /* i'th byte of val2 */
+		
+		/* add the two bytes plus carry from previous addition */
+		usSum   = (unsigned short)( usVal1 + usVal2 + ucCarry );
+		
+		/* set up carry for next byte */
+		ucCarry = (unsigned char)( ( usSum > 255 ) ? 1 : 0 );
+		
+        /* set the i'th byte of the result */
+		plvResVal->val[ sIndex ]    = (unsigned char)usSum;
+    }
+}
+
+/*****************************************************************************
+* Function:     readVal
+* Description:  read from XSVF numBytes bytes of data into x.
+* Parameters:   plv         - ptr to lenval in which to put the bytes read.
+*               sNumBytes   - the number of bytes to read.
+* Returns:      void.
+*****************************************************************************/
+void readVal( lenVal*   plv,
+              short     sNumBytes )
+{
+    unsigned char*  pucVal;
+	
+    plv->len    = sNumBytes;        /* set the length of the lenVal        */
+    for ( pucVal = plv->val; sNumBytes; --sNumBytes, ++pucVal )
+    {
+        /* read a byte of data into the lenVal */
+		readByte( pucVal );
+    }
+}
+

utils/pinprocfw/lenval.h

@@ -0,0 +1,94 @@
+/*******************************************************/
+/* file: lenval.h                                      */
+/* abstract:  This file contains a description of the  */
+/*            data structure "lenval".                 */
+/*******************************************************/
+
+#ifndef lenval_dot_h
+#define lenval_dot_h
+
+/* the lenVal structure is a byte oriented type used to store an */
+/* arbitrary length binary value. As an example, the hex value   */
+/* 0x0e3d is represented as a lenVal with len=2 (since 2 bytes   */
+/* and val[0]=0e and val[1]=3d.  val[2-MAX_LEN] are undefined    */
+
+/* maximum length (in bytes) of value to read in        */
+/* this needs to be at least 4, and longer than the     */
+/* length of the longest SDR instruction.  If there is, */
+/* only 1 device in the chain, MAX_LEN must be at least */
+/* ceil(27/8) == 4.  For 6 devices in a chain, MAX_LEN  */
+/* must be 5, for 14 devices MAX_LEN must be 6, for 20  */
+/* devices MAX_LEN must be 7, etc..                     */
+/* You can safely set MAX_LEN to a smaller number if you*/
+/* know how many devices will be in your chain.         */
+/*  #define MAX_LEN (Actual #define is below this comment block)
+      This #define defines the maximum length (in bytes) of predefined
+      buffers in which the XSVF player stores the current shift data.
+      This length must be greater than the longest shift length (in bytes)
+      in the XSVF files that will be processed.  7000 is a very conservative
+      number.  The buffers are stored on the stack and if you have limited
+      stack space, you may decrease the MAX_LEN value.
+
+      How to find the "shift length" in bits?
+      Look at the ASCII version of the XSVF (generated with the -a option
+      for the SVF2XSVF translator) and search for the XSDRSIZE command
+      with the biggest parameter.  XSDRSIZE is equivalent to the SVF's
+      SDR length plus the lengths of applicable HDR and TDR commands.
+      Remember that the MAX_LEN is defined in bytes.  Therefore, the
+      minimum MAX_LEN = ceil( max( XSDRSIZE ) / 8 );
+
+      The following MAX_LEN values have been tested and provide relatively
+      good margin for the corresponding devices:
+
+        DEVICE       MAX_LEN   Resulting Shift Length Max (in bits)
+        ---------    -------   ----------------------------------------------
+        XC9500/XL/XV 32        256
+
+        CoolRunner/II 256      2048   - actual max 1 device = 1035 bits
+
+        FPGA         128       1024    - svf2xsvf -rlen 1024
+
+        XC18V00/XCF00
+                     1100      8800   - no blank check performed (default)
+                                      - actual max 1 device = 8192 bits verify
+                                      - max 1 device = 4096 bits program-only
+
+        XC18V00/XCF00 when using the optional Blank Check operation
+                     2500      20000  - required for blank check
+                                      - blank check max 1 device = 16384 bits
+*/
+//#define MAX_LEN 7000
+#define MAX_LEN 1100
+
+
+typedef struct var_len_byte
+{
+    short len;   /* number of chars in this value */
+    unsigned char val[MAX_LEN+1];  /* bytes of data */
+} lenVal;
+
+
+/* return the long representation of a lenVal */
+extern long value(lenVal *x);
+
+/* set lenVal equal to value */
+extern void initLenVal(lenVal *x, long value);
+
+/* check if expected equals actual (taking the mask into account) */
+extern short EqualLenVal(lenVal *expected, lenVal *actual, lenVal *mask);
+
+/* add val1+val2 and put the result in resVal */
+extern void addVal(lenVal *resVal, lenVal *val1, lenVal *val2);
+
+/* return the (byte, bit) of lv (reading from left to right) */
+extern short RetBit(lenVal *lv, int byte, int bit);
+
+/* set the (byte, bit) of lv equal to val (e.g. SetBit("00000000",byte, 1)
+   equals "01000000" */
+extern void SetBit(lenVal *lv, int byte, int bit, short val);
+
+/* read from XSVF numBytes bytes of data into x */
+extern void  readVal(lenVal *x, short numBytes);
+
+#endif
+

utils/pinprocfw/pinprocfw.h

@@ -0,0 +1,64 @@
+/*****************************************************************************
+* File:         micro.h
+* Description:  This header file contains the function prototype to the
+*               primary interface function for the XSVF player.
+* Usage:        FIRST - PORTS.C
+*               Customize the ports.c function implementations to establish
+*               the correct protocol for communicating with your JTAG ports
+*               (setPort() and readTDOBit()) and tune the waitTime() delay
+*               function.  Also, establish access to the XSVF data source
+*               in the readByte() function.
+*               FINALLY - Call xsvfExecute().
+*****************************************************************************/
+#ifndef PINPROCFW_H
+#define PINPROCFW_H
+
+/* Legacy error codes for xsvfExecute from original XSVF player v2.0 */
+#define XSVF_LEGACY_SUCCESS 1
+#define XSVF_LEGACY_ERROR   0
+
+/* 4.04 [NEW] Error codes for xsvfExecute. */
+/* Must #define XSVF_SUPPORT_ERRORCODES in micro.c to get these codes */
+#define XSVF_ERROR_NONE         0
+#define XSVF_ERROR_UNKNOWN      1
+#define XSVF_ERROR_TDOMISMATCH  2
+#define XSVF_ERROR_MAXRETRIES   3   /* TDO mismatch after max retries */
+#define XSVF_ERROR_ILLEGALCMD   4
+#define XSVF_ERROR_ILLEGALSTATE 5
+#define XSVF_ERROR_DATAOVERFLOW 6   /* Data > lenVal MAX_LEN buffer size*/
+/* Insert new errors here */
+#define XSVF_ERROR_LAST         7
+
+/*****************************************************************************
+* Function:     xsvfExecute
+* Description:  Process, interpret, and apply the XSVF commands.
+*               See port.c:readByte for source of XSVF data.
+* Parameters:   none.
+* Returns:      int - For error codes see above.
+*****************************************************************************/
+extern int xsvfExecute();
+
+/* these constants are used to send the appropriate ports to setPort */
+/* they should be enumerated types, but some of the microcontroller  */
+/* compilers don't like enumerated types */
+#define TCK (short) 0
+#define TMS (short) 1
+#define TDI (short) 2
+
+/* set the port "p" (TCK, TMS, or TDI) to val (0 or 1) */
+void setPort(short p, short val);
+
+/* read the TDO bit and store it in val */
+unsigned char readTDOBit();
+
+/* make clock go down->up->down*/
+void pulseClock();
+
+/* read the next byte of data from the xsvf file */
+void readByte(unsigned char *data);
+
+void waitTime(long microsec);
+
+
+#endif  /* PINPROCFW_H */
+