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