readme_xc18v00_xcf00s.txt

Xilinx Jtag Configuration source code, Support *.xsvf file

                         |                                      |
TCK Type 3:     __       |________________________________      | ____________
High-Low-High     \      /      ...wait with static TCK...\     |/
TCK Pulse          \____/|                                 \____/
==NOT-GOOD==             |Waiting for falling edge to Start^.End^--Too short!!
                         |                                  ^^^^
                         |                                  NOT enough time
                                                            for operation
                                                            to complete.

How To Know Which Type of TCK Implementation You Have?

    Check the TCK activity with a scope...
    or
    Look at the XAPP058 XSVF player C code...

    Step A - Check for TCK Type 1 (Continuous TCK)
        Look at PORTS.C waitTime() function to see if a continuous TCK
        clock is implemented.  (XC18V00/XCF00S erase/program wait times are
        15000000us/14000us.)
        If waitTime() function is implemented as a continuous TCK, then
        the implementation satisfies the UMC and STMicro XC18V00/XCF00S
        requirements.
            Example continuous TCK implementation in PORTS.C, waitTime() function:
                waitTime( time )
                {
                    for ( int i = 0; i < time; i++ )
                    {
                        pulseClock();   // repeatedly pulse TCK
                    }
                }
        If waitTime() function is implemented as a simple wait that does
        nothing, i.e. that holds TCK at a static level, then go to Step B
        to determine the static TCK level and TCK type.
            Example static implementations of waitTime in PORTS.C:
                // Example 1
                waitTime( time )
                {
                    for ( int i = 0; i < time; i++ )
                    {
                        // Empty loop...do nothing while waiting
                    }
                }
                // Example 2
                waitTime( time )
                {
                    sleep( time );  // call simple sleep that does nothing
                }
    Step B - Check How MICRO.C Handles TCK
        Look at the MICRO.C code to see how it handles the TCK.
        See the #define XSVF_VERSION in MICRO.C to determine the version.
        Old versions (prior to 4.x or unspecified version) of MICRO.C
        may call the pulseClock function in the PORTS.C file.  If
        MICRO.C calls pulseClock in PORTS.C, then go to Step C.
        For recent versions (4.x or later) of MICRO.C, look at the
        xsvfTmsTransition function in MICRO.C.  (xsvfTmsTransition is used to
        set the new TMS value for transitioning to a new TAP state such
        as transitioning to the Run-Test/Idle state.)
        If the xsvfTmsTransition function calls pulseClock in PORTS.C,
        then go to Step C.  Example xsvfTmsTransition that calls pulseClock:
            xsvfTmsTransition( newTmsValue )
            {
                setPort( TMS, newTmsValue );
                pulseClock();   // Go to STEP C to determine TCK type
            }
        If the xsvfTmsTransition function implements a TCK Type 3
        (High-Low-High), then there may be a problem.
        Example xsvfTmsTransition function with TCK Type 3 (High-Low-High):
            xsvfTmsTransition( newTmsValue )
            {
                setPort( TMS, newTmsValue );
                // Assumes previous TCK == High
                setPort( TCK, 0 );
                setPort( TCK, 1 );  // Low->High transition changes TAP state
                                    // Last TCK level == High.
                // PROBLEM...May not satisfy STMicro XC18V00/XCF00S sequence
                //           requirement!!!
                //           If PORTS.C waitTime function sets TCK Low,
                //           then the STMicro requirement is satisfied.
                //           If PORTS.C waitTime function does nothing to TCK
                //           then the STMicro requirement is NOT satisfied!!!
            }
    Step C - Check the TCK type in the pulseClock function in the PORTS.C file
        Look at the pulseClock function in PORTS.C.
        TCK Type 2 (Low-High-Low) pulseClock function, example implementation:
            pulseClock()
            {
                // TCK Type 2 - Low-High-Low TCK pulse
                setPort( TCK, 0 );  // Low
                setPort( TCK, 1 );  // High
                setPort( TCK, 0 );  // Low...last TCK transition is High->Low
                // GOOD--Satisfies UMC and STMicro XC18V00/XCF00S
            }
        TCK Type 3 (High-Low-High) pulseClock function, example implementation:
            pulseClock()
            {
                // TCK Type 3 - High-Low-High TCK pulse
                // Assumes previous TCK value was High
                setPort( TCK, 0 );  // Low
                setPort( TCK, 1 );  // High...last TCK transition is Low->High
                // PROBLEM...May not satisfy STMicro XC18V00/XCF00S sequence
                //           requirement!!!
                //           If PORTS.C waitTime function sets TCK Low,
                //           then the STMicro requirement is satisfied.
                //           If PORTS.C waitTime function does nothing to TCK
                //           then the STMicro requirement is NOT satisfied!!!
            }

How To Fix a TCK Type 3 (High-Low-High) Problem:
    XSVF Player Workaround (ONLY for v5.xx XSVF Players):
        For a v5.xx XSVF player implementation that does not meet
        the Special ST Micro XC18V00/XCF00S PROM Requirement:
        Use the -xwait option when translating the iMPACT 5.2.03i SVF
        to XSVF.  For example:
            svf2xsvf502 -r 0 -xwait -i myfile.svf -o myfile.xsvf
            where
            -r 0 = Zero retries.  (Retries applicable to only XC9500 series.)
            -xwait = use the XSVF XWAIT command.
            -i myfile.svf  = input SVF file
            -o myfile.xsvf = output XSVF file

    Generic Fix (All XSVF Player Versions):
        The fix is to set the TCK to a Low value in the PORTS.C waitTime
        function prior to the wait period.  This will ensure the High->Low
        TCK transition requirement of the STMicro XC18V00/XCF00S.
            Example waitTime function fix in PORTS.C:
                waitTime( time )
                {
                    setPort( TCK, 0 );  // ***FIX:  Make sure TCK High->Low
                                        //          transition occurs within
                                        //          TAP Run-Test/Idle prior
                                        //          to the wait period.
                    // Wait for requested period
                    for ( int i = 0; i < time; i++ )
                    {
                        // Empty loop...do nothing while waiting
                    }
                }

    Alternate Generic Fix (All XSVF Player Versions):
        The alternate fix is to pulse the TCK at least once in the PORTS.C
        waitTime function prior to the wait period.  This will ensure the
        High->Low TCK transition requirement of the STMicro XC18V00/XCF00S.
            Example waitTime function alternate fix in PORTS.C:
                waitTime( time )
                {
                    pulseClock();   // ***FIX:  A full TCK clock period
                                    //          ensures a TCK High->Low
                                    //          transition occurs within
                                    //          TAP Run-Test/Idle prior
                                    //          to the wait period.
                    // Wait for requested period
                    for ( int i = 0; i < time; i++ )
                    {
                        // Empty loop...do nothing while waiting
                    }
                }