Code Review / openocd.git / blob
? search:


1c21e9290cb40e3a3bc847b89fe93d1aa00b9d74
[openocd.git] / src / xsvf / xsvf.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2008 Peter Hettkamp *
9 * peter.hettkamp@htp-tel.de *
10 * *
11 * Copyright (C) 2009 SoftPLC Corporation. http://softplc.com *
12 * Dick Hollenbeck <dick@softplc.com> *
13 * *
14 * This program is free software; you can redistribute it and/or modify *
15 * it under the terms of the GNU General Public License as published by *
16 * the Free Software Foundation; either version 2 of the License, or *
17 * (at your option) any later version. *
18 * *
19 * This program is distributed in the hope that it will be useful, *
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
22 * GNU General Public License for more details. *
23 * *
24 * You should have received a copy of the GNU General Public License *
25 * along with this program; if not, write to the *
26 * Free Software Foundation, Inc., *
27 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
28 ***************************************************************************/
29
30
31 /* The specification for SVF is available here:
32 * http://www.asset-intertech.com/support/svf.pdf
33 * Below, this document is refered to as the "SVF spec".
34 *
35 * The specification for XSVF is available here:
36 * http://www.xilinx.com/support/documentation/application_notes/xapp503.pdf
37 * Below, this document is refered to as the "XSVF spec".
38 */
39
40 #ifdef HAVE_CONFIG_H
41 #include "config.h"
42 #endif
43
44 #include "xsvf.h"
45 #include "jtag.h"
46
47
48 /* XSVF commands, from appendix B of xapp503.pdf */
49 #define XCOMPLETE 0x00
50 #define XTDOMASK 0x01
51 #define XSIR 0x02
52 #define XSDR 0x03
53 #define XRUNTEST 0x04
54 #define XREPEAT 0x07
55 #define XSDRSIZE 0x08
56 #define XSDRTDO 0x09
57 #define XSETSDRMASKS 0x0A
58 #define XSDRINC 0x0B
59 #define XSDRB 0x0C
60 #define XSDRC 0x0D
61 #define XSDRE 0x0E
62 #define XSDRTDOB 0x0F
63 #define XSDRTDOC 0x10
64 #define XSDRTDOE 0x11
65 #define XSTATE 0x12
66 #define XENDIR 0x13
67 #define XENDDR 0x14
68 #define XSIR2 0x15
69 #define XCOMMENT 0x16
70 #define XWAIT 0x17
71
72 /* XWAITSTATE is not in the xilinx XSVF spec, but the svf2xsvf.py translator
73 * generates this. Arguably it is needed because the XSVF XRUNTEST command
74 * was ill conceived and does not directly flow out of the SVF RUNTEST command.
75 * This XWAITSTATE does map directly from the SVF RUNTEST command.
76 */
77 #define XWAITSTATE 0x18
78
79 /* Lattice has extended the SVF file format, and Dick Hollenbeck's python based
80 * SVF2XSVF converter supports these 3 additional XSVF opcodes, LCOUNT, LDELAY, LSDR.
81 * Here is an example of usage of the 3 lattice opcode extensions:
82
83 ! Set the maximum loop count to 25.
84 LCOUNT 25;
85 ! Step to DRPAUSE give 5 clocks and wait for 1.00e+000 SEC.
86 LDELAY DRPAUSE 5 TCK 1.00E-003 SEC;
87 ! Test for the completed status. Match means pass.
88 ! Loop back to LDELAY line if not match and loop count less than 25.
89
90 LSDR 1 TDI (0)
91 TDO (1);
92 */
93
94 #define LCOUNT 0x19
95 #define LDELAY 0x1A
96 #define LSDR 0x1B
97 #define XTRST 0x1C
98
99
100 /* XSVF valid state values for the XSTATE command, from appendix B of xapp503.pdf */
101 #define XSV_RESET 0x00
102 #define XSV_IDLE 0x01
103 #define XSV_DRSELECT 0x02
104 #define XSV_DRCAPTURE 0x03
105 #define XSV_DRSHIFT 0x04
106 #define XSV_DREXIT1 0x05
107 #define XSV_DRPAUSE 0x06
108 #define XSV_DREXIT2 0x07
109 #define XSV_DRUPDATE 0x08
110 #define XSV_IRSELECT 0x09
111 #define XSV_IRCAPTURE 0x0A
112 #define XSV_IRSHIFT 0x0B
113 #define XSV_IREXIT1 0x0C
114 #define XSV_IRPAUSE 0x0D
115 #define XSV_IREXIT2 0x0E
116 #define XSV_IRUPDATE 0x0F
117
118 /* arguments to XTRST */
119 #define XTRST_ON 0
120 #define XTRST_OFF 1
121 #define XTRST_Z 2
122 #define XTRST_ABSENT 3
123
124 #define XSTATE_MAX_PATH 12
125
126 static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
127
128 static int xsvf_fd = 0;
129
130
131 /* map xsvf tap state to an openocd "tap_state_t" */
132 static tap_state_t xsvf_to_tap( int xsvf_state )
133 {
134 tap_state_t ret;
135
136 switch( xsvf_state )
137 {
138 case XSV_RESET: ret = TAP_RESET; break;
139 case XSV_IDLE: ret = TAP_IDLE; break;
140 case XSV_DRSELECT: ret = TAP_DRSELECT; break;
141 case XSV_DRCAPTURE: ret = TAP_DRCAPTURE; break;
142 case XSV_DRSHIFT: ret = TAP_DRSHIFT; break;
143 case XSV_DREXIT1: ret = TAP_DREXIT1; break;
144 case XSV_DRPAUSE: ret = TAP_DRPAUSE; break;
145 case XSV_DREXIT2: ret = TAP_DREXIT2; break;
146 case XSV_DRUPDATE: ret = TAP_DRUPDATE; break;
147 case XSV_IRSELECT: ret = TAP_IRSELECT; break;
148 case XSV_IRCAPTURE: ret = TAP_IRCAPTURE; break;
149 case XSV_IRSHIFT: ret = TAP_IRSHIFT; break;
150 case XSV_IREXIT1: ret = TAP_IREXIT1; break;
151 case XSV_IRPAUSE: ret = TAP_IRPAUSE; break;
152 case XSV_IREXIT2: ret = TAP_IREXIT2; break;
153 case XSV_IRUPDATE: ret = TAP_IRUPDATE; break;
154 default:
155 LOG_ERROR( "UNKNOWN XSVF STATE 0x%02X", xsvf_state );
156 exit(1);
157 }
158
159 return ret;
160 }
161
162
163
164 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 jtag_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 jtag_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 /* there is no need for the lookahead code that was here since we
504 queue up the jtag commands anyway. This is a simple way to handle
505 the XSTATE.
506 */
507
508 if ( jtag_add_statemove( mystate ) != ERROR_OK )
509 {
510 /* For special states known as stable states
511 (Test-Logic-Reset, Run-Test/Idle, Pause-DR, Pause- IR),
512 an XSVF interpreter follows predefined TAP state paths
513 when the starting state is a stable state and when the
514 XSTATE specifies a new stable state (see the STATE
515 command in the [Ref 5] for the TAP state paths between
516 stable states). For non-stable states, XSTATE should
517 specify a state that is only one TAP state transition
518 distance from the current TAP state to avoid undefined
519 TAP state paths. A sequence of multiple XSTATE commands
520 can be issued to transition the TAP through a specific
521 state path.
522 */
523
524 LOG_ERROR("XSTATE %s is not reachable from current state %s in one clock cycle",
525 tap_state_name(mystate),
526 tap_state_name(cmd_queue_cur_state)
527 );
528 }
529 }
530 break;
531
532 case XENDIR:
533
534 if (read(xsvf_fd, &uc, 1) < 0)
535 {
536 do_abort = 1;
537 break;
538 }
539
540 /* see page 22 of XSVF spec */
541 if ( uc == 0 )
542 xendir = TAP_IDLE;
543 else if ( uc == 1 )
544 xendir = TAP_IRPAUSE;
545 else
546 {
547 LOG_ERROR("illegial XENDIR argument: 0x%02X", uc);
548 unsupported = 1;
549 break;
550 }
551
552 LOG_DEBUG("XENDIR 0x%02X %s", uc, tap_state_name(xendir));
553 break;
554
555 case XENDDR:
556
557 if (read(xsvf_fd, &uc, 1) < 0)
558 {
559 do_abort = 1;
560 break;
561 }
562
563 /* see page 22 of XSVF spec */
564 if ( uc == 0 )
565 xenddr = TAP_IDLE;
566 else if ( uc == 1 )
567 xenddr = TAP_DRPAUSE;
568 else
569 {
570 LOG_ERROR("illegial XENDDR argument: 0x%02X", uc);
571 unsupported = 1;
572 break;
573 }
574
575 LOG_DEBUG("XENDDR %02X %s", uc, tap_state_name(xenddr));
576 break;
577
578 case XSIR:
579 case XSIR2:
580 {
581 uint8_t short_buf[2];
582 uint8_t* ir_buf;
583 int bitcount;
584 tap_state_t my_end_state = xruntest ? TAP_IDLE : xendir;
585
586 if ( opcode == XSIR )
587 {
588 /* one byte bitcount */
589 if (read(xsvf_fd, short_buf, 1) < 0)
590 {
591 do_abort = 1;
592 break;
593 }
594 bitcount = short_buf[0];
595 LOG_DEBUG("XSIR %d", bitcount);
596 }
597 else
598 {
599 if (read(xsvf_fd, short_buf, 2) < 0)
600 {
601 do_abort = 1;
602 break;
603 }
604 bitcount = be_to_h_u16(short_buf);
605 LOG_DEBUG("XSIR2 %d", bitcount);
606 }
607
608 ir_buf = malloc((bitcount+7) / 8);
609
610 if (xsvf_read_buffer(bitcount, xsvf_fd, ir_buf) != ERROR_OK)
611 do_abort = 1;
612 else
613 {
614 scan_field_t field;
615
616 field.tap = tap;
617 field.num_bits = bitcount;
618 field.out_value = ir_buf;
619
620 field.in_value = NULL;
621
622
623
624
625 if (tap == NULL)
626 jtag_add_plain_ir_scan(1, &field, my_end_state);
627 else
628 jtag_add_ir_scan(1, &field, my_end_state);
629
630 if (xruntest)
631 {
632 if (runtest_requires_tck)
633 jtag_add_clocks(xruntest);
634 else
635 jtag_add_sleep(xruntest);
636 }
637
638 /* Note that an -irmask of non-zero in your config file
639 * can cause this to fail. Setting -irmask to zero cand work
640 * around the problem.
641 */
642
643 /* LOG_DEBUG("FLUSHING QUEUE"); */
644 result = jtag_execute_queue();
645 if (result != ERROR_OK)
646 {
647 tdo_mismatch = 1;
648 }
649 }
650 free(ir_buf);
651 }
652 break;
653
654 case XCOMMENT:
655 {
656 unsigned int ndx = 0;
657 char comment[128];
658
659 do
660 {
661 if (read(xsvf_fd, &uc, 1) < 0)
662 {
663 do_abort = 1;
664 break;
665 }
666
667 if ( ndx < sizeof(comment)-1 )
668 comment[ndx++] = uc;
669
670 } while (uc != 0);
671
672 comment[sizeof(comment)-1] = 0; /* regardless, terminate */
673 if (verbose)
674 LOG_USER("# %s", comment);
675 }
676 break;
677
678 case XWAIT:
679 {
680 /* expected in stream:
681 XWAIT <uint8_t wait_state> <uint8_t end_state> <uint32_t usecs>
682 */
683
684 uint8_t wait;
685 uint8_t end;
686 uint8_t delay_buf[4];
687
688 tap_state_t wait_state;
689 tap_state_t end_state;
690 int delay;
691
692 if ( read(xsvf_fd, &wait, 1) < 0
693 || read(xsvf_fd, &end, 1) < 0
694 || read(xsvf_fd, delay_buf, 4) < 0)
695 {
696 do_abort = 1;
697 break;
698 }
699
700 wait_state = xsvf_to_tap(wait);
701 end_state = xsvf_to_tap(end);
702 delay = be_to_h_u32(delay_buf);
703
704 LOG_DEBUG("XWAIT %s %s usecs:%d", tap_state_name(wait_state), tap_state_name(end_state), delay);
705
706 if (runtest_requires_tck && wait_state == TAP_IDLE )
707 {
708 jtag_add_runtest(delay, end_state);
709 }
710 else
711 {
712 jtag_add_statemove( wait_state );
713 jtag_add_sleep(delay);
714 jtag_add_statemove( end_state );
715 }
716 }
717 break;
718
719 case XWAITSTATE:
720 {
721 /* expected in stream:
722 XWAITSTATE <uint8_t wait_state> <uint8_t end_state> <uint32_t clock_count> <uint32_t usecs>
723 */
724
725 uint8_t clock_buf[4];
726 uint8_t usecs_buf[4];
727 uint8_t wait;
728 uint8_t end;
729 tap_state_t wait_state;
730 tap_state_t end_state;
731 int clock_count;
732 int usecs;
733
734 if ( read(xsvf_fd, &wait, 1) < 0
735 || read(xsvf_fd, &end, 1) < 0
736 || read(xsvf_fd, clock_buf, 4) < 0
737 || read(xsvf_fd, usecs_buf, 4) < 0 )
738 {
739 do_abort = 1;
740 break;
741 }
742
743 wait_state = xsvf_to_tap( wait );
744 end_state = xsvf_to_tap( end );
745
746 clock_count = be_to_h_u32(clock_buf);
747 usecs = be_to_h_u32(usecs_buf);
748
749 LOG_DEBUG("XWAITSTATE %s %s clocks:%i usecs:%i",
750 tap_state_name(wait_state),
751 tap_state_name(end_state),
752 clock_count, usecs);
753
754 /* the following states are 'stable', meaning that they have a transition
755 * in the state diagram back to themselves. This is necessary because we will
756 * be issuing a number of clocks in this state. This set of allowed states is also
757 * determined by the SVF RUNTEST command's allowed states.
758 */
759 if (wait_state != TAP_IRPAUSE && wait_state != TAP_DRPAUSE && wait_state != TAP_RESET && wait_state != TAP_IDLE)
760 {
761 LOG_ERROR("illegal XWAITSTATE wait_state: \"%s\"", tap_state_name( wait_state ));
762 unsupported = 1;
763 }
764
765 jtag_add_statemove( wait_state );
766
767 jtag_add_clocks( clock_count );
768
769 jtag_add_sleep( usecs );
770
771 jtag_add_statemove( end_state );
772 }
773 break;
774
775 case LCOUNT:
776 {
777 /* expected in stream:
778 LCOUNT <uint32_t loop_count>
779 */
780 uint8_t count_buf[4];
781
782 if ( read(xsvf_fd, count_buf, 4) < 0 )
783 {
784 do_abort = 1;
785 break;
786 }
787
788 loop_count = be_to_h_u32(count_buf);
789 LOG_DEBUG("LCOUNT %d", loop_count);
790 }
791 break;
792
793 case LDELAY:
794 {
795 /* expected in stream:
796 LDELAY <uint8_t wait_state> <uint32_t clock_count> <uint32_t usecs_to_sleep>
797 */
798 uint8_t state;
799 uint8_t clock_buf[4];
800 uint8_t usecs_buf[4];
801
802 if ( read(xsvf_fd, &state, 1) < 0
803 || read(xsvf_fd, clock_buf, 4) < 0
804 || read(xsvf_fd, usecs_buf, 4) < 0 )
805 {
806 do_abort = 1;
807 break;
808 }
809
810 loop_state = xsvf_to_tap(state);
811 loop_clocks = be_to_h_u32(clock_buf);
812 loop_usecs = be_to_h_u32(usecs_buf);
813
814 LOG_DEBUG("LDELAY %s clocks:%d usecs:%d", tap_state_name(loop_state), loop_clocks, loop_usecs);
815 }
816 break;
817
818 /* LSDR is more like XSDRTDO than it is like XSDR. It uses LDELAY which
819 * comes with clocks !AND! sleep requirements.
820 */
821 case LSDR:
822 {
823 int limit = loop_count;
824 int matched = 0;
825 int attempt;
826
827 LOG_DEBUG("LSDR");
828
829 if ( xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK
830 || xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf) != ERROR_OK )
831 {
832 do_abort = 1;
833 break;
834 }
835
836 if (limit < 1)
837 limit = 1;
838
839 for( attempt=0; attempt<limit; ++attempt )
840 {
841 scan_field_t field;
842
843 jtag_add_statemove( loop_state );
844 jtag_add_clocks(loop_clocks);
845 jtag_add_sleep(loop_usecs);
846
847 field.tap = tap;
848 field.num_bits = xsdrsize;
849 field.out_value = dr_out_buf;
850 field.in_value = calloc(CEIL(field.num_bits, 8), 1);
851
852 if (attempt > 0 && verbose)
853 LOG_USER("LSDR retry %d", attempt);
854
855 if (tap == NULL)
856 jtag_add_plain_dr_scan(1, &field, jtag_set_end_state(TAP_DRPAUSE));
857 else
858 jtag_add_dr_scan(1, &field, jtag_set_end_state(TAP_DRPAUSE));
859
860 jtag_check_value_mask(&field, dr_in_buf, dr_in_mask);
861
862 free(field.in_value);
863
864
865 /* LOG_DEBUG("FLUSHING QUEUE"); */
866 result = jtag_execute_queue();
867 if (result == ERROR_OK)
868 {
869 matched = 1;
870 break;
871 }
872 }
873
874 if (!matched )
875 {
876 LOG_USER( "LSDR mismatch" );
877 tdo_mismatch = 1;
878 break;
879 }
880 }
881 break;
882
883 case XTRST:
884 {
885 uint8_t trst_mode;
886
887 if (read(xsvf_fd, &trst_mode, 1) < 0)
888 {
889 do_abort = 1;
890 break;
891 }
892
893 switch( trst_mode )
894 {
895 case XTRST_ON:
896 jtag_add_reset(1, 0);
897 break;
898 case XTRST_OFF:
899 case XTRST_Z:
900 jtag_add_reset(0, 0);
901 break;
902 case XTRST_ABSENT:
903 break;
904 default:
905 LOG_ERROR( "XTRST mode argument (0x%02X) out of range", trst_mode );
906 do_abort = 1;
907 }
908 }
909 break;
910
911 default:
912 LOG_ERROR("unknown xsvf command (0x%02X)\n", uc);
913 unsupported = 1;
914 }
915
916 if (do_abort || unsupported || tdo_mismatch)
917 {
918 LOG_DEBUG("xsvf failed, setting taps to reasonable state");
919
920 /* upon error, return the TAPs to a reasonable state */
921 jtag_add_statemove( TAP_IDLE );
922 jtag_execute_queue();
923 break;
924 }
925 }
926
927 if (tdo_mismatch)
928 {
929 command_print(cmd_ctx, "TDO mismatch, somewhere near offset %lu in xsvf file, aborting",
930 file_offset );
931
932
933 return ERROR_FAIL;
934 }
935
936 if (unsupported)
937 {
938 off_t offset = lseek(xsvf_fd, 0, SEEK_CUR) - 1;
939 command_print(cmd_ctx,
940 "unsupported xsvf command (0x%02X) at offset %jd, aborting",
941 uc, (intmax_t)offset);
942 return ERROR_FAIL;
943 }
944
945 if (do_abort)
946 {
947 command_print(cmd_ctx, "premature end of xsvf file detected, aborting");
948 return ERROR_FAIL;
949 }
950
951 if (dr_out_buf)
952 free(dr_out_buf);
953
954 if (dr_in_buf)
955 free(dr_in_buf);
956
957 if (dr_in_mask)
958 free(dr_in_mask);
959
960 close(xsvf_fd);
961
962 command_print(cmd_ctx, "XSVF file programmed successfully");
963
964 return ERROR_OK;
965 }
966
967
968 #if 0 /* this comment style used to try and keep uncrustify from adding * at begin of line */
969
970 PSUEDO-Code from Xilinx Appnote XAPP067.pdf:
971
972 the following pseudo code clarifies the intent of the xrepeat support. The
973 flow given is for the entire processing of an SVF file, not an XSVF file.
974 No idea if this is just for the XC9500/XL/XV devices or all Xilinx parts.
975
976 "Pseudo-Code Algorithm for SVF-Based ISP"
977
978 1. Go to Test-Logic-Reset state
979 2. Go to Run-Test Idle state
980 3. Read SVF record
981
982 4. if SIR record then
983 go to Shift-IR state
984 Scan in <TDI value>
985
986 5. else if SDR record then
987 set <repeat count> to 0
988 store <TDI value> as <current TDI value>
989 store <TDO value> as <current TDO value>
990 6. go to Shift-DR state
991 scan in <current TDI value>
992 if <current TDO value> is specified then
993 if <current TDO value> does not equal <actual TDO value> then
994 if <repeat count> > 32 then
995 LOG ERROR
996 go to Run-Test Idle state
997 go to Step 3
998 end if
999 go to Pause-DR
1000 go to Exit2-DR
1001 go to Shift-DR
1002 go to Exit1-DR
1003 go to Update-DR
1004 go to Run-Test/Idle
1005 increment <repeat count> by 1
1006 pause <current pause time> microseconds
1007 go to Step 6)
1008 end if
1009 else
1010 go to Run-Test Idle state
1011 go to Step 3
1012 endif
1013 else if RUNTEST record then
1014 pause tester for <TCK value> microseconds
1015 store <TCK value> as <current pause time>
1016 end if
1017
1018 #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)