"DREXIT1",      /* 0x05 */	"DRPAUSE",      /* 0x06 */	"DREXIT2",      /* 0x07 */	"DRUPDATE",     /* 0x08 */	"IRSELECT",     /* 0x09 */	"IRCAPTURE",    /* 0x0A */	"IRSHIFT",      /* 0x0B */	"IREXIT1",      /* 0x0C */	"IRPAUSE",      /* 0x0D */	"IREXIT2",      /* 0x0E */	"IRUPDATE"      /* 0x0F */};#endif  /* DEBUG_MODE *//*#ifdef DEBUG_MODE	*//*    FILE* in;   /XXX* Legacy DEBUG_MODE file pointer */int xsvf_iDebugLevel;/*#endif /XXX* DEBUG_MODE *//*============================================================================ * Utility Functions ============================================================================*//***************************************************************************** * Function:     xsvfPrintLenVal * Description:  Print the lenval value in hex. * Parameters:   plv     - ptr to lenval. * Returns:      void. *****************************************************************************/#ifdef  DEBUG_MODEvoid xsvfPrintLenVal( lenVal *plv ){	int i;	if ( plv )	{		printf( "0x" );		for ( i = 0; i < plv->len; ++i )		{			printf( "%02x", ((unsigned int)(plv->val[ i ])) );		}	}}#endif  /* DEBUG_MODE *//***************************************************************************** * Function:     xsvfInfoInit * Description:  Initialize the xsvfInfo data. * Parameters:   pXsvfInfo   - ptr to the XSVF info structure. * Returns:      int         - 0 = success; otherwise error. *****************************************************************************/int xsvfInfoInit( SXsvfInfo* pXsvfInfo ){	XSVFDBG_PRINTF1( 4, "    sizeof( SXsvfInfo ) = %d bytes\n",			 sizeof( SXsvfInfo ) );	pXsvfInfo->ucComplete       = 0;	pXsvfInfo->ucCommand        = XCOMPLETE;	pXsvfInfo->lCommandCount    = 0;	pXsvfInfo->iErrorCode       = XSVF_ERROR_NONE;	pXsvfInfo->ucMaxRepeat      = 0;	pXsvfInfo->ucTapState       = XTAPSTATE_RESET;	pXsvfInfo->ucEndIR          = XTAPSTATE_RUNTEST;	pXsvfInfo->ucEndDR          = XTAPSTATE_RUNTEST;	pXsvfInfo->lShiftLengthBits = 0L;	pXsvfInfo->sShiftLengthBytes= 0;	pXsvfInfo->lRunTestTime     = 0L;	return( 0 );}/***************************************************************************** * Function:     xsvfInfoCleanup * Description:  Cleanup the xsvfInfo data. * Parameters:   pXsvfInfo   - ptr to the XSVF info structure. * Returns:      void. *****************************************************************************/void xsvfInfoCleanup( SXsvfInfo* pXsvfInfo ){}/***************************************************************************** * Function:     xsvfGetAsNumBytes * Description:  Calculate the number of bytes the given number of bits *               consumes. * Parameters:   lNumBits    - the number of bits. * Returns:      short       - the number of bytes to store the number of bits. *****************************************************************************/short xsvfGetAsNumBytes( long lNumBits ){	return( (short)( ( lNumBits + 7L ) / 8L ) );}/***************************************************************************** * Function:     xsvfTmsTransition * Description:  Apply TMS and transition TAP controller by applying one TCK *               cycle. * Parameters:   sTms    - new TMS value. * Returns:      void. *****************************************************************************/void xsvfTmsTransition( short sTms ){	setPort( TMS, sTms );	setPort( TCK, 0 );	setPort( TCK, 1 );}/***************************************************************************** * Function:     xsvfGotoTapState * Description:  From the current TAP state, go to the named TAP state. *               A target state of RESET ALWAYS causes TMS reset sequence. *               All SVF standard stable state paths are supported. *               All state transitions are supported except for the following *               which cause an XSVF_ERROR_ILLEGALSTATE: *                   - Target==DREXIT2;  Start!=DRPAUSE *                   - Target==IREXIT2;  Start!=IRPAUSE * Parameters:   pucTapState     - Current TAP state; returns final TAP state. *               ucTargetState   - New target TAP state. * Returns:      int             - 0 = success; otherwise error. *****************************************************************************/int xsvfGotoTapState( unsigned char*   pucTapState,		      unsigned char    ucTargetState ){	int i;	int iErrorCode;	iErrorCode  = XSVF_ERROR_NONE;	if ( ucTargetState == XTAPSTATE_RESET )	{		/* If RESET, always perform TMS reset sequence to reset/sync TAPs */		xsvfTmsTransition( 1 );		for ( i = 0; i < 5; ++i )		{			setPort( TCK, 0 );			setPort( TCK, 1 );		}		*pucTapState    = XTAPSTATE_RESET;		XSVFDBG_PRINTF( 3, "   TMS Reset Sequence -> Test-Logic-Reset\n" );		XSVFDBG_PRINTF1( 3, "   TAP State = %s\n",				 xsvf_pzTapState[ *pucTapState ] );	} else if ( ( ucTargetState != *pucTapState ) &&		  ( ( ( ucTargetState == XTAPSTATE_EXIT2DR ) && ( *pucTapState != XTAPSTATE_PAUSEDR ) ) ||		    ( ( ucTargetState == XTAPSTATE_EXIT2IR ) && ( *pucTapState != XTAPSTATE_PAUSEIR ) ) ) )	{		/* Trap illegal TAP state path specification */		iErrorCode      = XSVF_ERROR_ILLEGALSTATE;	} else {		if ( ucTargetState == *pucTapState )		{			/* Already in target state.  Do nothing except when in DRPAUSE			   or in IRPAUSE to comply with SVF standard */			if ( ucTargetState == XTAPSTATE_PAUSEDR )			{				xsvfTmsTransition( 1 );				*pucTapState    = XTAPSTATE_EXIT2DR;				XSVFDBG_PRINTF1( 3, "   TAP State = %s\n",						 xsvf_pzTapState[ *pucTapState ] );			}			else if ( ucTargetState == XTAPSTATE_PAUSEIR )			{				xsvfTmsTransition( 1 );				*pucTapState    = XTAPSTATE_EXIT2IR;				XSVFDBG_PRINTF1( 3, "   TAP State = %s\n",						 xsvf_pzTapState[ *pucTapState ] );			}		}		/* Perform TAP state transitions to get to the target state */		while ( ucTargetState != *pucTapState )		{			switch ( *pucTapState )			{			case XTAPSTATE_RESET:				xsvfTmsTransition( 0 );				*pucTapState    = XTAPSTATE_RUNTEST;				break;			case XTAPSTATE_RUNTEST:				xsvfTmsTransition( 1 );				*pucTapState    = XTAPSTATE_SELECTDR;				break;			case XTAPSTATE_SELECTDR:				if ( ucTargetState >= XTAPSTATE_IRSTATES )				{					xsvfTmsTransition( 1 );					*pucTapState    = XTAPSTATE_SELECTIR;				}				else				{					xsvfTmsTransition( 0 );					*pucTapState    = XTAPSTATE_CAPTUREDR;				}				break;			case XTAPSTATE_CAPTUREDR:				if ( ucTargetState == XTAPSTATE_SHIFTDR )				{					xsvfTmsTransition( 0 );					*pucTapState    = XTAPSTATE_SHIFTDR;				}				else				{					xsvfTmsTransition( 1 );					*pucTapState    = XTAPSTATE_EXIT1DR;				}				break;			case XTAPSTATE_SHIFTDR:				xsvfTmsTransition( 1 );				*pucTapState    = XTAPSTATE_EXIT1DR;				break;			case XTAPSTATE_EXIT1DR:				if ( ucTargetState == XTAPSTATE_PAUSEDR )				{					xsvfTmsTransition( 0 );					*pucTapState    = XTAPSTATE_PAUSEDR;				}				else				{					xsvfTmsTransition( 1 );					*pucTapState    = XTAPSTATE_UPDATEDR;				}				break;			case XTAPSTATE_PAUSEDR:				xsvfTmsTransition( 1 );				*pucTapState    = XTAPSTATE_EXIT2DR;				break;			case XTAPSTATE_EXIT2DR:				if ( ucTargetState == XTAPSTATE_SHIFTDR )				{					xsvfTmsTransition( 0 );					*pucTapState    = XTAPSTATE_SHIFTDR;				}				else				{					xsvfTmsTransition( 1 );					*pucTapState    = XTAPSTATE_UPDATEDR;				}				break;			case XTAPSTATE_UPDATEDR:				if ( ucTargetState == XTAPSTATE_RUNTEST )				{					xsvfTmsTransition( 0 );					*pucTapState    = XTAPSTATE_RUNTEST;				}				else				{					xsvfTmsTransition( 1 );					*pucTapState    = XTAPSTATE_SELECTDR;				}				break;			case XTAPSTATE_SELECTIR:				xsvfTmsTransition( 0 );				*pucTapState    = XTAPSTATE_CAPTUREIR;				break;			case XTAPSTATE_CAPTUREIR:				if ( ucTargetState == XTAPSTATE_SHIFTIR )				{					xsvfTmsTransition( 0 );					*pucTapState    = XTAPSTATE_SHIFTIR;				}				else				{					xsvfTmsTransition( 1 );					*pucTapState    = XTAPSTATE_EXIT1IR;				}				break;			case XTAPSTATE_SHIFTIR:				xsvfTmsTransition( 1 );				*pucTapState    = XTAPSTATE_EXIT1IR;				break;			case XTAPSTATE_EXIT1IR:				if ( ucTargetState == XTAPSTATE_PAUSEIR )				{					xsvfTmsTransition( 0 );					*pucTapState    = XTAPSTATE_PAUSEIR;				}				else				{					xsvfTmsTransition( 1 );					*pucTapState    = XTAPSTATE_UPDATEIR;				}				break;			case XTAPSTATE_PAUSEIR:				xsvfTmsTransition( 1 );				*pucTapState    = XTAPSTATE_EXIT2IR;				break;			case XTAPSTATE_EXIT2IR:				if ( ucTargetState == XTAPSTATE_SHIFTIR )				{					xsvfTmsTransition( 0 );					*pucTapState    = XTAPSTATE_SHIFTIR;				}				else				{					xsvfTmsTransition( 1 );					*pucTapState    = XTAPSTATE_UPDATEIR;				}				break;			case XTAPSTATE_UPDATEIR:				if ( ucTargetState == XTAPSTATE_RUNTEST )				{					xsvfTmsTransition( 0 );					*pucTapState    = XTAPSTATE_RUNTEST;				}				else				{					xsvfTmsTransition( 1 );					*pucTapState    = XTAPSTATE_SELECTDR;				}				break;			default:				iErrorCode      = XSVF_ERROR_ILLEGALSTATE;				*pucTapState    = ucTargetState;    /* Exit while loop */				break;			}			XSVFDBG_PRINTF1( 3, "   TAP State = %s\n",					 xsvf_pzTapState[ *pucTapState ] );		}	}	return( iErrorCode );}/***************************************************************************** * Function:     xsvfShiftOnly * Description:  Assumes that starting TAP state is SHIFT-DR or SHIFT-IR. *               Shift the given TDI data into the JTAG scan chain. *               Optionally, save the TDO data shifted out of the scan chain. *               Last shift cycle is special:  capture last TDO, set last TDI, *               but does not pulse TCK.  Caller must pulse TCK and optionally *               set TMS=1 to exit shift state. * Parameters:   lNumBits        - number of bits to shift. *               plvTdi          - ptr to lenval for TDI data. *               plvTdoCaptured  - ptr to lenval for storing captured TDO data. *               iExitShift      - 1=exit at end of shift; 0=stay in Shift-DR. * Returns:      void. *****************************************************************************/void xsvfShiftOnly( long    lNumBits,		    lenVal* plvTdi,		    lenVal* plvTdoCaptured,		    int     iExitShift ){	unsigned char*  pucTdi;	unsigned char*  pucTdo;	unsigned char   ucTdiByte;	unsigned char   ucTdoByte;	unsigned char   ucTdoBit;	int             i;	/* assert( ( ( lNumBits + 7 ) / 8 ) == plvTdi->len ); */	/* Initialize TDO storage len == TDI len */	pucTdo  = 0;	if ( plvTdoCaptured )	{		plvTdoCaptured->len = plvTdi->len;		pucTdo              = plvTdoCaptured->val + plvTdi->len;	}	/* Shift LSB first.  val[N-1] == LSB.  val[0] == MSB. */	pucTdi  = plvTdi->val + plvTdi->len;	while ( lNumBits )	{		/* Process on a byte-basis */		ucTdiByte   = (*(--pucTdi));		ucTdoByte   = 0;		for ( i = 0; ( lNumBits && ( i < 8 ) ); ++i )		{			--lNumBits;			if ( iExitShift && !lNumBits )			{				/* Exit Shift-DR state */				setPort( TMS, 1 );			}