Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Remove redundant sys/types.h #include directives (now in types.h).
[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/stat.h>
53 #include <fcntl.h>
54 #include <string.h>
55 #include <assert.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 /**
177 * Function xsvf_add_statemove
178 * moves from the current state to the goal \a state. This needs
179 * to be handled according to the xsvf spec, see the XSTATE command
180 * description.
181 */
182 static int xsvf_add_statemove(tap_state_t goal_state)
183 {
184 int retval = ERROR_OK;
185
186 tap_state_t moves[8];
187 tap_state_t cur_state = cmd_queue_cur_state;
188 int i;
189 int tms_bits;
190 int tms_count;
191
192 LOG_DEBUG( "cur_state=%s goal_state=%s",
193 tap_state_name(cur_state),
194 tap_state_name(goal_state) );
195
196
197 /* From the XSVF spec, pertaining to XSTATE:
198
199 For special states known as stable states (Test-Logic-Reset,
200 Run-Test/Idle, Pause-DR, Pause- IR), an XSVF interpreter follows
201 predefined TAP state paths when the starting state is a stable state and
202 when the XSTATE specifies a new stable state (see the STATE command in
203 the [Ref 5] for the TAP state paths between stable states). For
204 non-stable states, XSTATE should specify a state that is only one TAP
205 state transition distance from the current TAP state to avoid undefined
206 TAP state paths. A sequence of multiple XSTATE commands can be issued to
207 transition the TAP through a specific state path.
208 */
209
210 if (goal_state==cur_state )
211 ; /* nothing to do */
212
213 else if( goal_state==TAP_RESET )
214 {
215 jtag_add_tlr();
216 }
217
218 else if( tap_is_state_stable(cur_state) && tap_is_state_stable(goal_state) )
219 {
220 /* note: unless tms_bits holds a path that agrees with [Ref 5] in above
221 spec, then this code is not fully conformant to the xsvf spec. This
222 puts a burden on tap_get_tms_path() function from the xsvf spec.
223 If in doubt, you should confirm that that burden is being met.
224 */
225
226 tms_bits = tap_get_tms_path(cur_state, goal_state);
227 tms_count = tap_get_tms_path_len(cur_state, goal_state);
228
229 assert( (unsigned) tms_count < DIM(moves) );
230
231 for (i=0; i<tms_count; i++, tms_bits>>=1)
232 {
233 bool bit = tms_bits & 1;
234
235 cur_state = tap_state_transition(cur_state, bit);
236 moves[i] = cur_state;
237 }
238
239 jtag_add_pathmove(tms_count, moves);
240 }
241
242 /* else state must be immediately reachable in one clock cycle, and does not
243 need to be a stable state.
244 */
245 else if( tap_state_transition(cur_state, true) == goal_state
246 || tap_state_transition(cur_state, false) == goal_state )
247 {
248 /* move a single state */
249 moves[0] = goal_state;
250 jtag_add_pathmove( 1, moves );
251 }
252
253 else
254 {
255 retval = ERROR_FAIL;
256 }
257
258 return retval;
259 }
260
261
262 int xsvf_register_commands(struct command_context_s *cmd_ctx)
263 {
264 register_command(cmd_ctx, NULL, "xsvf", handle_xsvf_command,
265 COMMAND_EXEC, "run xsvf <file> [virt2] [quiet]");
266
267 return ERROR_OK;
268 }
269
270 static int xsvf_read_buffer(int num_bits, int fd, u8* buf)
271 {
272 int num_bytes;
273
274 for (num_bytes = (num_bits + 7) / 8; num_bytes > 0; num_bytes--)
275 {
276 /* reverse the order of bytes as they are read sequentially from file */
277 if (read(fd, buf + num_bytes - 1, 1) < 0)
278 return ERROR_XSVF_EOF;
279 }
280
281 return ERROR_OK;
282 }
283
284
285 static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
286 {
287 u8 *dr_out_buf = NULL; /* from host to device (TDI) */
288 u8 *dr_in_buf = NULL; /* from device to host (TDO) */
289 u8 *dr_in_mask = NULL;
290
291 int xsdrsize = 0;
292 int xruntest = 0; /* number of TCK cycles OR microseconds */
293 int xrepeat = 0; /* number of retries */
294
295 tap_state_t xendir = TAP_IDLE; /* see page 8 of the SVF spec, initial xendir to be TAP_IDLE */
296 tap_state_t xenddr = TAP_IDLE;
297
298 u8 opcode;
299 u8 uc;
300 long file_offset = 0;
301
302 int loop_count = 0;
303 tap_state_t loop_state = TAP_IDLE;
304 int loop_clocks = 0;
305 int loop_usecs = 0;
306
307 int do_abort = 0;
308 int unsupported = 0;
309 int tdo_mismatch = 0;
310 int result;
311 int verbose = 1;
312 char* filename;
313
314 int runtest_requires_tck = 0; /* a flag telling whether to clock TCK during waits, or simply sleep, controled by virt2 */
315
316
317 /* use NULL to indicate a "plain" xsvf file which accounts for
318 additional devices in the scan chain, otherwise the device
319 that should be affected
320 */
321 jtag_tap_t *tap = NULL;
322
323 if (argc < 2)
324 {
325 command_print(cmd_ctx, "usage: xsvf <device#|plain> <file> [<variant>] [quiet]");
326 return ERROR_FAIL;
327 }
328
329 filename = args[1]; /* we mess with args starting point below, snapshot filename here */
330
331 if (strcmp(args[0], "plain") != 0)
332 {
333 tap = jtag_TapByString( args[0] );
334 if (!tap )
335 {
336 command_print( cmd_ctx, "Tap: %s unknown", args[0] );
337 return ERROR_FAIL;
338 }
339 }
340
341 if ((xsvf_fd = open(filename, O_RDONLY)) < 0)
342 {
343 command_print(cmd_ctx, "file \"%s\" not found", filename);
344 return ERROR_FAIL;
345 }
346
347 /* if this argument is present, then interpret xruntest counts as TCK cycles rather than as usecs */
348 if ((argc > 2) && (strcmp(args[2], "virt2") == 0))
349 {
350 runtest_requires_tck = 1;
351 --argc;
352 ++args;
353 }
354
355 if ((argc > 2) && (strcmp(args[2], "quiet") == 0))
356 {
357 verbose = 0;
358 }
359
360 LOG_USER("xsvf processing file: \"%s\"", filename);
361
362 while( read(xsvf_fd, &opcode, 1) > 0 )
363 {
364 /* record the position of the just read opcode within the file */
365 file_offset = lseek(xsvf_fd, 0, SEEK_CUR) - 1;
366
367 switch (opcode)
368 {
369 case XCOMPLETE:
370 LOG_DEBUG("XCOMPLETE");
371
372 result = jtag_execute_queue();
373 if (result != ERROR_OK)
374 {
375 tdo_mismatch = 1;
376 break;
377 }
378 break;
379
380 case XTDOMASK:
381 LOG_DEBUG("XTDOMASK");
382 if (dr_in_mask && (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_mask) != ERROR_OK))
383 do_abort = 1;
384 break;
385
386 case XRUNTEST:
387 {
388 u8 xruntest_buf[4];
389
390 if (read(xsvf_fd, xruntest_buf, 4) < 0)
391 {
392 do_abort = 1;
393 break;
394 }
395
396 xruntest = be_to_h_u32(xruntest_buf);
397 LOG_DEBUG("XRUNTEST %d 0x%08X", xruntest, xruntest);
398 }
399 break;
400
401 case XREPEAT:
402 {
403 u8 myrepeat;
404
405 if (read(xsvf_fd, &myrepeat, 1) < 0)
406 do_abort = 1;
407 else
408 {
409 xrepeat = myrepeat;
410 LOG_DEBUG("XREPEAT %d", xrepeat );
411 }
412 }
413 break;
414
415 case XSDRSIZE:
416 {
417 u8 xsdrsize_buf[4];
418
419 if (read(xsvf_fd, xsdrsize_buf, 4) < 0)
420 {
421 do_abort = 1;
422 break;
423 }
424
425 xsdrsize = be_to_h_u32(xsdrsize_buf);
426 LOG_DEBUG("XSDRSIZE %d", xsdrsize);
427
428 if( dr_out_buf ) free(dr_out_buf);
429 if( dr_in_buf) free(dr_in_buf);
430 if( dr_in_mask) free(dr_in_mask);
431
432 dr_out_buf = malloc((xsdrsize + 7) / 8);
433 dr_in_buf = malloc((xsdrsize + 7) / 8);
434 dr_in_mask = malloc((xsdrsize + 7) / 8);
435 }
436 break;
437
438 case XSDR: /* these two are identical except for the dr_in_buf */
439 case XSDRTDO:
440 {
441 int limit = xrepeat;
442 int matched = 0;
443 int attempt;
444
445 const char* op_name = (opcode == XSDR ? "XSDR" : "XSDRTDO");
446
447 if (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK)
448 {
449 do_abort = 1;
450 break;
451 }
452
453 if (opcode == XSDRTDO)
454 {
455 if(xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf) != ERROR_OK )
456 {
457 do_abort = 1;
458 break;
459 }
460 }
461
462 if (limit < 1)
463 limit = 1;
464
465 LOG_DEBUG("%s %d", op_name, xsdrsize);
466
467 for( attempt=0; attempt<limit; ++attempt )
468 {
469 scan_field_t field;
470
471 if( attempt>0 )
472 {
473 /* perform the XC9500 exception handling sequence shown in xapp067.pdf and
474 illustrated in psuedo code at end of this file. We start from state
475 DRPAUSE:
476 go to Exit2-DR
477 go to Shift-DR
478 go to Exit1-DR
479 go to Update-DR
480 go to Run-Test/Idle
481
482 This sequence should be harmless for other devices, and it
483 will be skipped entirely if xrepeat is set to zero.
484 */
485
486 static tap_state_t exception_path[] = {
487 TAP_DREXIT2,
488 TAP_DRSHIFT,
489 TAP_DREXIT1,
490 TAP_DRUPDATE,
491 TAP_IDLE,
492 };
493
494 jtag_add_pathmove( DIM(exception_path), exception_path );
495
496 if (verbose)
497 LOG_USER("%s mismatch, xsdrsize=%d retry=%d", op_name, xsdrsize, attempt);
498 }
499
500 field.tap = tap;
501 field.num_bits = xsdrsize;
502 field.out_value = dr_out_buf;
503 field.in_value = calloc(CEIL(field.num_bits, 8), 1);
504
505 if (tap == NULL)
506 jtag_add_plain_dr_scan(1, &field, TAP_DRPAUSE);
507 else
508 jtag_add_dr_scan(1, &field, TAP_DRPAUSE);
509
510 jtag_check_value_mask(&field, dr_in_buf, dr_in_mask);
511
512 free(field.in_value);
513
514
515 /* LOG_DEBUG("FLUSHING QUEUE"); */
516 result = jtag_execute_queue();
517 if (result == ERROR_OK)
518 {
519 matched = 1;
520 break;
521 }
522 }
523
524 if (!matched)
525 {
526 LOG_USER( "%s mismatch", op_name);
527 tdo_mismatch = 1;
528 break;
529 }
530
531 /* See page 19 of XSVF spec regarding opcode "XSDR" */
532 if (xruntest)
533 {
534 xsvf_add_statemove(TAP_IDLE);
535
536 if (runtest_requires_tck)
537 jtag_add_clocks(xruntest);
538 else
539 jtag_add_sleep(xruntest);
540 }
541 else if (xendir != TAP_DRPAUSE) /* we are already in TAP_DRPAUSE */
542 xsvf_add_statemove(xenddr);
543 }
544 break;
545
546 case XSETSDRMASKS:
547 LOG_ERROR("unsupported XSETSDRMASKS\n");
548 unsupported = 1;
549 break;
550
551 case XSDRINC:
552 LOG_ERROR("unsupported XSDRINC\n");
553 unsupported = 1;
554 break;
555
556 case XSDRB:
557 LOG_ERROR("unsupported XSDRB\n");
558 unsupported = 1;
559 break;
560
561 case XSDRC:
562 LOG_ERROR("unsupported XSDRC\n");
563 unsupported = 1;
564 break;
565
566 case XSDRE:
567 LOG_ERROR("unsupported XSDRE\n");
568 unsupported = 1;
569 break;
570
571 case XSDRTDOB:
572 LOG_ERROR("unsupported XSDRTDOB\n");
573 unsupported = 1;
574 break;
575
576 case XSDRTDOC:
577 LOG_ERROR("unsupported XSDRTDOC\n");
578 unsupported = 1;
579 break;
580
581 case XSDRTDOE:
582 LOG_ERROR("unsupported XSDRTDOE\n");
583 unsupported = 1;
584 break;
585
586 case XSTATE:
587 {
588 tap_state_t mystate;
589 u8 uc;
590
591 if (read(xsvf_fd, &uc, 1) < 0)
592 {
593 do_abort = 1;
594 break;
595 }
596
597 mystate = xsvf_to_tap(uc);
598
599 LOG_DEBUG("XSTATE 0x%02X %s", uc, tap_state_name(mystate) );
600
601 /* there is no need for the lookahead code that was here since we
602 queue up the jtag commands anyway. This is a simple way to handle
603 the XSTATE.
604 */
605
606 if( xsvf_add_statemove( mystate ) != ERROR_OK )
607 {
608 /* For special states known as stable states
609 (Test-Logic-Reset, Run-Test/Idle, Pause-DR, Pause- IR),
610 an XSVF interpreter follows predefined TAP state paths
611 when the starting state is a stable state and when the
612 XSTATE specifies a new stable state (see the STATE
613 command in the [Ref 5] for the TAP state paths between
614 stable states). For non-stable states, XSTATE should
615 specify a state that is only one TAP state transition
616 distance from the current TAP state to avoid undefined
617 TAP state paths. A sequence of multiple XSTATE commands
618 can be issued to transition the TAP through a specific
619 state path.
620 */
621
622 LOG_ERROR("XSTATE %s is not reachable from current state %s in one clock cycle",
623 tap_state_name(mystate),
624 tap_state_name(cmd_queue_cur_state)
625 );
626 }
627 }
628 break;
629
630 case XENDIR:
631
632 if (read(xsvf_fd, &uc, 1) < 0)
633 {
634 do_abort = 1;
635 break;
636 }
637
638 /* see page 22 of XSVF spec */
639 if( uc == 0 )
640 xendir = TAP_IDLE;
641 else if( uc == 1 )
642 xendir = TAP_IRPAUSE;
643 else
644 {
645 LOG_ERROR("illegial XENDIR argument: 0x%02X", uc);
646 unsupported = 1;
647 break;
648 }
649
650 LOG_DEBUG("XENDIR 0x%02X %s", uc, tap_state_name(xendir));
651 break;
652
653 case XENDDR:
654
655 if (read(xsvf_fd, &uc, 1) < 0)
656 {
657 do_abort = 1;
658 break;
659 }
660
661 /* see page 22 of XSVF spec */
662 if( uc == 0 )
663 xenddr = TAP_IDLE;
664 else if( uc == 1 )
665 xenddr = TAP_DRPAUSE;
666 else
667 {
668 LOG_ERROR("illegial XENDDR argument: 0x%02X", uc);
669 unsupported = 1;
670 break;
671 }
672
673 LOG_DEBUG("XENDDR %02X %s", uc, tap_state_name(xenddr));
674 break;
675
676 case XSIR:
677 case XSIR2:
678 {
679 u8 short_buf[2];
680 u8* ir_buf;
681 int bitcount;
682 tap_state_t my_end_state = xruntest ? TAP_IDLE : xendir;
683
684 if( opcode == XSIR )
685 {
686 /* one byte bitcount */
687 if (read(xsvf_fd, short_buf, 1) < 0)
688 {
689 do_abort = 1;
690 break;
691 }
692 bitcount = short_buf[0];
693 LOG_DEBUG("XSIR %d", bitcount);
694 }
695 else
696 {
697 if (read(xsvf_fd, short_buf, 2) < 0)
698 {
699 do_abort = 1;
700 break;
701 }
702 bitcount = be_to_h_u16(short_buf);
703 LOG_DEBUG("XSIR2 %d", bitcount);
704 }
705
706 ir_buf = malloc((bitcount+7) / 8);
707
708 if (xsvf_read_buffer(bitcount, xsvf_fd, ir_buf) != ERROR_OK)
709 do_abort = 1;
710 else
711 {
712 scan_field_t field;
713
714 field.tap = tap;
715 field.num_bits = bitcount;
716 field.out_value = ir_buf;
717
718 field.in_value = NULL;
719
720
721
722
723 if (tap == NULL)
724 jtag_add_plain_ir_scan(1, &field, my_end_state);
725 else
726 jtag_add_ir_scan(1, &field, my_end_state);
727
728 if (xruntest)
729 {
730 if (runtest_requires_tck)
731 jtag_add_clocks(xruntest);
732 else
733 jtag_add_sleep(xruntest);
734 }
735
736 /* Note that an -irmask of non-zero in your config file
737 * can cause this to fail. Setting -irmask to zero cand work
738 * around the problem.
739 */
740
741 /* LOG_DEBUG("FLUSHING QUEUE"); */
742 result = jtag_execute_queue();
743 if(result != ERROR_OK)
744 {
745 tdo_mismatch = 1;
746 }
747 }
748 free(ir_buf);
749 }
750 break;
751
752 case XCOMMENT:
753 {
754 unsigned int ndx = 0;
755 char comment[128];
756
757 do
758 {
759 if (read(xsvf_fd, &uc, 1) < 0)
760 {
761 do_abort = 1;
762 break;
763 }
764
765 if ( ndx < sizeof(comment)-1 )
766 comment[ndx++] = uc;
767
768 } while (uc != 0);
769
770 comment[sizeof(comment)-1] = 0; /* regardless, terminate */
771 if (verbose)
772 LOG_USER("# %s", comment);
773 }
774 break;
775
776 case XWAIT:
777 {
778 /* expected in stream:
779 XWAIT <u8 wait_state> <u8 end_state> <u32 usecs>
780 */
781
782 u8 wait;
783 u8 end;
784 u8 delay_buf[4];
785
786 tap_state_t wait_state;
787 tap_state_t end_state;
788 int delay;
789
790 if ( read(xsvf_fd, &wait, 1) < 0
791 || read(xsvf_fd, &end, 1) < 0
792 || read(xsvf_fd, delay_buf, 4) < 0)
793 {
794 do_abort = 1;
795 break;
796 }
797
798 wait_state = xsvf_to_tap(wait);
799 end_state = xsvf_to_tap(end);
800 delay = be_to_h_u32(delay_buf);
801
802 LOG_DEBUG("XWAIT %s %s usecs:%d", tap_state_name(wait_state), tap_state_name(end_state), delay);
803
804 if (runtest_requires_tck && wait_state == TAP_IDLE )
805 {
806 jtag_add_runtest(delay, end_state);
807 }
808 else
809 {
810 xsvf_add_statemove( wait_state );
811 jtag_add_sleep(delay);
812 xsvf_add_statemove( end_state );
813 }
814 }
815 break;
816
817 case XWAITSTATE:
818 {
819 /* expected in stream:
820 XWAITSTATE <u8 wait_state> <u8 end_state> <u32 clock_count> <u32 usecs>
821 */
822
823 u8 clock_buf[4];
824 u8 usecs_buf[4];
825 u8 wait;
826 u8 end;
827 tap_state_t wait_state;
828 tap_state_t end_state;
829 int clock_count;
830 int usecs;
831
832 if ( read(xsvf_fd, &wait, 1) < 0
833 || read(xsvf_fd, &end, 1) < 0
834 || read(xsvf_fd, clock_buf, 4) < 0
835 || read(xsvf_fd, usecs_buf, 4) < 0 )
836 {
837 do_abort = 1;
838 break;
839 }
840
841 wait_state = xsvf_to_tap( wait );
842 end_state = xsvf_to_tap( end );
843
844 clock_count = be_to_h_u32(clock_buf);
845 usecs = be_to_h_u32(usecs_buf);
846
847 LOG_DEBUG("XWAITSTATE %s %s clocks:%i usecs:%i",
848 tap_state_name(wait_state),
849 tap_state_name(end_state),
850 clock_count, usecs);
851
852 /* the following states are 'stable', meaning that they have a transition
853 * in the state diagram back to themselves. This is necessary because we will
854 * be issuing a number of clocks in this state. This set of allowed states is also
855 * determined by the SVF RUNTEST command's allowed states.
856 */
857 if (wait_state != TAP_IRPAUSE && wait_state != TAP_DRPAUSE && wait_state != TAP_RESET && wait_state != TAP_IDLE)
858 {
859 LOG_ERROR("illegal XWAITSTATE wait_state: \"%s\"", tap_state_name( wait_state ));
860 unsupported = 1;
861 }
862
863 xsvf_add_statemove( wait_state );
864
865 jtag_add_clocks( clock_count );
866
867 jtag_add_sleep( usecs );
868
869 xsvf_add_statemove( end_state );
870 }
871 break;
872
873 case LCOUNT:
874 {
875 /* expected in stream:
876 LCOUNT <u32 loop_count>
877 */
878 u8 count_buf[4];
879
880 if ( read(xsvf_fd, count_buf, 4) < 0 )
881 {
882 do_abort = 1;
883 break;
884 }
885
886 loop_count = be_to_h_u32(count_buf);
887 LOG_DEBUG("LCOUNT %d", loop_count);
888 }
889 break;
890
891 case LDELAY:
892 {
893 /* expected in stream:
894 LDELAY <u8 wait_state> <u32 clock_count> <u32 usecs_to_sleep>
895 */
896 u8 state;
897 u8 clock_buf[4];
898 u8 usecs_buf[4];
899
900 if ( read(xsvf_fd, &state, 1) < 0
901 || read(xsvf_fd, clock_buf, 4) < 0
902 || read(xsvf_fd, usecs_buf, 4) < 0 )
903 {
904 do_abort = 1;
905 break;
906 }
907
908 loop_state = xsvf_to_tap(state);
909 loop_clocks = be_to_h_u32(clock_buf);
910 loop_usecs = be_to_h_u32(usecs_buf);
911
912 LOG_DEBUG("LDELAY %s clocks:%d usecs:%d", tap_state_name(loop_state), loop_clocks, loop_usecs);
913 }
914 break;
915
916 /* LSDR is more like XSDRTDO than it is like XSDR. It uses LDELAY which
917 * comes with clocks !AND! sleep requirements.
918 */
919 case LSDR:
920 {
921 int limit = loop_count;
922 int matched = 0;
923 int attempt;
924
925 LOG_DEBUG("LSDR");
926
927 if ( xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK
928 || xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf) != ERROR_OK )
929 {
930 do_abort = 1;
931 break;
932 }
933
934 if (limit < 1)
935 limit = 1;
936
937 for( attempt=0; attempt<limit; ++attempt )
938 {
939 scan_field_t field;
940
941 xsvf_add_statemove( loop_state );
942 jtag_add_clocks(loop_clocks);
943 jtag_add_sleep(loop_usecs);
944
945 field.tap = tap;
946 field.num_bits = xsdrsize;
947 field.out_value = dr_out_buf;
948 field.in_value = calloc(CEIL(field.num_bits, 8), 1);
949
950 if (attempt > 0 && verbose)
951 LOG_USER("LSDR retry %d", attempt);
952
953 if (tap == NULL)
954 jtag_add_plain_dr_scan(1, &field, TAP_DRPAUSE);
955 else
956 jtag_add_dr_scan(1, &field, TAP_DRPAUSE);
957
958 jtag_check_value_mask(&field, dr_in_buf, dr_in_mask);
959
960 free(field.in_value);
961
962
963 /* LOG_DEBUG("FLUSHING QUEUE"); */
964 result = jtag_execute_queue();
965 if(result == ERROR_OK)
966 {
967 matched = 1;
968 break;
969 }
970 }
971
972 if (!matched )
973 {
974 LOG_USER( "LSDR mismatch" );
975 tdo_mismatch = 1;
976 break;
977 }
978 }
979 break;
980
981 case XTRST:
982 {
983 u8 trst_mode;
984
985 if (read(xsvf_fd, &trst_mode, 1) < 0)
986 {
987 do_abort = 1;
988 break;
989 }
990
991 switch( trst_mode )
992 {
993 case XTRST_ON:
994 jtag_add_reset(1, 0);
995 break;
996 case XTRST_OFF:
997 case XTRST_Z:
998 jtag_add_reset(0, 0);
999 break;
1000 case XTRST_ABSENT:
1001 break;
1002 default:
1003 LOG_ERROR( "XTRST mode argument (0x%02X) out of range", trst_mode );
1004 do_abort = 1;
1005 }
1006 }
1007 break;
1008
1009 default:
1010 LOG_ERROR("unknown xsvf command (0x%02X)\n", uc);
1011 unsupported = 1;
1012 }
1013
1014 if (do_abort || unsupported || tdo_mismatch)
1015 {
1016 LOG_DEBUG("xsvf failed, setting taps to reasonable state");
1017
1018 /* upon error, return the TAPs to a reasonable state */
1019 xsvf_add_statemove( TAP_IDLE );
1020 jtag_execute_queue();
1021 break;
1022 }
1023 }
1024
1025 if (tdo_mismatch)
1026 {
1027 command_print(cmd_ctx, "TDO mismatch, somewhere near offset %lu in xsvf file, aborting",
1028 file_offset );
1029
1030
1031 return ERROR_FAIL;
1032 }
1033
1034 if (unsupported)
1035 {
1036 command_print(cmd_ctx,
1037 "unsupported xsvf command: 0x%02X in xsvf file at offset %ld, aborting",
1038 uc, lseek(xsvf_fd, 0, SEEK_CUR)-1 );
1039 return ERROR_FAIL;
1040 }
1041
1042 if (do_abort)
1043 {
1044 command_print(cmd_ctx, "premature end of xsvf file detected, aborting");
1045 return ERROR_FAIL;
1046 }
1047
1048 if (dr_out_buf)
1049 free(dr_out_buf);
1050
1051 if (dr_in_buf)
1052 free(dr_in_buf);
1053
1054 if (dr_in_mask)
1055 free(dr_in_mask);
1056
1057 close(xsvf_fd);
1058
1059 command_print(cmd_ctx, "XSVF file programmed successfully");
1060
1061 return ERROR_OK;
1062 }
1063
1064
1065 #if 0 /* this comment style used to try and keep uncrustify from adding * at begin of line */
1066
1067 PSUEDO-Code from Xilinx Appnote XAPP067.pdf:
1068
1069 the following pseudo code clarifies the intent of the xrepeat support. The
1070 flow given is for the entire processing of an SVF file, not an XSVF file.
1071 No idea if this is just for the XC9500/XL/XV devices or all Xilinx parts.
1072
1073 "Pseudo-Code Algorithm for SVF-Based ISP"
1074
1075 1. Go to Test-Logic-Reset state
1076 2. Go to Run-Test Idle state
1077 3. Read SVF record
1078
1079 4. if SIR record then
1080 go to Shift-IR state
1081 Scan in <TDI value>
1082
1083 5. else if SDR record then
1084 set <repeat count> to 0
1085 store <TDI value> as <current TDI value>
1086 store <TDO value> as <current TDO value>
1087 6. go to Shift-DR state
1088 scan in <current TDI value>
1089 if <current TDO value> is specified then
1090 if <current TDO value> does not equal <actual TDO value> then
1091 if <repeat count> > 32 then
1092 LOG ERROR
1093 go to Run-Test Idle state
1094 go to Step 3
1095 end if
1096 go to Pause-DR
1097 go to Exit2-DR
1098 go to Shift-DR
1099 go to Exit1-DR
1100 go to Update-DR
1101 go to Run-Test/Idle
1102 increment <repeat count> by 1
1103 pause <current pause time> microseconds
1104 go to Step 6)
1105 end if
1106 else
1107 go to Run-Test Idle state
1108 go to Step 3
1109 endif
1110 else if RUNTEST record then
1111 pause tester for <TCK value> microseconds
1112 store <TCK value> as <current pause time>
1113 end if
1114
1115 #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)