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