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