Code Review / openocd.git / blob
? search:


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