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