Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
remove in_handler usage
[openocd.git] / src / xsvf / xsvf.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2008 Peter Hettkamp *
9 * peter.hettkamp@htp-tel.de *
10 * *
11 * Copyright (C) 2009 SoftPLC Corporation. http://softplc.com *
12 * Dick Hollenbeck <dick@softplc.com> *
13 * *
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. *
18 * *
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. *
23 * *
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 ***************************************************************************/
29
30
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".
34 *
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".
38 */
39
40 #ifdef HAVE_CONFIG_H
41 #include "config.h"
42 #endif
43
44 #include "xsvf.h"
45
46 #include "jtag.h"
47 #include "command.h"
48 #include "log.h"
49
50 #include <stdlib.h>
51 #include <unistd.h>
52 #include <sys/types.h>
53 #include <sys/stat.h>
54 #include <fcntl.h>
55 #include <string.h>
56 #include <assert.h>
57
58 #include <sys/time.h>
59 #include <time.h>
60
61
62 /* XSVF commands, from appendix B of xapp503.pdf */
63 #define XCOMPLETE 0x00
64 #define XTDOMASK 0x01
65 #define XSIR 0x02
66 #define XSDR 0x03
67 #define XRUNTEST 0x04
68 #define XREPEAT 0x07
69 #define XSDRSIZE 0x08
70 #define XSDRTDO 0x09
71 #define XSETSDRMASKS 0x0A
72 #define XSDRINC 0x0B
73 #define XSDRB 0x0C
74 #define XSDRC 0x0D
75 #define XSDRE 0x0E
76 #define XSDRTDOB 0x0F
77 #define XSDRTDOC 0x10
78 #define XSDRTDOE 0x11
79 #define XSTATE 0x12
80 #define XENDIR 0x13
81 #define XENDDR 0x14
82 #define XSIR2 0x15
83 #define XCOMMENT 0x16
84 #define XWAIT 0x17
85
86 /* XWAITSTATE is not in the xilinx XSVF spec, but the svf2xsvf.py translator
87 * generates this. Arguably it is needed because the XSVF XRUNTEST command
88 * was ill conceived and does not directly flow out of the SVF RUNTEST command.
89 * This XWAITSTATE does map directly from the SVF RUNTEST command.
90 */
91 #define XWAITSTATE 0x18
92
93 /* Lattice has extended the SVF file format, and Dick Hollenbeck's python based
94 * SVF2XSVF converter supports these 3 additional XSVF opcodes, LCOUNT, LDELAY, LSDR.
95 * Here is an example of usage of the 3 lattice opcode extensions:
96
97 ! Set the maximum loop count to 25.
98 LCOUNT 25;
99 ! Step to DRPAUSE give 5 clocks and wait for 1.00e+000 SEC.
100 LDELAY DRPAUSE 5 TCK 1.00E-003 SEC;
101 ! Test for the completed status. Match means pass.
102 ! Loop back to LDELAY line if not match and loop count less than 25.
103
104 LSDR 1 TDI (0)
105 TDO (1);
106 */
107
108 #define LCOUNT 0x19
109 #define LDELAY 0x1A
110 #define LSDR 0x1B
111 #define XTRST 0x1C
112
113
114 /* XSVF valid state values for the XSTATE command, from appendix B of xapp503.pdf */
115 #define XSV_RESET 0x00
116 #define XSV_IDLE 0x01
117 #define XSV_DRSELECT 0x02
118 #define XSV_DRCAPTURE 0x03
119 #define XSV_DRSHIFT 0x04
120 #define XSV_DREXIT1 0x05
121 #define XSV_DRPAUSE 0x06
122 #define XSV_DREXIT2 0x07
123 #define XSV_DRUPDATE 0x08
124 #define XSV_IRSELECT 0x09
125 #define XSV_IRCAPTURE 0x0A
126 #define XSV_IRSHIFT 0x0B
127 #define XSV_IREXIT1 0x0C
128 #define XSV_IRPAUSE 0x0D
129 #define XSV_IREXIT2 0x0E
130 #define XSV_IRUPDATE 0x0F
131
132 /* arguments to XTRST */
133 #define XTRST_ON 0
134 #define XTRST_OFF 1
135 #define XTRST_Z 2
136 #define XTRST_ABSENT 3
137
138 #define XSTATE_MAX_PATH 12
139
140 static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
141
142 static int xsvf_fd = 0;
143
144
145 /* map xsvf tap state to an openocd "tap_state_t" */
146 static tap_state_t xsvf_to_tap( int xsvf_state )
147 {
148 tap_state_t ret;
149
150 switch( xsvf_state )
151 {
152 case XSV_RESET: ret = TAP_RESET; break;
153 case XSV_IDLE: ret = TAP_IDLE; break;
154 case XSV_DRSELECT: ret = TAP_DRSELECT; break;
155 case XSV_DRCAPTURE: ret = TAP_DRCAPTURE; break;
156 case XSV_DRSHIFT: ret = TAP_DRSHIFT; break;
157 case XSV_DREXIT1: ret = TAP_DREXIT1; break;
158 case XSV_DRPAUSE: ret = TAP_DRPAUSE; break;
159 case XSV_DREXIT2: ret = TAP_DREXIT2; break;
160 case XSV_DRUPDATE: ret = TAP_DRUPDATE; break;
161 case XSV_IRSELECT: ret = TAP_IRSELECT; break;
162 case XSV_IRCAPTURE: ret = TAP_IRCAPTURE; break;
163 case XSV_IRSHIFT: ret = TAP_IRSHIFT; break;
164 case XSV_IREXIT1: ret = TAP_IREXIT1; break;
165 case XSV_IRPAUSE: ret = TAP_IRPAUSE; break;
166 case XSV_IREXIT2: ret = TAP_IREXIT2; break;
167 case XSV_IRUPDATE: ret = TAP_IRUPDATE; break;
168 default:
169 LOG_ERROR( "UNKNOWN XSVF STATE 0x%02X", xsvf_state );
170 exit(1);
171 }
172
173 return ret;
174 }
175
176
177 /**
178 * Function xsvf_add_statemove
179 * moves from the current state to the goal \a state. This needs
180 * to be handled according to the xsvf spec, see the XSTATE command
181 * description.
182 */
183 static int xsvf_add_statemove(tap_state_t goal_state)
184 {
185 int retval = ERROR_OK;
186
187 tap_state_t moves[8];
188 tap_state_t cur_state = cmd_queue_cur_state;
189 int i;
190 int tms_bits;
191 int tms_count;
192
193 LOG_DEBUG( "cur_state=%s goal_state=%s",
194 tap_state_name(cur_state),
195 tap_state_name(goal_state) );
196
197
198 /* From the XSVF spec, pertaining to XSTATE:
199
200 For special states known as stable states (Test-Logic-Reset,
201 Run-Test/Idle, Pause-DR, Pause- IR), an XSVF interpreter follows
202 predefined TAP state paths when the starting state is a stable state and
203 when the XSTATE specifies a new stable state (see the STATE command in
204 the [Ref 5] for the TAP state paths between stable states). For
205 non-stable states, XSTATE should specify a state that is only one TAP
206 state transition distance from the current TAP state to avoid undefined
207 TAP state paths. A sequence of multiple XSTATE commands can be issued to
208 transition the TAP through a specific state path.
209 */
210
211 if (goal_state==cur_state )
212 ; /* nothing to do */
213
214 else if( goal_state==TAP_RESET )
215 {
216 jtag_add_tlr();
217 }
218
219 else if( tap_is_state_stable(cur_state) && tap_is_state_stable(goal_state) )
220 {
221 /* note: unless tms_bits holds a path that agrees with [Ref 5] in above
222 spec, then this code is not fully conformant to the xsvf spec. This
223 puts a burden on tap_get_tms_path() function from the xsvf spec.
224 If in doubt, you should confirm that that burden is being met.
225 */
226
227 tms_bits = tap_get_tms_path(cur_state, goal_state);
228 tms_count = tap_get_tms_path_len(cur_state, goal_state);
229
230 assert( (unsigned) tms_count < DIM(moves) );
231
232 for (i=0; i<tms_count; i++, tms_bits>>=1)
233 {
234 bool bit = tms_bits & 1;
235
236 cur_state = tap_state_transition(cur_state, bit);
237 moves[i] = cur_state;
238 }
239
240 jtag_add_pathmove(tms_count, moves);
241 }
242
243 /* else state must be immediately reachable in one clock cycle, and does not
244 need to be a stable state.
245 */
246 else if( tap_state_transition(cur_state, true) == goal_state
247 || tap_state_transition(cur_state, false) == goal_state )
248 {
249 /* move a single state */
250 moves[0] = goal_state;
251 jtag_add_pathmove( 1, moves );
252 }
253
254 else
255 {
256 retval = ERROR_FAIL;
257 }
258
259 return retval;
260 }
261
262
263 int xsvf_register_commands(struct command_context_s *cmd_ctx)
264 {
265 register_command(cmd_ctx, NULL, "xsvf", handle_xsvf_command,
266 COMMAND_EXEC, "run xsvf <file> [virt2] [quiet]");
267
268 return ERROR_OK;
269 }
270
271 static int xsvf_read_buffer(int num_bits, int fd, u8* buf)
272 {
273 int num_bytes;
274
275 for (num_bytes = (num_bits + 7) / 8; num_bytes > 0; num_bytes--)
276 {
277 /* reverse the order of bytes as they are read sequentially from file */
278 if (read(fd, buf + num_bytes - 1, 1) < 0)
279 return ERROR_XSVF_EOF;
280 }
281
282 return ERROR_OK;
283 }
284
285
286 static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
287 {
288 u8 *dr_out_buf = NULL; /* from host to device (TDI) */
289 u8 *dr_in_buf = NULL; /* from device to host (TDO) */
290 u8 *dr_in_mask = NULL;
291
292 int xsdrsize = 0;
293 int xruntest = 0; /* number of TCK cycles OR microseconds */
294 int xrepeat = 0; /* number of retries */
295
296 tap_state_t xendir = TAP_IDLE; /* see page 8 of the SVF spec, initial xendir to be TAP_IDLE */
297 tap_state_t xenddr = TAP_IDLE;
298
299 u8 opcode;
300 u8 uc;
301 long file_offset = 0;
302
303 int loop_count = 0;
304 tap_state_t loop_state = TAP_IDLE;
305 int loop_clocks = 0;
306 int loop_usecs = 0;
307
308 int do_abort = 0;
309 int unsupported = 0;
310 int tdo_mismatch = 0;
311 int result;
312 int verbose = 1;
313 char* filename;
314
315 int runtest_requires_tck = 0; /* a flag telling whether to clock TCK during waits, or simply sleep, controled by virt2 */
316
317
318 /* use NULL to indicate a "plain" xsvf file which accounts for
319 additional devices in the scan chain, otherwise the device
320 that should be affected
321 */
322 jtag_tap_t *tap = NULL;
323
324 if (argc < 2)
325 {
326 command_print(cmd_ctx, "usage: xsvf <device#|plain> <file> [<variant>] [quiet]");
327 return ERROR_FAIL;
328 }
329
330 filename = args[1]; /* we mess with args starting point below, snapshot filename here */
331
332 if (strcmp(args[0], "plain") != 0)
333 {
334 tap = jtag_TapByString( args[0] );
335 if (!tap )
336 {
337 command_print( cmd_ctx, "Tap: %s unknown", args[0] );
338 return ERROR_FAIL;
339 }
340 }
341
342 if ((xsvf_fd = open(filename, O_RDONLY)) < 0)
343 {
344 command_print(cmd_ctx, "file \"%s\" not found", filename);
345 return ERROR_FAIL;
346 }
347
348 /* if this argument is present, then interpret xruntest counts as TCK cycles rather than as usecs */
349 if ((argc > 2) && (strcmp(args[2], "virt2") == 0))
350 {
351 runtest_requires_tck = 1;
352 --argc;
353 ++args;
354 }
355
356 if ((argc > 2) && (strcmp(args[2], "quiet") == 0))
357 {
358 verbose = 0;
359 }
360
361 LOG_USER("xsvf processing file: \"%s\"", filename);
362
363 while( read(xsvf_fd, &opcode, 1) > 0 )
364 {
365 /* record the position of the just read opcode within the file */
366 file_offset = lseek(xsvf_fd, 0, SEEK_CUR) - 1;
367
368 switch (opcode)
369 {
370 case XCOMPLETE:
371 LOG_DEBUG("XCOMPLETE");
372
373 result = jtag_execute_queue();
374 if (result != ERROR_OK)
375 {
376 tdo_mismatch = 1;
377 break;
378 }
379 break;
380
381 case XTDOMASK:
382 LOG_DEBUG("XTDOMASK");
383 if (dr_in_mask && (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_mask) != ERROR_OK))
384 do_abort = 1;
385 break;
386
387 case XRUNTEST:
388 {
389 u8 xruntest_buf[4];
390
391 if (read(xsvf_fd, xruntest_buf, 4) < 0)
392 {
393 do_abort = 1;
394 break;
395 }
396
397 xruntest = be_to_h_u32(xruntest_buf);
398 LOG_DEBUG("XRUNTEST %d 0x%08X", xruntest, xruntest);
399 }
400 break;
401
402 case XREPEAT:
403 {
404 u8 myrepeat;
405
406 if (read(xsvf_fd, &myrepeat, 1) < 0)
407 do_abort = 1;
408 else
409 {
410 xrepeat = myrepeat;
411 LOG_DEBUG("XREPEAT %d", xrepeat );
412 }
413 }
414 break;
415
416 case XSDRSIZE:
417 {
418 u8 xsdrsize_buf[4];
419
420 if (read(xsvf_fd, xsdrsize_buf, 4) < 0)
421 {
422 do_abort = 1;
423 break;
424 }
425
426 xsdrsize = be_to_h_u32(xsdrsize_buf);
427 LOG_DEBUG("XSDRSIZE %d", xsdrsize);
428
429 if( dr_out_buf ) free(dr_out_buf);
430 if( dr_in_buf) free(dr_in_buf);
431 if( dr_in_mask) free(dr_in_mask);
432
433 dr_out_buf = malloc((xsdrsize + 7) / 8);
434 dr_in_buf = malloc((xsdrsize + 7) / 8);
435 dr_in_mask = malloc((xsdrsize + 7) / 8);
436 }
437 break;
438
439 case XSDR: /* these two are identical except for the dr_in_buf */
440 case XSDRTDO:
441 {
442 int limit = xrepeat;
443 int matched = 0;
444 int attempt;
445
446 const char* op_name = (opcode == XSDR ? "XSDR" : "XSDRTDO");
447
448 if (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK)
449 {
450 do_abort = 1;
451 break;
452 }
453
454 if (opcode == XSDRTDO)
455 {
456 if(xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf) != ERROR_OK )
457 {
458 do_abort = 1;
459 break;
460 }
461 }
462
463 if (limit < 1)
464 limit = 1;
465
466 LOG_DEBUG("%s %d", op_name, xsdrsize);
467
468 for( attempt=0; attempt<limit; ++attempt )
469 {
470 scan_field_t field;
471
472 if( attempt>0 )
473 {
474 /* perform the XC9500 exception handling sequence shown in xapp067.pdf and
475 illustrated in psuedo code at end of this file. We start from state
476 DRPAUSE:
477 go to Exit2-DR
478 go to Shift-DR
479 go to Exit1-DR
480 go to Update-DR
481 go to Run-Test/Idle
482
483 This sequence should be harmless for other devices, and it
484 will be skipped entirely if xrepeat is set to zero.
485 */
486
487 static tap_state_t exception_path[] = {
488 TAP_DREXIT2,
489 TAP_DRSHIFT,
490 TAP_DREXIT1,
491 TAP_DRUPDATE,
492 TAP_IDLE,
493 };
494
495 jtag_add_pathmove( DIM(exception_path), exception_path );
496
497 if (verbose)
498 LOG_USER("%s mismatch, xsdrsize=%d retry=%d", op_name, xsdrsize, attempt);
499 }
500
501 field.tap = tap;
502 field.num_bits = xsdrsize;
503 field.out_value = dr_out_buf;
504
505 field.in_value = NULL;
506
507 jtag_set_check_value(&field, dr_in_buf, dr_in_mask, NULL);
508
509 if (tap == NULL)
510 jtag_add_plain_dr_scan(1, &field, TAP_DRPAUSE);
511 else
512 jtag_add_dr_scan(1, &field, TAP_DRPAUSE);
513
514 /* LOG_DEBUG("FLUSHING QUEUE"); */
515 result = jtag_execute_queue();
516 if (result == ERROR_OK)
517 {
518 matched = 1;
519 break;
520 }
521 }
522
523 if (!matched)
524 {
525 LOG_USER( "%s mismatch", op_name);
526 tdo_mismatch = 1;
527 break;
528 }
529
530 /* See page 19 of XSVF spec regarding opcode "XSDR" */
531 if (xruntest)
532 {
533 xsvf_add_statemove(TAP_IDLE);
534
535 if (runtest_requires_tck)
536 jtag_add_clocks(xruntest);
537 else
538 jtag_add_sleep(xruntest);
539 }
540 else if (xendir != TAP_DRPAUSE) /* we are already in TAP_DRPAUSE */
541 xsvf_add_statemove(xenddr);
542 }
543 break;
544
545 case XSETSDRMASKS:
546 LOG_ERROR("unsupported XSETSDRMASKS\n");
547 unsupported = 1;
548 break;
549
550 case XSDRINC:
551 LOG_ERROR("unsupported XSDRINC\n");
552 unsupported = 1;
553 break;
554
555 case XSDRB:
556 LOG_ERROR("unsupported XSDRB\n");
557 unsupported = 1;
558 break;
559
560 case XSDRC:
561 LOG_ERROR("unsupported XSDRC\n");
562 unsupported = 1;
563 break;
564
565 case XSDRE:
566 LOG_ERROR("unsupported XSDRE\n");
567 unsupported = 1;
568 break;
569
570 case XSDRTDOB:
571 LOG_ERROR("unsupported XSDRTDOB\n");
572 unsupported = 1;
573 break;
574
575 case XSDRTDOC:
576 LOG_ERROR("unsupported XSDRTDOC\n");
577 unsupported = 1;
578 break;
579
580 case XSDRTDOE:
581 LOG_ERROR("unsupported XSDRTDOE\n");
582 unsupported = 1;
583 break;
584
585 case XSTATE:
586 {
587 tap_state_t mystate;
588 u8 uc;
589
590 if (read(xsvf_fd, &uc, 1) < 0)
591 {
592 do_abort = 1;
593 break;
594 }
595
596 mystate = xsvf_to_tap(uc);
597
598 LOG_DEBUG("XSTATE 0x%02X %s", uc, tap_state_name(mystate) );
599
600 /* there is no need for the lookahead code that was here since we
601 queue up the jtag commands anyway. This is a simple way to handle
602 the XSTATE.
603 */
604
605 if( xsvf_add_statemove( mystate ) != ERROR_OK )
606 {
607 /* For special states known as stable states
608 (Test-Logic-Reset, Run-Test/Idle, Pause-DR, Pause- IR),
609 an XSVF interpreter follows predefined TAP state paths
610 when the starting state is a stable state and when the
611 XSTATE specifies a new stable state (see the STATE
612 command in the [Ref 5] for the TAP state paths between
613 stable states). For non-stable states, XSTATE should
614 specify a state that is only one TAP state transition
615 distance from the current TAP state to avoid undefined
616 TAP state paths. A sequence of multiple XSTATE commands
617 can be issued to transition the TAP through a specific
618 state path.
619 */
620
621 LOG_ERROR("XSTATE %s is not reachable from current state %s in one clock cycle",
622 tap_state_name(mystate),
623 tap_state_name(cmd_queue_cur_state)
624 );
625 }
626 }
627 break;
628
629 case XENDIR:
630
631 if (read(xsvf_fd, &uc, 1) < 0)
632 {
633 do_abort = 1;
634 break;
635 }
636
637 /* see page 22 of XSVF spec */
638 if( uc == 0 )
639 xendir = TAP_IDLE;
640 else if( uc == 1 )
641 xendir = TAP_IRPAUSE;
642 else
643 {
644 LOG_ERROR("illegial XENDIR argument: 0x%02X", uc);
645 unsupported = 1;
646 break;
647 }
648
649 LOG_DEBUG("XENDIR 0x%02X %s", uc, tap_state_name(xendir));
650 break;
651
652 case XENDDR:
653
654 if (read(xsvf_fd, &uc, 1) < 0)
655 {
656 do_abort = 1;
657 break;
658 }
659
660 /* see page 22 of XSVF spec */
661 if( uc == 0 )
662 xenddr = TAP_IDLE;
663 else if( uc == 1 )
664 xenddr = TAP_DRPAUSE;
665 else
666 {
667 LOG_ERROR("illegial XENDDR argument: 0x%02X", uc);
668 unsupported = 1;
669 break;
670 }
671
672 LOG_DEBUG("XENDDR %02X %s", uc, tap_state_name(xenddr));
673 break;
674
675 case XSIR:
676 case XSIR2:
677 {
678 u8 short_buf[2];
679 u8* ir_buf;
680 int bitcount;
681 tap_state_t my_end_state = xruntest ? TAP_IDLE : xendir;
682
683 if( opcode == XSIR )
684 {
685 /* one byte bitcount */
686 if (read(xsvf_fd, short_buf, 1) < 0)
687 {
688 do_abort = 1;
689 break;
690 }
691 bitcount = short_buf[0];
692 LOG_DEBUG("XSIR %d", bitcount);
693 }
694 else
695 {
696 if (read(xsvf_fd, short_buf, 2) < 0)
697 {
698 do_abort = 1;
699 break;
700 }
701 bitcount = be_to_h_u16(short_buf);
702 LOG_DEBUG("XSIR2 %d", bitcount);
703 }
704
705 ir_buf = malloc((bitcount+7) / 8);
706
707 if (xsvf_read_buffer(bitcount, xsvf_fd, ir_buf) != ERROR_OK)
708 do_abort = 1;
709 else
710 {
711 scan_field_t field;
712
713 field.tap = tap;
714 field.num_bits = bitcount;
715 field.out_value = ir_buf;
716
717 field.in_value = NULL;
718
719
720 field.in_handler = NULL;
721
722 if (tap == NULL)
723 jtag_add_plain_ir_scan(1, &field, my_end_state);
724 else
725 jtag_add_ir_scan(1, &field, my_end_state);
726
727 if (xruntest)
728 {
729 if (runtest_requires_tck)
730 jtag_add_clocks(xruntest);
731 else
732 jtag_add_sleep(xruntest);
733 }
734
735 /* Note that an -irmask of non-zero in your config file
736 * can cause this to fail. Setting -irmask to zero cand work
737 * around the problem.
738 */
739
740 /* LOG_DEBUG("FLUSHING QUEUE"); */
741 result = jtag_execute_queue();
742 if(result != ERROR_OK)
743 {
744 tdo_mismatch = 1;
745 }
746 }
747 free(ir_buf);
748 }
749 break;
750
751 case XCOMMENT:
752 {
753 unsigned int ndx = 0;
754 char comment[128];
755
756 do
757 {
758 if (read(xsvf_fd, &uc, 1) < 0)
759 {
760 do_abort = 1;
761 break;
762 }
763
764 if ( ndx < sizeof(comment)-1 )
765 comment[ndx++] = uc;
766
767 } while (uc != 0);
768
769 comment[sizeof(comment)-1] = 0; /* regardless, terminate */
770 if (verbose)
771 LOG_USER("# %s", comment);
772 }
773 break;
774
775 case XWAIT:
776 {
777 /* expected in stream:
778 XWAIT <u8 wait_state> <u8 end_state> <u32 usecs>
779 */
780
781 u8 wait;
782 u8 end;
783 u8 delay_buf[4];
784
785 tap_state_t wait_state;
786 tap_state_t end_state;
787 int delay;
788
789 if ( read(xsvf_fd, &wait, 1) < 0
790 || read(xsvf_fd, &end, 1) < 0
791 || read(xsvf_fd, delay_buf, 4) < 0)
792 {
793 do_abort = 1;
794 break;
795 }
796
797 wait_state = xsvf_to_tap(wait);
798 end_state = xsvf_to_tap(end);
799 delay = be_to_h_u32(delay_buf);
800
801 LOG_DEBUG("XWAIT %s %s usecs:%d", tap_state_name(wait_state), tap_state_name(end_state), delay);
802
803 if (runtest_requires_tck && wait_state == TAP_IDLE )
804 {
805 jtag_add_runtest(delay, end_state);
806 }
807 else
808 {
809 xsvf_add_statemove( wait_state );
810 jtag_add_sleep(delay);
811 xsvf_add_statemove( end_state );
812 }
813 }
814 break;
815
816 case XWAITSTATE:
817 {
818 /* expected in stream:
819 XWAITSTATE <u8 wait_state> <u8 end_state> <u32 clock_count> <u32 usecs>
820 */
821
822 u8 clock_buf[4];
823 u8 usecs_buf[4];
824 u8 wait;
825 u8 end;
826 tap_state_t wait_state;
827 tap_state_t end_state;
828 int clock_count;
829 int usecs;
830
831 if ( read(xsvf_fd, &wait, 1) < 0
832 || read(xsvf_fd, &end, 1) < 0
833 || read(xsvf_fd, clock_buf, 4) < 0
834 || read(xsvf_fd, usecs_buf, 4) < 0 )
835 {
836 do_abort = 1;
837 break;
838 }
839
840 wait_state = xsvf_to_tap( wait );
841 end_state = xsvf_to_tap( end );
842
843 clock_count = be_to_h_u32(clock_buf);
844 usecs = be_to_h_u32(usecs_buf);
845
846 LOG_DEBUG("XWAITSTATE %s %s clocks:%i usecs:%i",
847 tap_state_name(wait_state),
848 tap_state_name(end_state),
849 clock_count, usecs);
850
851 /* the following states are 'stable', meaning that they have a transition
852 * in the state diagram back to themselves. This is necessary because we will
853 * be issuing a number of clocks in this state. This set of allowed states is also
854 * determined by the SVF RUNTEST command's allowed states.
855 */
856 if (wait_state != TAP_IRPAUSE && wait_state != TAP_DRPAUSE && wait_state != TAP_RESET && wait_state != TAP_IDLE)
857 {
858 LOG_ERROR("illegal XWAITSTATE wait_state: \"%s\"", tap_state_name( wait_state ));
859 unsupported = 1;
860 }
861
862 xsvf_add_statemove( wait_state );
863
864 jtag_add_clocks( clock_count );
865
866 jtag_add_sleep( usecs );
867
868 xsvf_add_statemove( end_state );
869 }
870 break;
871
872 case LCOUNT:
873 {
874 /* expected in stream:
875 LCOUNT <u32 loop_count>
876 */
877 u8 count_buf[4];
878
879 if ( read(xsvf_fd, count_buf, 4) < 0 )
880 {
881 do_abort = 1;
882 break;
883 }
884
885 loop_count = be_to_h_u32(count_buf);
886 LOG_DEBUG("LCOUNT %d", loop_count);
887 }
888 break;
889
890 case LDELAY:
891 {
892 /* expected in stream:
893 LDELAY <u8 wait_state> <u32 clock_count> <u32 usecs_to_sleep>
894 */
895 u8 state;
896 u8 clock_buf[4];
897 u8 usecs_buf[4];
898
899 if ( read(xsvf_fd, &state, 1) < 0
900 || read(xsvf_fd, clock_buf, 4) < 0
901 || read(xsvf_fd, usecs_buf, 4) < 0 )
902 {
903 do_abort = 1;
904 break;
905 }
906
907 loop_state = xsvf_to_tap(state);
908 loop_clocks = be_to_h_u32(clock_buf);
909 loop_usecs = be_to_h_u32(usecs_buf);
910
911 LOG_DEBUG("LDELAY %s clocks:%d usecs:%d", tap_state_name(loop_state), loop_clocks, loop_usecs);
912 }
913 break;
914
915 /* LSDR is more like XSDRTDO than it is like XSDR. It uses LDELAY which
916 * comes with clocks !AND! sleep requirements.
917 */
918 case LSDR:
919 {
920 int limit = loop_count;
921 int matched = 0;
922 int attempt;
923
924 LOG_DEBUG("LSDR");
925
926 if ( xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK
927 || xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf) != ERROR_OK )
928 {
929 do_abort = 1;
930 break;
931 }
932
933 if (limit < 1)
934 limit = 1;
935
936 for( attempt=0; attempt<limit; ++attempt )
937 {
938 scan_field_t field;
939
940 xsvf_add_statemove( loop_state );
941 jtag_add_clocks(loop_clocks);
942 jtag_add_sleep(loop_usecs);
943
944 field.tap = tap;
945 field.num_bits = xsdrsize;
946 field.out_value = dr_out_buf;
947
948 field.in_value = NULL;
949
950 if (attempt > 0 && verbose)
951 LOG_USER("LSDR retry %d", attempt);
952
953 jtag_set_check_value(&field, dr_in_buf, dr_in_mask, NULL);
954 if (tap == NULL)
955 jtag_add_plain_dr_scan(1, &field, TAP_DRPAUSE);
956 else
957 jtag_add_dr_scan(1, &field, TAP_DRPAUSE);
958
959 /* LOG_DEBUG("FLUSHING QUEUE"); */
960 result = jtag_execute_queue();
961 if(result == ERROR_OK)
962 {
963 matched = 1;
964 break;
965 }
966 }
967
968 if (!matched )
969 {
970 LOG_USER( "LSDR mismatch" );
971 tdo_mismatch = 1;
972 break;
973 }
974 }
975 break;
976
977 case XTRST:
978 {
979 u8 trst_mode;
980
981 if (read(xsvf_fd, &trst_mode, 1) < 0)
982 {
983 do_abort = 1;
984 break;
985 }
986
987 switch( trst_mode )
988 {
989 case XTRST_ON:
990 jtag_add_reset(1, 0);
991 break;
992 case XTRST_OFF:
993 case XTRST_Z:
994 jtag_add_reset(0, 0);
995 break;
996 case XTRST_ABSENT:
997 break;
998 default:
999 LOG_ERROR( "XTRST mode argument (0x%02X) out of range", trst_mode );
1000 do_abort = 1;
1001 }
1002 }
1003 break;
1004
1005 default:
1006 LOG_ERROR("unknown xsvf command (0x%02X)\n", uc);
1007 unsupported = 1;
1008 }
1009
1010 if (do_abort || unsupported || tdo_mismatch)
1011 {
1012 LOG_DEBUG("xsvf failed, setting taps to reasonable state");
1013
1014 /* upon error, return the TAPs to a reasonable state */
1015 xsvf_add_statemove( TAP_IDLE );
1016 jtag_execute_queue();
1017 break;
1018 }
1019 }
1020
1021 if (tdo_mismatch)
1022 {
1023 command_print(cmd_ctx, "TDO mismatch, somewhere near offset %lu in xsvf file, aborting",
1024 file_offset );
1025
1026
1027 return ERROR_FAIL;
1028 }
1029
1030 if (unsupported)
1031 {
1032 command_print(cmd_ctx,
1033 "unsupported xsvf command: 0x%02X in xsvf file at offset %ld, aborting",
1034 uc, lseek(xsvf_fd, 0, SEEK_CUR)-1 );
1035 return ERROR_FAIL;
1036 }
1037
1038 if (do_abort)
1039 {
1040 command_print(cmd_ctx, "premature end of xsvf file detected, aborting");
1041 return ERROR_FAIL;
1042 }
1043
1044 if (dr_out_buf)
1045 free(dr_out_buf);
1046
1047 if (dr_in_buf)
1048 free(dr_in_buf);
1049
1050 if (dr_in_mask)
1051 free(dr_in_mask);
1052
1053 close(xsvf_fd);
1054
1055 command_print(cmd_ctx, "XSVF file programmed successfully");
1056
1057 return ERROR_OK;
1058 }
1059
1060
1061 #if 0 /* this comment style used to try and keep uncrustify from adding * at begin of line */
1062
1063 PSUEDO-Code from Xilinx Appnote XAPP067.pdf:
1064
1065 the following pseudo code clarifies the intent of the xrepeat support. The
1066 flow given is for the entire processing of an SVF file, not an XSVF file.
1067 No idea if this is just for the XC9500/XL/XV devices or all Xilinx parts.
1068
1069 "Pseudo-Code Algorithm for SVF-Based ISP"
1070
1071 1. Go to Test-Logic-Reset state
1072 2. Go to Run-Test Idle state
1073 3. Read SVF record
1074
1075 4. if SIR record then
1076 go to Shift-IR state
1077 Scan in <TDI value>
1078
1079 5. else if SDR record then
1080 set <repeat count> to 0
1081 store <TDI value> as <current TDI value>
1082 store <TDO value> as <current TDO value>
1083 6. go to Shift-DR state
1084 scan in <current TDI value>
1085 if <current TDO value> is specified then
1086 if <current TDO value> does not equal <actual TDO value> then
1087 if <repeat count> > 32 then
1088 LOG ERROR
1089 go to Run-Test Idle state
1090 go to Step 3
1091 end if
1092 go to Pause-DR
1093 go to Exit2-DR
1094 go to Shift-DR
1095 go to Exit1-DR
1096 go to Update-DR
1097 go to Run-Test/Idle
1098 increment <repeat count> by 1
1099 pause <current pause time> microseconds
1100 go to Step 6)
1101 end if
1102 else
1103 go to Run-Test Idle state
1104 go to Step 3
1105 endif
1106 else if RUNTEST record then
1107 pause tester for <TCK value> microseconds
1108 store <TCK value> as <current pause time>
1109 end if
1110
1111 #endif
Open On-Chip Debugger

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)