jtag: do not use jtag_get_error()
[openocd/dnglaze.git] / src / xsvf / xsvf.c
blobf4d09ff9296ec01fadcf7ff6d7bb64bccbbd6632
1 /*
2 * Copyright (C) 2005 by Dominic Rath
3 * Dominic.Rath@gmx.de
5 * Copyright (C) 2007,2008 Øyvind Harboe
6 * oyvind.harboe@zylin.com
8 * Copyright (C) 2008 Peter Hettkamp
9 * peter.hettkamp@htp-tel.de
11 * Copyright (C) 2009 SoftPLC Corporation. http://softplc.com
12 * Dick Hollenbeck <dick@softplc.com>
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, write to the Free Software
26 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
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".
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".
39 #ifdef HAVE_CONFIG_H
40 #include "config.h"
41 #endif
43 #include "xsvf.h"
44 #include <jtag/jtag.h>
45 #include <svf/svf.h>
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
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.
77 #define XWAITSTATE 0x18
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:
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.
90 LSDR 1 TDI (0)
91 TDO (1);
94 #define LCOUNT 0x19
95 #define LDELAY 0x1A
96 #define LSDR 0x1B
97 #define XTRST 0x1C
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
118 /* arguments to XTRST */
119 #define XTRST_ON 0
120 #define XTRST_OFF 1
121 #define XTRST_Z 2
122 #define XTRST_ABSENT 3
124 #define XSTATE_MAX_PATH 12
127 static int xsvf_fd = 0;
130 /* map xsvf tap state to an openocd "tap_state_t" */
131 static tap_state_t xsvf_to_tap(int xsvf_state)
133 tap_state_t ret;
135 switch (xsvf_state)
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);
158 return ret;
163 static int xsvf_read_buffer(int num_bits, int fd, uint8_t* buf)
165 int num_bytes;
167 for (num_bytes = (num_bits + 7) / 8; num_bytes > 0; num_bytes--)
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;
174 return ERROR_OK;
178 COMMAND_HANDLER(handle_xsvf_command)
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;
184 int xsdrsize = 0;
185 int xruntest = 0; /* number of TCK cycles OR microseconds */
186 int xrepeat = 0; /* number of retries */
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;
191 uint8_t opcode;
192 uint8_t uc;
193 long file_offset = 0;
195 int loop_count = 0;
196 tap_state_t loop_state = TAP_IDLE;
197 int loop_clocks = 0;
198 int loop_usecs = 0;
200 int do_abort = 0;
201 int unsupported = 0;
202 int tdo_mismatch = 0;
203 int result;
204 int verbose = 1;
206 bool collecting_path = false;
207 tap_state_t path[XSTATE_MAX_PATH];
208 unsigned pathlen = 0;
210 /* a flag telling whether to clock TCK during waits,
211 * or simply sleep, controled by virt2
213 int runtest_requires_tck = 0;
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
220 struct jtag_tap *tap = NULL;
222 if (CMD_ARGC < 2)
224 command_print(CMD_CTX, "usage: xsvf <device#|plain> <file> [<variant>] [quiet]");
225 return ERROR_FAIL;
228 /* we mess with CMD_ARGV starting point below, snapshot filename here */
229 const char *filename = CMD_ARGV[1];
231 if (strcmp(CMD_ARGV[0], "plain") != 0)
233 tap = jtag_tap_by_string(CMD_ARGV[0]);
234 if (!tap)
236 command_print(CMD_CTX, "Tap: %s unknown", CMD_ARGV[0]);
237 return ERROR_FAIL;
241 if ((xsvf_fd = open(filename, O_RDONLY)) < 0)
243 command_print(CMD_CTX, "file \"%s\" not found", filename);
244 return ERROR_FAIL;
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))
250 runtest_requires_tck = 1;
251 --CMD_ARGC;
252 ++CMD_ARGV;
255 if ((CMD_ARGC > 2) && (strcmp(CMD_ARGV[2], "quiet") == 0))
257 verbose = 0;
260 LOG_USER("xsvf processing file: \"%s\"", filename);
262 while (read(xsvf_fd, &opcode, 1) > 0)
264 /* record the position of this opcode within the file */
265 file_offset = lseek(xsvf_fd, 0, SEEK_CUR) - 1;
267 /* maybe collect another state for a pathmove();
268 * or terminate a path.
270 if (collecting_path) {
271 tap_state_t mystate;
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;
285 if (read(xsvf_fd, &uc, 1) < 0)
287 do_abort = 1;
288 break;
291 mystate = xsvf_to_tap(uc);
292 path[pathlen++] = mystate;
294 LOG_DEBUG("XSTATE 0x%02X %s", uc,
295 tap_state_name(mystate));
297 /* If path is incomplete, collect more */
298 if (!svf_tap_state_is_stable(mystate))
299 continue;
301 /* Else execute the path transitions we've
302 * collected so far.
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.
313 if (mystate == TAP_RESET) {
314 LOG_WARNING("XSVF: dodgey RESET");
315 path[0] = mystate;
318 /* FALL THROUGH */
319 default:
320 /* Execute the path we collected
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.
327 collecting_path = false;
329 if (path[0] == TAP_RESET)
330 jtag_add_tlr();
331 else
332 jtag_add_pathmove(pathlen, path);
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;
341 continue;
345 switch (opcode)
347 case XCOMPLETE:
348 LOG_DEBUG("XCOMPLETE");
350 result = jtag_execute_queue();
351 if (result != ERROR_OK)
353 tdo_mismatch = 1;
354 break;
356 break;
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;
364 case XRUNTEST:
366 uint8_t xruntest_buf[4];
368 if (read(xsvf_fd, xruntest_buf, 4) < 0)
370 do_abort = 1;
371 break;
374 xruntest = be_to_h_u32(xruntest_buf);
375 LOG_DEBUG("XRUNTEST %d 0x%08X", xruntest, xruntest);
377 break;
379 case XREPEAT:
381 uint8_t myrepeat;
383 if (read(xsvf_fd, &myrepeat, 1) < 0)
384 do_abort = 1;
385 else
387 xrepeat = myrepeat;
388 LOG_DEBUG("XREPEAT %d", xrepeat);
391 break;
393 case XSDRSIZE:
395 uint8_t xsdrsize_buf[4];
397 if (read(xsvf_fd, xsdrsize_buf, 4) < 0)
399 do_abort = 1;
400 break;
403 xsdrsize = be_to_h_u32(xsdrsize_buf);
404 LOG_DEBUG("XSDRSIZE %d", xsdrsize);
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);
410 dr_out_buf = malloc((xsdrsize + 7) / 8);
411 dr_in_buf = malloc((xsdrsize + 7) / 8);
412 dr_in_mask = malloc((xsdrsize + 7) / 8);
414 break;
416 case XSDR: /* these two are identical except for the dr_in_buf */
417 case XSDRTDO:
419 int limit = xrepeat;
420 int matched = 0;
421 int attempt;
423 const char* op_name = (opcode == XSDR ? "XSDR" : "XSDRTDO");
425 if (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK)
427 do_abort = 1;
428 break;
431 if (opcode == XSDRTDO)
433 if (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf) != ERROR_OK)
435 do_abort = 1;
436 break;
440 if (limit < 1)
441 limit = 1;
443 LOG_DEBUG("%s %d", op_name, xsdrsize);
445 for (attempt = 0; attempt < limit; ++attempt)
447 struct scan_field field;
449 if (attempt > 0)
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
460 This sequence should be harmless for other devices, and it
461 will be skipped entirely if xrepeat is set to zero.
464 static tap_state_t exception_path[] = {
465 TAP_DREXIT2,
466 TAP_DRSHIFT,
467 TAP_DREXIT1,
468 TAP_DRUPDATE,
469 TAP_IDLE,
472 jtag_add_pathmove(ARRAY_SIZE(exception_path), exception_path);
474 if (verbose)
475 LOG_USER("%s mismatch, xsdrsize=%d retry=%d", op_name, xsdrsize, attempt);
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);
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);
488 jtag_check_value_mask(&field, dr_in_buf, dr_in_mask);
490 free(field.in_value);
493 /* LOG_DEBUG("FLUSHING QUEUE"); */
494 result = jtag_execute_queue();
495 if (result == ERROR_OK)
497 matched = 1;
498 break;
502 if (!matched)
504 LOG_USER("%s mismatch", op_name);
505 tdo_mismatch = 1;
506 break;
509 /* See page 19 of XSVF spec regarding opcode "XSDR" */
510 if (xruntest)
512 result = svf_add_statemove(TAP_IDLE);
514 if (runtest_requires_tck)
515 jtag_add_clocks(xruntest);
516 else
517 jtag_add_sleep(xruntest);
519 else if (xendir != TAP_DRPAUSE) /* we are already in TAP_DRPAUSE */
520 result = svf_add_statemove(xenddr);
522 break;
524 case XSETSDRMASKS:
525 LOG_ERROR("unsupported XSETSDRMASKS\n");
526 unsupported = 1;
527 break;
529 case XSDRINC:
530 LOG_ERROR("unsupported XSDRINC\n");
531 unsupported = 1;
532 break;
534 case XSDRB:
535 LOG_ERROR("unsupported XSDRB\n");
536 unsupported = 1;
537 break;
539 case XSDRC:
540 LOG_ERROR("unsupported XSDRC\n");
541 unsupported = 1;
542 break;
544 case XSDRE:
545 LOG_ERROR("unsupported XSDRE\n");
546 unsupported = 1;
547 break;
549 case XSDRTDOB:
550 LOG_ERROR("unsupported XSDRTDOB\n");
551 unsupported = 1;
552 break;
554 case XSDRTDOC:
555 LOG_ERROR("unsupported XSDRTDOC\n");
556 unsupported = 1;
557 break;
559 case XSDRTDOE:
560 LOG_ERROR("unsupported XSDRTDOE\n");
561 unsupported = 1;
562 break;
564 case XSTATE:
566 tap_state_t mystate;
568 if (read(xsvf_fd, &uc, 1) < 0)
570 do_abort = 1;
571 break;
574 mystate = xsvf_to_tap(uc);
576 LOG_DEBUG("XSTATE 0x%02X %s", uc, tap_state_name(mystate));
578 if (mystate == TAP_INVALID) {
579 LOG_ERROR("XSVF: bad XSTATE %02x", uc);
580 do_abort = 1;
581 break;
584 /* NOTE: the current state is SVF-stable! */
586 /* no change == NOP */
587 if (mystate == cmd_queue_cur_state
588 && mystate != TAP_RESET)
589 break;
591 /* Hand off to SVF? */
592 if (svf_tap_state_is_stable(mystate))
594 result = svf_add_statemove(mystate);
595 if (result != ERROR_OK)
596 unsupported = 1;
597 break;
601 * A sequence of XSTATE transitions, each TAP
602 * state adjacent to the previous one. Start
603 * collecting them.
605 collecting_path = true;
606 pathlen = 1;
607 path[0] = mystate;
609 break;
611 case XENDIR:
613 if (read(xsvf_fd, &uc, 1) < 0)
615 do_abort = 1;
616 break;
619 /* see page 22 of XSVF spec */
620 if (uc == 0)
621 xendir = TAP_IDLE;
622 else if (uc == 1)
623 xendir = TAP_IRPAUSE;
624 else
626 LOG_ERROR("illegial XENDIR argument: 0x%02X", uc);
627 unsupported = 1;
628 break;
631 LOG_DEBUG("XENDIR 0x%02X %s", uc, tap_state_name(xendir));
632 break;
634 case XENDDR:
636 if (read(xsvf_fd, &uc, 1) < 0)
638 do_abort = 1;
639 break;
642 /* see page 22 of XSVF spec */
643 if (uc == 0)
644 xenddr = TAP_IDLE;
645 else if (uc == 1)
646 xenddr = TAP_DRPAUSE;
647 else
649 LOG_ERROR("illegial XENDDR argument: 0x%02X", uc);
650 unsupported = 1;
651 break;
654 LOG_DEBUG("XENDDR %02X %s", uc, tap_state_name(xenddr));
655 break;
657 case XSIR:
658 case XSIR2:
660 uint8_t short_buf[2];
661 uint8_t* ir_buf;
662 int bitcount;
663 tap_state_t my_end_state = xruntest ? TAP_IDLE : xendir;
665 if (opcode == XSIR)
667 /* one byte bitcount */
668 if (read(xsvf_fd, short_buf, 1) < 0)
670 do_abort = 1;
671 break;
673 bitcount = short_buf[0];
674 LOG_DEBUG("XSIR %d", bitcount);
676 else
678 if (read(xsvf_fd, short_buf, 2) < 0)
680 do_abort = 1;
681 break;
683 bitcount = be_to_h_u16(short_buf);
684 LOG_DEBUG("XSIR2 %d", bitcount);
687 ir_buf = malloc((bitcount + 7) / 8);
689 if (xsvf_read_buffer(bitcount, xsvf_fd, ir_buf) != ERROR_OK)
690 do_abort = 1;
691 else
693 struct scan_field field;
695 field.num_bits = bitcount;
696 field.out_value = ir_buf;
698 field.in_value = NULL;
703 if (tap == NULL)
704 jtag_add_plain_ir_scan(field.num_bits,
705 field.out_value, field.in_value, my_end_state);
706 else
707 jtag_add_ir_scan(tap, &field, my_end_state);
709 if (xruntest)
711 if (runtest_requires_tck)
712 jtag_add_clocks(xruntest);
713 else
714 jtag_add_sleep(xruntest);
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.
722 /* LOG_DEBUG("FLUSHING QUEUE"); */
723 result = jtag_execute_queue();
724 if (result != ERROR_OK)
726 tdo_mismatch = 1;
729 free(ir_buf);
731 break;
733 case XCOMMENT:
735 unsigned int ndx = 0;
736 char comment[128];
740 if (read(xsvf_fd, &uc, 1) < 0)
742 do_abort = 1;
743 break;
746 if (ndx < sizeof(comment)-1)
747 comment[ndx++] = uc;
749 } while (uc != 0);
751 comment[sizeof(comment)-1] = 0; /* regardless, terminate */
752 if (verbose)
753 LOG_USER("# %s", comment);
755 break;
757 case XWAIT:
759 /* expected in stream:
760 XWAIT <uint8_t wait_state> <uint8_t end_state> <uint32_t usecs>
763 uint8_t wait;
764 uint8_t end;
765 uint8_t delay_buf[4];
767 tap_state_t wait_state;
768 tap_state_t end_state;
769 int delay;
771 if (read(xsvf_fd, &wait, 1) < 0
772 || read(xsvf_fd, &end, 1) < 0
773 || read(xsvf_fd, delay_buf, 4) < 0)
775 do_abort = 1;
776 break;
779 wait_state = xsvf_to_tap(wait);
780 end_state = xsvf_to_tap(end);
781 delay = be_to_h_u32(delay_buf);
783 LOG_DEBUG("XWAIT %s %s usecs:%d", tap_state_name(wait_state), tap_state_name(end_state), delay);
785 if (runtest_requires_tck && wait_state == TAP_IDLE)
787 jtag_add_runtest(delay, end_state);
789 else
791 /* FIXME handle statemove errors ... */
792 result = svf_add_statemove(wait_state);
793 jtag_add_sleep(delay);
794 result = svf_add_statemove(end_state);
797 break;
799 case XWAITSTATE:
801 /* expected in stream:
802 XWAITSTATE <uint8_t wait_state> <uint8_t end_state> <uint32_t clock_count> <uint32_t usecs>
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;
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)
819 do_abort = 1;
820 break;
823 wait_state = xsvf_to_tap(wait);
824 end_state = xsvf_to_tap(end);
826 clock_count = be_to_h_u32(clock_buf);
827 usecs = be_to_h_u32(usecs_buf);
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);
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.
839 if (!svf_tap_state_is_stable(wait_state))
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? */
847 /* FIXME handle statemove errors ... */
848 result = svf_add_statemove(wait_state);
850 jtag_add_clocks(clock_count);
852 jtag_add_sleep(usecs);
854 result = svf_add_statemove(end_state);
856 break;
858 case LCOUNT:
860 /* expected in stream:
861 LCOUNT <uint32_t loop_count>
863 uint8_t count_buf[4];
865 if (read(xsvf_fd, count_buf, 4) < 0)
867 do_abort = 1;
868 break;
871 loop_count = be_to_h_u32(count_buf);
872 LOG_DEBUG("LCOUNT %d", loop_count);
874 break;
876 case LDELAY:
878 /* expected in stream:
879 LDELAY <uint8_t wait_state> <uint32_t clock_count> <uint32_t usecs_to_sleep>
881 uint8_t state;
882 uint8_t clock_buf[4];
883 uint8_t usecs_buf[4];
885 if (read(xsvf_fd, &state, 1) < 0
886 || read(xsvf_fd, clock_buf, 4) < 0
887 || read(xsvf_fd, usecs_buf, 4) < 0)
889 do_abort = 1;
890 break;
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);
898 LOG_DEBUG("LDELAY %s clocks:%d usecs:%d", tap_state_name(loop_state), loop_clocks, loop_usecs);
900 break;
902 /* LSDR is more like XSDRTDO than it is like XSDR. It uses LDELAY which
903 * comes with clocks !AND! sleep requirements.
905 case LSDR:
907 int limit = loop_count;
908 int matched = 0;
909 int attempt;
911 LOG_DEBUG("LSDR");
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)
916 do_abort = 1;
917 break;
920 if (limit < 1)
921 limit = 1;
923 for (attempt = 0; attempt < limit; ++attempt)
925 struct scan_field field;
927 result = svf_add_statemove(loop_state);
928 jtag_add_clocks(loop_clocks);
929 jtag_add_sleep(loop_usecs);
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);
935 if (attempt > 0 && verbose)
936 LOG_USER("LSDR retry %d", attempt);
938 if (tap == NULL)
939 jtag_add_plain_dr_scan(field.num_bits, field.out_value, field.in_value,
940 TAP_DRPAUSE);
941 else
942 jtag_add_dr_scan(tap, 1, &field, TAP_DRPAUSE);
944 jtag_check_value_mask(&field, dr_in_buf, dr_in_mask);
946 free(field.in_value);
949 /* LOG_DEBUG("FLUSHING QUEUE"); */
950 result = jtag_execute_queue();
951 if (result == ERROR_OK)
953 matched = 1;
954 break;
958 if (!matched)
960 LOG_USER("LSDR mismatch");
961 tdo_mismatch = 1;
962 break;
965 break;
967 case XTRST:
969 uint8_t trst_mode;
971 if (read(xsvf_fd, &trst_mode, 1) < 0)
973 do_abort = 1;
974 break;
977 switch (trst_mode)
979 case XTRST_ON:
980 jtag_add_reset(1, 0);
981 break;
982 case XTRST_OFF:
983 case XTRST_Z:
984 jtag_add_reset(0, 0);
985 break;
986 case XTRST_ABSENT:
987 break;
988 default:
989 LOG_ERROR("XTRST mode argument (0x%02X) out of range", trst_mode);
990 do_abort = 1;
993 break;
995 default:
996 LOG_ERROR("unknown xsvf command (0x%02X)\n", uc);
997 unsupported = 1;
1000 if (do_abort || unsupported || tdo_mismatch)
1002 LOG_DEBUG("xsvf failed, setting taps to reasonable state");
1004 /* upon error, return the TAPs to a reasonable state */
1005 result = svf_add_statemove(TAP_IDLE);
1006 result = jtag_execute_queue();
1007 break;
1011 if (tdo_mismatch)
1013 command_print(CMD_CTX, "TDO mismatch, somewhere near offset %lu in xsvf file, aborting",
1014 file_offset);
1017 return ERROR_FAIL;
1020 if (unsupported)
1022 off_t offset = lseek(xsvf_fd, 0, SEEK_CUR) - 1;
1023 command_print(CMD_CTX,
1024 "unsupported xsvf command (0x%02X) at offset %jd, aborting",
1025 uc, (intmax_t)offset);
1026 return ERROR_FAIL;
1029 if (do_abort)
1031 command_print(CMD_CTX, "premature end of xsvf file detected, aborting");
1032 return ERROR_FAIL;
1035 if (dr_out_buf)
1036 free(dr_out_buf);
1038 if (dr_in_buf)
1039 free(dr_in_buf);
1041 if (dr_in_mask)
1042 free(dr_in_mask);
1044 close(xsvf_fd);
1046 command_print(CMD_CTX, "XSVF file programmed successfully");
1048 return ERROR_OK;
1051 static const struct command_registration xsvf_command_handlers[] = {
1053 .name = "xsvf",
1054 .handler = handle_xsvf_command,
1055 .mode = COMMAND_EXEC,
1056 .help = "Runs a XSVF file. If 'virt2' is given, xruntest "
1057 "counts are interpreted as TCK cycles rather than "
1058 "as microseconds. Without the 'quiet' option, all "
1059 "comments, retries, and mismatches will be reported.",
1060 .usage = "(tapname|'plain') filename ['virt2'] ['quiet']",
1062 COMMAND_REGISTRATION_DONE
1065 int xsvf_register_commands(struct command_context *cmd_ctx)
1067 return register_commands(cmd_ctx, NULL, xsvf_command_handlers);
1070 #if 0 /* this comment style used to try and keep uncrustify from adding * at begin of line */
1072 PSUEDO-Code from Xilinx Appnote XAPP067.pdf:
1074 the following pseudo code clarifies the intent of the xrepeat support. The
1075 flow given is for the entire processing of an SVF file, not an XSVF file.
1076 No idea if this is just for the XC9500/XL/XV devices or all Xilinx parts.
1078 "Pseudo-Code Algorithm for SVF-Based ISP"
1080 1. Go to Test-Logic-Reset state
1081 2. Go to Run-Test Idle state
1082 3. Read SVF record
1084 4. if SIR record then
1085 go to Shift-IR state
1086 Scan in <TDI value>
1088 5. else if SDR record then
1089 set <repeat count> to 0
1090 store <TDI value> as <current TDI value>
1091 store <TDO value> as <current TDO value>
1092 6. go to Shift-DR state
1093 scan in <current TDI value>
1094 if <current TDO value> is specified then
1095 if <current TDO value> does not equal <actual TDO value> then
1096 if <repeat count> > 32 then
1097 LOG ERROR
1098 go to Run-Test Idle state
1099 go to Step 3
1100 end if
1101 go to Pause-DR
1102 go to Exit2-DR
1103 go to Shift-DR
1104 go to Exit1-DR
1105 go to Update-DR
1106 go to Run-Test/Idle
1107 increment <repeat count> by 1
1108 pause <current pause time> microseconds
1109 go to Step 6)
1110 end if
1111 else
1112 go to Run-Test Idle state
1113 go to Step 3
1114 endif
1115 else if RUNTEST record then
1116 pause tester for <TCK value> microseconds
1117 store <TCK value> as <current pause time>
1118 end if
1120 #endif