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