Code Review / openocd.git / blob
? search:


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