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