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