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