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