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