1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008 Peter Hettkamp *
9 * peter.hettkamp@htp-tel.de *
11 * Copyright (C) 2009 SoftPLC Corporation. http://softplc.com *
12 * Dick Hollenbeck <dick@softplc.com> *
14 * This program is free software; you can redistribute it and/or modify *
15 * it under the terms of the GNU General Public License as published by *
16 * the Free Software Foundation; either version 2 of the License, or *
17 * (at your option) any later version. *
19 * This program is distributed in the hope that it will be useful, *
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
22 * GNU General Public License for more details. *
24 * You should have received a copy of the GNU General Public License *
25 * along with this program; if not, write to the *
26 * Free Software Foundation, Inc., *
27 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
28 ***************************************************************************/
31 /* The specification for SVF is available here:
32 * http://www.asset-intertech.com/support/svf.pdf
33 * Below, this document is refered to as the "SVF spec".
35 * The specification for XSVF is available here:
36 * http://www.xilinx.com/support/documentation/application_notes/xapp503.pdf
37 * Below, this document is refered to as the "XSVF spec".
61 /* XSVF commands, from appendix B of xapp503.pdf */
62 #define XCOMPLETE 0x00
70 #define XSETSDRMASKS 0x0A
85 /* XWAITSTATE is not in the xilinx XSVF spec, but the svf2xsvf.py translator
86 * generates this. Arguably it is needed because the XSVF XRUNTEST command
87 * was ill conceived and does not directly flow out of the SVF RUNTEST command.
88 * This XWAITSTATE does map directly from the SVF RUNTEST command.
90 #define XWAITSTATE 0x18
92 /* Lattice has extended the SVF file format, and Dick Hollenbeck's python based
93 * SVF2XSVF converter supports these 3 additional XSVF opcodes, LCOUNT, LDELAY, LSDR.
94 * Here is an example of usage of the 3 lattice opcode extensions:
96 ! Set the maximum loop count to 25.
98 ! Step to DRPAUSE give 5 clocks and wait for 1.00e+000 SEC.
99 LDELAY DRPAUSE 5 TCK 1.00E-003 SEC;
100 ! Test for the completed status. Match means pass.
101 ! Loop back to LDELAY line if not match and loop count less than 25.
113 /* XSVF valid state values for the XSTATE command, from appendix B of xapp503.pdf */
114 #define XSV_RESET 0x00
115 #define XSV_IDLE 0x01
116 #define XSV_DRSELECT 0x02
117 #define XSV_DRCAPTURE 0x03
118 #define XSV_DRSHIFT 0x04
119 #define XSV_DREXIT1 0x05
120 #define XSV_DRPAUSE 0x06
121 #define XSV_DREXIT2 0x07
122 #define XSV_DRUPDATE 0x08
123 #define XSV_IRSELECT 0x09
124 #define XSV_IRCAPTURE 0x0A
125 #define XSV_IRSHIFT 0x0B
126 #define XSV_IREXIT1 0x0C
127 #define XSV_IRPAUSE 0x0D
128 #define XSV_IREXIT2 0x0E
129 #define XSV_IRUPDATE 0x0F
131 /* arguments to XTRST */
135 #define XTRST_ABSENT 3
137 #define XSTATE_MAX_PATH 12
139 static int handle_xsvf_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
141 static int xsvf_fd
= 0;
144 /* map xsvf tap state to an openocd "tap_state_t" */
145 static tap_state_t
xsvf_to_tap( int xsvf_state
)
151 case XSV_RESET
: ret
= TAP_RESET
; break;
152 case XSV_IDLE
: ret
= TAP_IDLE
; break;
153 case XSV_DRSELECT
: ret
= TAP_DRSELECT
; break;
154 case XSV_DRCAPTURE
: ret
= TAP_DRCAPTURE
; break;
155 case XSV_DRSHIFT
: ret
= TAP_DRSHIFT
; break;
156 case XSV_DREXIT1
: ret
= TAP_DREXIT1
; break;
157 case XSV_DRPAUSE
: ret
= TAP_DRPAUSE
; break;
158 case XSV_DREXIT2
: ret
= TAP_DREXIT2
; break;
159 case XSV_DRUPDATE
: ret
= TAP_DRUPDATE
; break;
160 case XSV_IRSELECT
: ret
= TAP_IRSELECT
; break;
161 case XSV_IRCAPTURE
: ret
= TAP_IRCAPTURE
; break;
162 case XSV_IRSHIFT
: ret
= TAP_IRSHIFT
; break;
163 case XSV_IREXIT1
: ret
= TAP_IREXIT1
; break;
164 case XSV_IRPAUSE
: ret
= TAP_IRPAUSE
; break;
165 case XSV_IREXIT2
: ret
= TAP_IREXIT2
; break;
166 case XSV_IRUPDATE
: ret
= TAP_IRUPDATE
; break;
168 LOG_ERROR( "UNKNOWN XSVF STATE 0x%02X", xsvf_state
);
177 * Function xsvf_add_statemove
178 * moves from the current state to the goal \a state. This needs
179 * to be handled according to the xsvf spec, see the XSTATE command
182 static int xsvf_add_statemove(tap_state_t goal_state
)
184 int retval
= ERROR_OK
;
186 tap_state_t moves
[8];
187 tap_state_t cur_state
= cmd_queue_cur_state
;
192 LOG_DEBUG( "cur_state=%s goal_state=%s",
193 tap_state_name(cur_state
),
194 tap_state_name(goal_state
) );
197 /* From the XSVF spec, pertaining to XSTATE:
199 For special states known as stable states (Test-Logic-Reset,
200 Run-Test/Idle, Pause-DR, Pause- IR), an XSVF interpreter follows
201 predefined TAP state paths when the starting state is a stable state and
202 when the XSTATE specifies a new stable state (see the STATE command in
203 the [Ref 5] for the TAP state paths between stable states). For
204 non-stable states, XSTATE should specify a state that is only one TAP
205 state transition distance from the current TAP state to avoid undefined
206 TAP state paths. A sequence of multiple XSTATE commands can be issued to
207 transition the TAP through a specific state path.
210 if (goal_state
==cur_state
)
211 ; /* nothing to do */
213 else if( goal_state
==TAP_RESET
)
218 else if( tap_is_state_stable(cur_state
) && tap_is_state_stable(goal_state
) )
220 /* note: unless tms_bits holds a path that agrees with [Ref 5] in above
221 spec, then this code is not fully conformant to the xsvf spec. This
222 puts a burden on tap_get_tms_path() function from the xsvf spec.
223 If in doubt, you should confirm that that burden is being met.
226 tms_bits
= tap_get_tms_path(cur_state
, goal_state
);
227 tms_count
= tap_get_tms_path_len(cur_state
, goal_state
);
229 assert( (unsigned) tms_count
< DIM(moves
) );
231 for (i
=0; i
<tms_count
; i
++, tms_bits
>>=1)
233 bool bit
= tms_bits
& 1;
235 cur_state
= tap_state_transition(cur_state
, bit
);
236 moves
[i
] = cur_state
;
239 jtag_add_pathmove(tms_count
, moves
);
242 /* else state must be immediately reachable in one clock cycle, and does not
243 need to be a stable state.
245 else if( tap_state_transition(cur_state
, true) == goal_state
246 || tap_state_transition(cur_state
, false) == goal_state
)
248 /* move a single state */
249 moves
[0] = goal_state
;
250 jtag_add_pathmove( 1, moves
);
262 int xsvf_register_commands(struct command_context_s
*cmd_ctx
)
264 register_command(cmd_ctx
, NULL
, "xsvf", handle_xsvf_command
,
265 COMMAND_EXEC
, "run xsvf <file> [virt2] [quiet]");
270 static int xsvf_read_buffer(int num_bits
, int fd
, u8
* buf
)
274 for (num_bytes
= (num_bits
+ 7) / 8; num_bytes
> 0; num_bytes
--)
276 /* reverse the order of bytes as they are read sequentially from file */
277 if (read(fd
, buf
+ num_bytes
- 1, 1) < 0)
278 return ERROR_XSVF_EOF
;
285 static int handle_xsvf_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
287 u8
*dr_out_buf
= NULL
; /* from host to device (TDI) */
288 u8
*dr_in_buf
= NULL
; /* from device to host (TDO) */
289 u8
*dr_in_mask
= NULL
;
292 int xruntest
= 0; /* number of TCK cycles OR microseconds */
293 int xrepeat
= 0; /* number of retries */
295 tap_state_t xendir
= TAP_IDLE
; /* see page 8 of the SVF spec, initial xendir to be TAP_IDLE */
296 tap_state_t xenddr
= TAP_IDLE
;
300 long file_offset
= 0;
303 tap_state_t loop_state
= TAP_IDLE
;
309 int tdo_mismatch
= 0;
314 int runtest_requires_tck
= 0; /* a flag telling whether to clock TCK during waits, or simply sleep, controled by virt2 */
317 /* use NULL to indicate a "plain" xsvf file which accounts for
318 additional devices in the scan chain, otherwise the device
319 that should be affected
321 jtag_tap_t
*tap
= NULL
;
325 command_print(cmd_ctx
, "usage: xsvf <device#|plain> <file> [<variant>] [quiet]");
329 filename
= args
[1]; /* we mess with args starting point below, snapshot filename here */
331 if (strcmp(args
[0], "plain") != 0)
333 tap
= jtag_TapByString( args
[0] );
336 command_print( cmd_ctx
, "Tap: %s unknown", args
[0] );
341 if ((xsvf_fd
= open(filename
, O_RDONLY
)) < 0)
343 command_print(cmd_ctx
, "file \"%s\" not found", filename
);
347 /* if this argument is present, then interpret xruntest counts as TCK cycles rather than as usecs */
348 if ((argc
> 2) && (strcmp(args
[2], "virt2") == 0))
350 runtest_requires_tck
= 1;
355 if ((argc
> 2) && (strcmp(args
[2], "quiet") == 0))
360 LOG_USER("xsvf processing file: \"%s\"", filename
);
362 while( read(xsvf_fd
, &opcode
, 1) > 0 )
364 /* record the position of the just read opcode within the file */
365 file_offset
= lseek(xsvf_fd
, 0, SEEK_CUR
) - 1;
370 LOG_DEBUG("XCOMPLETE");
372 result
= jtag_execute_queue();
373 if (result
!= ERROR_OK
)
381 LOG_DEBUG("XTDOMASK");
382 if (dr_in_mask
&& (xsvf_read_buffer(xsdrsize
, xsvf_fd
, dr_in_mask
) != ERROR_OK
))
390 if (read(xsvf_fd
, xruntest_buf
, 4) < 0)
396 xruntest
= be_to_h_u32(xruntest_buf
);
397 LOG_DEBUG("XRUNTEST %d 0x%08X", xruntest
, xruntest
);
405 if (read(xsvf_fd
, &myrepeat
, 1) < 0)
410 LOG_DEBUG("XREPEAT %d", xrepeat
);
419 if (read(xsvf_fd
, xsdrsize_buf
, 4) < 0)
425 xsdrsize
= be_to_h_u32(xsdrsize_buf
);
426 LOG_DEBUG("XSDRSIZE %d", xsdrsize
);
428 if( dr_out_buf
) free(dr_out_buf
);
429 if( dr_in_buf
) free(dr_in_buf
);
430 if( dr_in_mask
) free(dr_in_mask
);
432 dr_out_buf
= malloc((xsdrsize
+ 7) / 8);
433 dr_in_buf
= malloc((xsdrsize
+ 7) / 8);
434 dr_in_mask
= malloc((xsdrsize
+ 7) / 8);
438 case XSDR
: /* these two are identical except for the dr_in_buf */
445 const char* op_name
= (opcode
== XSDR
? "XSDR" : "XSDRTDO");
447 if (xsvf_read_buffer(xsdrsize
, xsvf_fd
, dr_out_buf
) != ERROR_OK
)
453 if (opcode
== XSDRTDO
)
455 if(xsvf_read_buffer(xsdrsize
, xsvf_fd
, dr_in_buf
) != ERROR_OK
)
465 LOG_DEBUG("%s %d", op_name
, xsdrsize
);
467 for( attempt
=0; attempt
<limit
; ++attempt
)
473 /* perform the XC9500 exception handling sequence shown in xapp067.pdf and
474 illustrated in psuedo code at end of this file. We start from state
482 This sequence should be harmless for other devices, and it
483 will be skipped entirely if xrepeat is set to zero.
486 static tap_state_t exception_path
[] = {
494 jtag_add_pathmove( DIM(exception_path
), exception_path
);
497 LOG_USER("%s mismatch, xsdrsize=%d retry=%d", op_name
, xsdrsize
, attempt
);
501 field
.num_bits
= xsdrsize
;
502 field
.out_value
= dr_out_buf
;
503 field
.in_value
= calloc(CEIL(field
.num_bits
, 8), 1);
506 jtag_add_plain_dr_scan(1, &field
, TAP_DRPAUSE
);
508 jtag_add_dr_scan(1, &field
, TAP_DRPAUSE
);
510 jtag_check_value_mask(&field
, dr_in_buf
, dr_in_mask
);
512 free(field
.in_value
);
515 /* LOG_DEBUG("FLUSHING QUEUE"); */
516 result
= jtag_execute_queue();
517 if (result
== ERROR_OK
)
526 LOG_USER( "%s mismatch", op_name
);
531 /* See page 19 of XSVF spec regarding opcode "XSDR" */
534 xsvf_add_statemove(TAP_IDLE
);
536 if (runtest_requires_tck
)
537 jtag_add_clocks(xruntest
);
539 jtag_add_sleep(xruntest
);
541 else if (xendir
!= TAP_DRPAUSE
) /* we are already in TAP_DRPAUSE */
542 xsvf_add_statemove(xenddr
);
547 LOG_ERROR("unsupported XSETSDRMASKS\n");
552 LOG_ERROR("unsupported XSDRINC\n");
557 LOG_ERROR("unsupported XSDRB\n");
562 LOG_ERROR("unsupported XSDRC\n");
567 LOG_ERROR("unsupported XSDRE\n");
572 LOG_ERROR("unsupported XSDRTDOB\n");
577 LOG_ERROR("unsupported XSDRTDOC\n");
582 LOG_ERROR("unsupported XSDRTDOE\n");
591 if (read(xsvf_fd
, &uc
, 1) < 0)
597 mystate
= xsvf_to_tap(uc
);
599 LOG_DEBUG("XSTATE 0x%02X %s", uc
, tap_state_name(mystate
) );
601 /* there is no need for the lookahead code that was here since we
602 queue up the jtag commands anyway. This is a simple way to handle
606 if( xsvf_add_statemove( mystate
) != ERROR_OK
)
608 /* For special states known as stable states
609 (Test-Logic-Reset, Run-Test/Idle, Pause-DR, Pause- IR),
610 an XSVF interpreter follows predefined TAP state paths
611 when the starting state is a stable state and when the
612 XSTATE specifies a new stable state (see the STATE
613 command in the [Ref 5] for the TAP state paths between
614 stable states). For non-stable states, XSTATE should
615 specify a state that is only one TAP state transition
616 distance from the current TAP state to avoid undefined
617 TAP state paths. A sequence of multiple XSTATE commands
618 can be issued to transition the TAP through a specific
622 LOG_ERROR("XSTATE %s is not reachable from current state %s in one clock cycle",
623 tap_state_name(mystate
),
624 tap_state_name(cmd_queue_cur_state
)
632 if (read(xsvf_fd
, &uc
, 1) < 0)
638 /* see page 22 of XSVF spec */
642 xendir
= TAP_IRPAUSE
;
645 LOG_ERROR("illegial XENDIR argument: 0x%02X", uc
);
650 LOG_DEBUG("XENDIR 0x%02X %s", uc
, tap_state_name(xendir
));
655 if (read(xsvf_fd
, &uc
, 1) < 0)
661 /* see page 22 of XSVF spec */
665 xenddr
= TAP_DRPAUSE
;
668 LOG_ERROR("illegial XENDDR argument: 0x%02X", uc
);
673 LOG_DEBUG("XENDDR %02X %s", uc
, tap_state_name(xenddr
));
682 tap_state_t my_end_state
= xruntest
? TAP_IDLE
: xendir
;
686 /* one byte bitcount */
687 if (read(xsvf_fd
, short_buf
, 1) < 0)
692 bitcount
= short_buf
[0];
693 LOG_DEBUG("XSIR %d", bitcount
);
697 if (read(xsvf_fd
, short_buf
, 2) < 0)
702 bitcount
= be_to_h_u16(short_buf
);
703 LOG_DEBUG("XSIR2 %d", bitcount
);
706 ir_buf
= malloc((bitcount
+7) / 8);
708 if (xsvf_read_buffer(bitcount
, xsvf_fd
, ir_buf
) != ERROR_OK
)
715 field
.num_bits
= bitcount
;
716 field
.out_value
= ir_buf
;
718 field
.in_value
= NULL
;
724 jtag_add_plain_ir_scan(1, &field
, my_end_state
);
726 jtag_add_ir_scan(1, &field
, my_end_state
);
730 if (runtest_requires_tck
)
731 jtag_add_clocks(xruntest
);
733 jtag_add_sleep(xruntest
);
736 /* Note that an -irmask of non-zero in your config file
737 * can cause this to fail. Setting -irmask to zero cand work
738 * around the problem.
741 /* LOG_DEBUG("FLUSHING QUEUE"); */
742 result
= jtag_execute_queue();
743 if(result
!= ERROR_OK
)
754 unsigned int ndx
= 0;
759 if (read(xsvf_fd
, &uc
, 1) < 0)
765 if ( ndx
< sizeof(comment
)-1 )
770 comment
[sizeof(comment
)-1] = 0; /* regardless, terminate */
772 LOG_USER("# %s", comment
);
778 /* expected in stream:
779 XWAIT <u8 wait_state> <u8 end_state> <u32 usecs>
786 tap_state_t wait_state
;
787 tap_state_t end_state
;
790 if ( read(xsvf_fd
, &wait
, 1) < 0
791 || read(xsvf_fd
, &end
, 1) < 0
792 || read(xsvf_fd
, delay_buf
, 4) < 0)
798 wait_state
= xsvf_to_tap(wait
);
799 end_state
= xsvf_to_tap(end
);
800 delay
= be_to_h_u32(delay_buf
);
802 LOG_DEBUG("XWAIT %s %s usecs:%d", tap_state_name(wait_state
), tap_state_name(end_state
), delay
);
804 if (runtest_requires_tck
&& wait_state
== TAP_IDLE
)
806 jtag_add_runtest(delay
, end_state
);
810 xsvf_add_statemove( wait_state
);
811 jtag_add_sleep(delay
);
812 xsvf_add_statemove( end_state
);
819 /* expected in stream:
820 XWAITSTATE <u8 wait_state> <u8 end_state> <u32 clock_count> <u32 usecs>
827 tap_state_t wait_state
;
828 tap_state_t end_state
;
832 if ( read(xsvf_fd
, &wait
, 1) < 0
833 || read(xsvf_fd
, &end
, 1) < 0
834 || read(xsvf_fd
, clock_buf
, 4) < 0
835 || read(xsvf_fd
, usecs_buf
, 4) < 0 )
841 wait_state
= xsvf_to_tap( wait
);
842 end_state
= xsvf_to_tap( end
);
844 clock_count
= be_to_h_u32(clock_buf
);
845 usecs
= be_to_h_u32(usecs_buf
);
847 LOG_DEBUG("XWAITSTATE %s %s clocks:%i usecs:%i",
848 tap_state_name(wait_state
),
849 tap_state_name(end_state
),
852 /* the following states are 'stable', meaning that they have a transition
853 * in the state diagram back to themselves. This is necessary because we will
854 * be issuing a number of clocks in this state. This set of allowed states is also
855 * determined by the SVF RUNTEST command's allowed states.
857 if (wait_state
!= TAP_IRPAUSE
&& wait_state
!= TAP_DRPAUSE
&& wait_state
!= TAP_RESET
&& wait_state
!= TAP_IDLE
)
859 LOG_ERROR("illegal XWAITSTATE wait_state: \"%s\"", tap_state_name( wait_state
));
863 xsvf_add_statemove( wait_state
);
865 jtag_add_clocks( clock_count
);
867 jtag_add_sleep( usecs
);
869 xsvf_add_statemove( end_state
);
875 /* expected in stream:
876 LCOUNT <u32 loop_count>
880 if ( read(xsvf_fd
, count_buf
, 4) < 0 )
886 loop_count
= be_to_h_u32(count_buf
);
887 LOG_DEBUG("LCOUNT %d", loop_count
);
893 /* expected in stream:
894 LDELAY <u8 wait_state> <u32 clock_count> <u32 usecs_to_sleep>
900 if ( read(xsvf_fd
, &state
, 1) < 0
901 || read(xsvf_fd
, clock_buf
, 4) < 0
902 || read(xsvf_fd
, usecs_buf
, 4) < 0 )
908 loop_state
= xsvf_to_tap(state
);
909 loop_clocks
= be_to_h_u32(clock_buf
);
910 loop_usecs
= be_to_h_u32(usecs_buf
);
912 LOG_DEBUG("LDELAY %s clocks:%d usecs:%d", tap_state_name(loop_state
), loop_clocks
, loop_usecs
);
916 /* LSDR is more like XSDRTDO than it is like XSDR. It uses LDELAY which
917 * comes with clocks !AND! sleep requirements.
921 int limit
= loop_count
;
927 if ( xsvf_read_buffer(xsdrsize
, xsvf_fd
, dr_out_buf
) != ERROR_OK
928 || xsvf_read_buffer(xsdrsize
, xsvf_fd
, dr_in_buf
) != ERROR_OK
)
937 for( attempt
=0; attempt
<limit
; ++attempt
)
941 xsvf_add_statemove( loop_state
);
942 jtag_add_clocks(loop_clocks
);
943 jtag_add_sleep(loop_usecs
);
946 field
.num_bits
= xsdrsize
;
947 field
.out_value
= dr_out_buf
;
948 field
.in_value
= calloc(CEIL(field
.num_bits
, 8), 1);
950 if (attempt
> 0 && verbose
)
951 LOG_USER("LSDR retry %d", attempt
);
954 jtag_add_plain_dr_scan(1, &field
, TAP_DRPAUSE
);
956 jtag_add_dr_scan(1, &field
, TAP_DRPAUSE
);
958 jtag_check_value_mask(&field
, dr_in_buf
, dr_in_mask
);
960 free(field
.in_value
);
963 /* LOG_DEBUG("FLUSHING QUEUE"); */
964 result
= jtag_execute_queue();
965 if(result
== ERROR_OK
)
974 LOG_USER( "LSDR mismatch" );
985 if (read(xsvf_fd
, &trst_mode
, 1) < 0)
994 jtag_add_reset(1, 0);
998 jtag_add_reset(0, 0);
1003 LOG_ERROR( "XTRST mode argument (0x%02X) out of range", trst_mode
);
1010 LOG_ERROR("unknown xsvf command (0x%02X)\n", uc
);
1014 if (do_abort
|| unsupported
|| tdo_mismatch
)
1016 LOG_DEBUG("xsvf failed, setting taps to reasonable state");
1018 /* upon error, return the TAPs to a reasonable state */
1019 xsvf_add_statemove( TAP_IDLE
);
1020 jtag_execute_queue();
1027 command_print(cmd_ctx
, "TDO mismatch, somewhere near offset %lu in xsvf file, aborting",
1036 command_print(cmd_ctx
,
1037 "unsupported xsvf command: 0x%02X in xsvf file at offset %ld, aborting",
1038 uc
, lseek(xsvf_fd
, 0, SEEK_CUR
)-1 );
1044 command_print(cmd_ctx
, "premature end of xsvf file detected, aborting");
1059 command_print(cmd_ctx
, "XSVF file programmed successfully");
1065 #if 0 /* this comment style used to try and keep uncrustify from adding * at begin of line */
1067 PSUEDO
-Code from Xilinx Appnote XAPP067
.pdf
:
1069 the following pseudo code clarifies the intent of the xrepeat support
. The
1070 flow given is
for the entire processing of an SVF file
, not an XSVF file
.
1071 No idea
if this is just
for the XC9500
/XL
/XV devices
or all Xilinx parts
.
1073 "Pseudo-Code Algorithm for SVF-Based ISP"
1075 1. Go to Test
-Logic
-Reset state
1076 2. Go to Run
-Test Idle state
1079 4. if SIR record then
1080 go to Shift
-IR state
1083 5. else if SDR record then
1084 set
<repeat count
> to
0
1085 store
<TDI value
> as
<current TDI value
>
1086 store
<TDO value
> as
<current TDO value
>
1087 6. go to Shift
-DR state
1088 scan in
<current TDI value
>
1089 if <current TDO value
> is specified then
1090 if <current TDO value
> does
not equal
<actual TDO value
> then
1091 if <repeat count
> > 32 then
1093 go to Run
-Test Idle state
1102 increment
<repeat count
> by
1
1103 pause
<current pause time
> microseconds
1107 go to Run
-Test Idle state
1110 else if RUNTEST record then
1111 pause tester
for <TCK value
> microseconds
1112 store
<TCK value
> as
<current pause time
>
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)