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