/* Set the new TDI value */			setPort( TDI, (short)(ucTdiByte & 1) );			ucTdiByte   >>= 1;			/* Set TCK low */			setPort( TCK, 0 );			if ( pucTdo )			{				/* Save the TDO value */				ucTdoBit    = readTDOBit();				ucTdoByte   |= ( ucTdoBit << i );			}			/* Set TCK high */			setPort( TCK, 1 );		}		/* Save the TDO byte value */		if ( pucTdo )		{			(*(--pucTdo))   = ucTdoByte;		}	}}/***************************************************************************** * Function:     xsvfShift * Description:  Goes to the given starting TAP state. *               Calls xsvfShiftOnly to shift in the given TDI data and *               optionally capture the TDO data. *               Compares the TDO captured data against the TDO expected *               data. *               If a data mismatch occurs, then executes the exception *               handling loop upto ucMaxRepeat times. * Parameters:   pucTapState     - Ptr to current TAP state. *               ucStartState    - Starting shift state: Shift-DR or Shift-IR. *               lNumBits        - number of bits to shift. *               plvTdi          - ptr to lenval for TDI data. *               plvTdoCaptured  - ptr to lenval for storing TDO data. *               plvTdoExpected  - ptr to expected TDO data. *               plvTdoMask      - ptr to TDO mask. *               ucEndState      - state in which to end the shift. *               lRunTestTime    - amount of time to wait after the shift. *               ucMaxRepeat     - Maximum number of retries on TDO mismatch. * Returns:      int             - 0 = success; otherwise TDO mismatch. * Notes:        XC9500XL-only Optimization: *               Skip the waitTime() if plvTdoMask->val[0:plvTdoMask->len-1] *               is NOT all zeros and sMatch==1. *****************************************************************************/int xsvfShift( unsigned char*   pucTapState,	       unsigned char    ucStartState,	       long             lNumBits,	       lenVal*          plvTdi,	       lenVal*          plvTdoCaptured,	       lenVal*          plvTdoExpected,	       lenVal*          plvTdoMask,	       unsigned char    ucEndState,	       long             lRunTestTime,	       unsigned char    ucMaxRepeat ){	int             iErrorCode;	int             iMismatch;	unsigned char   ucRepeat;	int             iExitShift;	iErrorCode  = XSVF_ERROR_NONE;	iMismatch   = 0;	ucRepeat    = 0;	iExitShift  = ( ucStartState != ucEndState );	XSVFDBG_PRINTF1( 3, "   Shift Length = %ld\n", lNumBits );	XSVFDBG_PRINTF( 4, "    TDI          = ");	XSVFDBG_PRINTLENVAL( 4, plvTdi );	XSVFDBG_PRINTF( 4, "\n");	XSVFDBG_PRINTF( 4, "    TDO Expected = ");	XSVFDBG_PRINTLENVAL( 4, plvTdoExpected );	XSVFDBG_PRINTF( 4, "\n");	if ( !lNumBits )	{		/* Compatibility with XSVF2.00:  XSDR 0 = no shift, but wait in RTI */		if ( lRunTestTime )		{			/* Wait for prespecified XRUNTEST time */			xsvfGotoTapState( pucTapState, XTAPSTATE_RUNTEST );			XSVFDBG_PRINTF1( 3, "   Wait = %ld usec\n", lRunTestTime );			waitTime( lRunTestTime );		}	}	else	{		do		{			/* Goto Shift-DR or Shift-IR */			xsvfGotoTapState( pucTapState, ucStartState );			/* Shift TDI and capture TDO */			xsvfShiftOnly( lNumBits, plvTdi, plvTdoCaptured, iExitShift );			if ( plvTdoExpected )			{				/* Compare TDO data to expected TDO data */				iMismatch   = !EqualLenVal( plvTdoExpected,							    plvTdoCaptured,							    plvTdoMask );			}			if ( iExitShift )			{				/* Update TAP state:  Shift->Exit */				++(*pucTapState);				XSVFDBG_PRINTF1( 3, "   TAP State = %s\n",						 xsvf_pzTapState[ *pucTapState ] );				if ( iMismatch && lRunTestTime && ( ucRepeat < ucMaxRepeat ) )				{					XSVFDBG_PRINTF( 4, "    TDO Expected = ");					XSVFDBG_PRINTLENVAL( 4, plvTdoExpected );					XSVFDBG_PRINTF( 4, "\n");					XSVFDBG_PRINTF( 4, "    TDO Captured = ");					XSVFDBG_PRINTLENVAL( 4, plvTdoCaptured );					XSVFDBG_PRINTF( 4, "\n");					XSVFDBG_PRINTF( 4, "    TDO Mask     = ");					XSVFDBG_PRINTLENVAL( 4, plvTdoMask );					XSVFDBG_PRINTF( 4, "\n");					XSVFDBG_PRINTF1( 3, "   Retry #%d\n", ( ucRepeat + 1 ) );					/* Do exception handling retry - ShiftDR only */					xsvfGotoTapState( pucTapState, XTAPSTATE_PAUSEDR );					/* Shift 1 extra bit */					xsvfGotoTapState( pucTapState, XTAPSTATE_SHIFTDR );					/* Increment RUNTEST time by an additional 25% */					lRunTestTime    += ( lRunTestTime >> 2 );				}				else				{					/* Do normal exit from Shift-XR */					xsvfGotoTapState( pucTapState, ucEndState );				}				if ( lRunTestTime )				{					/* Wait for prespecified XRUNTEST time */					xsvfGotoTapState( pucTapState, XTAPSTATE_RUNTEST );					XSVFDBG_PRINTF1( 3, "   Wait = %ld usec\n", lRunTestTime );					waitTime( lRunTestTime );				}			}		} while ( iMismatch && ( ucRepeat++ < ucMaxRepeat ) );	}	if ( iMismatch )	{		XSVFDBG_PRINTF( 1, " TDO Expected = ");		XSVFDBG_PRINTLENVAL( 1, plvTdoExpected );		XSVFDBG_PRINTF( 1, "\n");		XSVFDBG_PRINTF( 1, " TDO Captured = ");		XSVFDBG_PRINTLENVAL( 1, plvTdoCaptured );		XSVFDBG_PRINTF( 1, "\n");		XSVFDBG_PRINTF( 1, " TDO Mask     = ");		XSVFDBG_PRINTLENVAL( 1, plvTdoMask );		XSVFDBG_PRINTF( 1, "\n");		if ( ucMaxRepeat && ( ucRepeat > ucMaxRepeat ) )		{			iErrorCode  = XSVF_ERROR_MAXRETRIES;		}		else		{			iErrorCode  = XSVF_ERROR_TDOMISMATCH;		}	}	return( iErrorCode );}/***************************************************************************** * Function:     xsvfBasicXSDRTDO * Description:  Get the XSDRTDO parameters and execute the XSDRTDO command. *               This is the common function for all XSDRTDO commands. * Parameters:   pucTapState         - Current TAP state. *               lShiftLengthBits    - number of bits to shift. *               sShiftLengthBytes   - number of bytes to read. *               plvTdi              - ptr to lenval for TDI data. *               lvTdoCaptured       - ptr to lenval for storing TDO data. *               iEndState           - state in which to end the shift. *               lRunTestTime        - amount of time to wait after the shift. *               ucMaxRepeat         - maximum xc9500/xl retries. * Returns:      int                 - 0 = success; otherwise TDO mismatch. *****************************************************************************/int xsvfBasicXSDRTDO( unsigned char*    pucTapState,		      long              lShiftLengthBits,		      short             sShiftLengthBytes,		      lenVal*           plvTdi,		      lenVal*           plvTdoCaptured,		      lenVal*           plvTdoExpected,		      lenVal*           plvTdoMask,		      unsigned char     ucEndState,		      long              lRunTestTime,		      unsigned char     ucMaxRepeat ){	readVal( plvTdi, sShiftLengthBytes );	if ( plvTdoExpected )	{		readVal( plvTdoExpected, sShiftLengthBytes );	}	return( xsvfShift( pucTapState, XTAPSTATE_SHIFTDR, lShiftLengthBits,			   plvTdi, plvTdoCaptured, plvTdoExpected, plvTdoMask,			   ucEndState, lRunTestTime, ucMaxRepeat ) );}/***************************************************************************** * Function:     xsvfDoSDRMasking * Description:  Update the data value with the next XSDRINC data and address. * Example:      dataVal=0x01ff, nextData=0xab, addressMask=0x0100, *               dataMask=0x00ff, should set dataVal to 0x02ab * Parameters:   plvTdi          - The current TDI value. *               plvNextData     - the next data value. *               plvAddressMask  - the address mask. *               plvDataMask     - the data mask. * Returns:      void. *****************************************************************************/#ifdef  XSVF_SUPPORT_COMPRESSIONvoid xsvfDoSDRMasking( lenVal*  plvTdi,		       lenVal*  plvNextData,		       lenVal*  plvAddressMask,		       lenVal*  plvDataMask ){	int             i;	unsigned char   ucTdi;	unsigned char   ucTdiMask;	unsigned char   ucDataMask;	unsigned char   ucNextData;	unsigned char   ucNextMask;	short           sNextData;	/* add the address Mask to dataVal and return as a new dataVal */	addVal( plvTdi, plvTdi, plvAddressMask );	ucNextData  = 0;	ucNextMask  = 0;	sNextData   = plvNextData->len;	for ( i = plvDataMask->len - 1; i >= 0; --i )	{		/* Go through data mask in reverse order looking for mask (1) bits */		ucDataMask  = plvDataMask->val[ i ];		if ( ucDataMask )		{			/* Retrieve the corresponding TDI byte value */			ucTdi       = plvTdi->val[ i ];			/* For each bit in the data mask byte, look for 1's */			ucTdiMask   = 1;			while ( ucDataMask )			{				if ( ucDataMask & 1 )				{					if ( !ucNextMask )					{						/* Get the next data byte */						ucNextData  = plvNextData->val[ --sNextData ];						ucNextMask  = 1;					}					/* Set or clear the data bit according to the next data */					if ( ucNextData & ucNextMask )					{						ucTdi   |= ucTdiMask;       /* Set bit */					}					else					{						ucTdi   &= ( ~ucTdiMask );  /* Clear bit */					}					/* Update the next data */					ucNextMask  <<= 1;				}				ucTdiMask   <<= 1;				ucDataMask  >>= 1;			}			/* Update the TDI value */			plvTdi->val[ i ]    = ucTdi;		}	}}#endif  /* XSVF_SUPPORT_COMPRESSION *//*============================================================================ * XSVF Command Functions (type = TXsvfDoCmdFuncPtr) * These functions update pXsvfInfo->iErrorCode only on an error. * Otherwise, the error code is left alone. * The function returns the error code from the function. ============================================================================*//***************************************************************************** * Function:     xsvfDoIllegalCmd * Description:  Function place holder for illegal/unsupported commands. * Parameters:   pXsvfInfo   - XSVF information pointer. * Returns:      int         - 0 = success;  non-zero = error. *****************************************************************************/int xsvfDoIllegalCmd( SXsvfInfo* pXsvfInfo ){	XSVFDBG_PRINTF2( 0, "ERROR:  Encountered unsupported command #%d (%s)\n",			 ((unsigned int)(pXsvfInfo->ucCommand)),			 ((pXsvfInfo->ucCommand < XLASTCMD)			  ? (xsvf_pzCommandName[pXsvfInfo->ucCommand])			  : "Unknown") );	pXsvfInfo->iErrorCode   = XSVF_ERROR_ILLEGALCMD;	return( pXsvfInfo->iErrorCode );}/***************************************************************************** * Function:     xsvfDoXCOMPLETE * Description:  XCOMPLETE (no parameters) *               Update complete status for XSVF player. * Parameters:   pXsvfInfo   - XSVF information pointer. * Returns:      int         - 0 = success;  non-zero = error. *****************************************************************************/int xsvfDoXCOMPLETE( SXsvfInfo* pXsvfInfo ){	pXsvfInfo->ucComplete   = 1;	return( XSVF_ERROR_NONE );}/***************************************************************************** * Function:     xsvfDoXTDOMASK * Description:  XTDOMASK <lenVal.TdoMask[XSDRSIZE]> *               Prespecify the TDO compare mask. * Parameters:   pXsvfInfo   - XSVF information pointer. * Returns:      int         - 0 = success;  non-zero = error. *****************************************************************************/int xsvfDoXTDOMASK( SXsvfInfo* pXsvfInfo ){	readVal( &(pXsvfInfo->lvTdoMask), pXsvfInfo->sShiftLengthBytes );	XSVFDBG_PRINTF( 4, "    TDO Mask     = ");	XSVFDBG_PRINTLENVAL( 4, &(pXsvfInfo->lvTdoMask) );	XSVFDBG_PRINTF( 4, "\n");	return( XSVF_ERROR_NONE );}/***************************************************************************** * Function:     xsvfDoXSIR * Description:  XSIR <(byte)shiftlen> <lenVal.TDI[shiftlen]> *               Get the instruction and shift the instruction into the TAP. *               If prespecified XRUNTEST!=0, goto RUNTEST and wait after *               the shift for XRUNTEST usec. * Parameters:   pXsvfInfo   - XSVF information pointer. * Returns:      int         - 0 = success;  non-zero = error. *****************************************************************************/int xsvfDoXSIR( SXsvfInfo* pXsvfInfo ){	unsigned char   ucShiftIrBits;	short           sShiftIrBytes;	int             iErrorCode;	/* Get the shift length and store */	readByte( &ucShiftIrBits );	sShiftIrBytes   = xsvfGetAsNumBytes( ucShiftIrBits );	XSVFDBG_PRINTF1( 3, "   XSIR length = %d\n",			 ((unsigned int)ucShiftIrBits) );	if ( sShiftIrBytes > MAX_LEN )	{		iErrorCode  = XSVF_ERROR_DATAOVERFLOW;	}	else	{		/* Get and store instruction to shift in */		readVal( &(pXsvfInfo->lvTdi), xsvfGetAsNumBytes( ucShiftIrBits ) );		/* Shift the data */		iErrorCode  = xsvfShift( &(pXsvfInfo->ucTapState), XTAPSTATE_SHIFTIR,