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