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