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