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