xsvf.c 24.6 KB
Newer Older
1
/***************************************************************************
2
3
4
5
6
7
8
9
10
11
 *	 Copyright (C) 2005 by Dominic Rath									   *
 *	 Dominic.Rath@gmx.de													   *
 *																		   *
 *	 Copyright (C) 2007,2008 yvind Harboe								   *
 *	 oyvind.harboe@zylin.com												   *
 *																		   *
 *	 Copyright (C) 2008 Peter Hettkamp									   *
 *	 peter.hettkamp@htp-tel.de											   *
 *																		   *
 *	 Copyright (C) 2009 SoftPLC Corporation. http://softplc.com             *
12
 *	 Dick Hollenbeck <dick@softplc.com>									   *
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 *                                                                          *
 *	 This program is free software; you can redistribute it and/or modify   *
 *	 it under the terms of the GNU General Public License as published by   *
 *	 the Free Software Foundation; either version 2 of the License, or	   *
 *	 (at your option) any later version.									   *
 *																		   *
 *	 This program is distributed in the hope that it will be useful,		   *
 *	 but WITHOUT ANY WARRANTY; without even the implied warranty of		   *
 *	 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the		   *
 *	 GNU General Public License for more details.						   *
 *																		   *
 *	 You should have received a copy of the GNU General Public License	   *
 *	 along with this program; if not, write to the						   *
 *	 Free Software Foundation, Inc.,										   *
 *	 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.			   *
28
 ***************************************************************************/
29
30
31
32
33
34
35
36
37
38
39


/* The specification for SVF is available here:
 * http://www.asset-intertech.com/support/svf.pdf
 * Below, this document is refered to as the "SVF spec".
 *
 * The specification for XSVF is available here:
 * http://www.xilinx.com/support/documentation/application_notes/xapp503.pdf
 * Below, this document is refered to as the "XSVF spec".
 */

40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "xsvf.h"

#include "jtag.h"
#include "command.h"
#include "log.h"

#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>

#include <sys/time.h>
#include <time.h>


61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
/* XSVF commands, from appendix B of xapp503.pdf  */
#define XCOMPLETE		0x00
#define XTDOMASK			0x01
#define XSIR				0x02
#define XSDR				0x03
#define XRUNTEST			0x04
#define XREPEAT			0x07
#define XSDRSIZE			0x08
#define XSDRTDO			0x09
#define XSETSDRMASKS		0x0A
#define XSDRINC			0x0B
#define XSDRB			0x0C
#define XSDRC			0x0D
#define XSDRE			0x0E
#define XSDRTDOB			0x0F
#define XSDRTDOC			0x10
#define XSDRTDOE			0x11
#define XSTATE			0x12
#define XENDIR			0x13
#define XENDDR			0x14
#define XSIR2			0x15
#define XCOMMENT			0x16
#define XWAIT			0x17
84

85
86
87
88
89
90
/* XWAITSTATE is not in the xilinx XSVF spec, but the svf2xsvf.py translator
 * generates this.  Arguably it is needed because the XSVF XRUNTEST command
 * was ill conceived and does not directly flow out of the SVF RUNTEST command.
 * This XWAITSTATE does map directly from the SVF RUNTEST command.
 */
#define XWAITSTATE		0x18
91

92
93
94
/* Lattice has extended the SVF file format, and Dick Hollenbeck's python based
 * SVF2XSVF converter supports these 3 additional XSVF opcodes, LCOUNT, LDELAY, LSDR.
 * Here is an example of usage of the 3 lattice opcode extensions:
95

96
97
98
99
100
101
! Set the maximum loop count to 25.
LCOUNT	25;
! Step to DRPAUSE give 5 clocks and wait for 1.00e+000 SEC.
LDELAY	DRPAUSE	5 TCK	1.00E-003 SEC;
! Test for the completed status. Match means pass.
! Loop back to LDELAY line if not match and loop count less than 25.
102

103
104
105
LSDR 1  TDI  (0)
		TDO  (1);
*/
106

107
108
109
#define LCOUNT			0x19
#define LDELAY			0x1A
#define LSDR				0x1B
110
#define XTRST			0x1C
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130


/* XSVF valid state values for the XSTATE command, from appendix B of xapp503.pdf */
#define XSV_RESET		0x00
#define XSV_IDLE			0x01
#define XSV_DRSELECT		0x02
#define XSV_DRCAPTURE	0x03
#define XSV_DRSHIFT		0x04
#define XSV_DREXIT1		0x05
#define XSV_DRPAUSE		0x06
#define XSV_DREXIT2		0x07
#define XSV_DRUPDATE		0x08
#define XSV_IRSELECT		0x09
#define XSV_IRCAPTURE	0x0A
#define XSV_IRSHIFT		0x0B
#define XSV_IREXIT1		0x0C
#define XSV_IRPAUSE		0x0D
#define XSV_IREXIT2		0x0E
#define XSV_IRUPDATE		0x0F

131
132
133
134
135
/* arguments to XTRST */
#define XTRST_ON			0
#define XTRST_OFF		1
#define XTRST_Z			2
#define XTRST_ABSENT		3
136
137

#define XSTATE_MAX_PATH 12
138

139
140
141
142
143
static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);

static int xsvf_fd = 0;


144
/* map xsvf tap state to an openocd "tap_state_t" */
145
static tap_state_t xsvf_to_tap( int xsvf_state )
146
{
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
	tap_state_t	ret;

	switch( xsvf_state )
	{
	case XSV_RESET:			ret = TAP_RESET;			break;
	case XSV_IDLE:			ret = TAP_IDLE;			break;
	case XSV_DRSELECT:		ret = TAP_DRSELECT;		break;
	case XSV_DRCAPTURE:		ret = TAP_DRCAPTURE;		break;
	case XSV_DRSHIFT:		ret = TAP_DRSHIFT;		break;
	case XSV_DREXIT1:		ret = TAP_DREXIT1;		break;
	case XSV_DRPAUSE:		ret = TAP_DRPAUSE;		break;
	case XSV_DREXIT2:		ret = TAP_DREXIT2;		break;
	case XSV_DRUPDATE:		ret = TAP_DRUPDATE;		break;
	case XSV_IRSELECT:		ret = TAP_IRSELECT;		break;
	case XSV_IRCAPTURE:		ret = TAP_IRCAPTURE;		break;
	case XSV_IRSHIFT:		ret = TAP_IRSHIFT;		break;
	case XSV_IREXIT1:		ret = TAP_IREXIT1;		break;
	case XSV_IRPAUSE:		ret = TAP_IRPAUSE;		break;
	case XSV_IREXIT2:		ret = TAP_IREXIT2;		break;
	case XSV_IRUPDATE:		ret = TAP_IRUPDATE;		break;
	default:
		LOG_ERROR( "UNKNOWN XSVF STATE 0x%02X", xsvf_state );
		exit(1);
	}

	return ret;
}
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
181
 * Implemented via jtag_add_pathmove().
 */
182
static void xsvf_add_statemove(tap_state_t state)
183
{
184
185
	tap_state_t moves[7]; 	/* max # of transitions */
	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;
drath's avatar
drath committed
192

193
	if(state==TAP_RESET)
194
	{
195
196
		jtag_add_tlr();
		return;
197
	}
198

199
200
	for (i=0; i<7; i++)
	{
drath's avatar
drath committed
201
		int j = (move >> i) & 1;
202
203
		if (j)
		{
204
			curstate = tap_state_transition(curstate, true);
205
206
		}
		else
207
		{
208
			curstate = tap_state_transition(curstate, false);
209
		}
drath's avatar
drath committed
210
		moves[i] = curstate;
211
	}
drath's avatar
drath committed
212

213
214
215
	jtag_add_pathmove(7, moves);
}

216
217
218
int xsvf_register_commands(struct command_context_s *cmd_ctx)
{
	register_command(cmd_ctx, NULL, "xsvf", handle_xsvf_command,
219
		COMMAND_EXEC, "run xsvf <file> [virt2] [quiet]");
220
221
222
223

	return ERROR_OK;
}

224
static int xsvf_read_buffer(int num_bits, int fd, u8* buf)
225
226
227
228
229
{
	int num_bytes;

	for (num_bytes = (num_bits + 7) / 8; num_bytes > 0; num_bytes--)
	{
230
		/* reverse the order of bytes as they are read sequentially from file */
231
232
233
234
235
236
237
		if (read(fd, buf + num_bytes - 1, 1) < 0)
			return ERROR_XSVF_EOF;
	}

	return ERROR_OK;
}

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
247
		tap_state_t	mystate;

248
249
		if (*path_len > max_path)
		{
250
			LOG_WARNING("XSTATE path longer than max_path");
251
252
253
254
255
256
			break;
		}
		if (read(fd, &uc, 1) < 0)
		{
			return ERROR_XSVF_EOF;
		}
257
258
259

		mystate = xsvf_to_tap(uc);

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
268
269
	return ERROR_OK;
}

270
271

static int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
272
{
273
274
275
	u8 *dr_out_buf = NULL; 				/* from host to device (TDI) */
	u8 *dr_in_buf = NULL;				/* from device to host (TDO) */
	u8 *dr_in_mask = NULL;
276

277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
	int xsdrsize = 0;
	int xruntest = 0;					/* number of TCK cycles OR microseconds */
	int xrepeat	 = 0;					/* number of retries */

	tap_state_t	xendir = TAP_IDLE;		/* see page 8 of the SVF spec, initial xendir to be TAP_IDLE */
	tap_state_t xenddr = TAP_IDLE;

	u8  		opcode;
	u8		uc;
	long		file_offset = 0;

	int		loop_count = 0;
	tap_state_t	loop_state = TAP_IDLE;
	int		loop_clocks = 0;
	int		loop_usecs = 0;

	int 		do_abort = 0;
	int 		unsupported = 0;
	int 		tdo_mismatch = 0;
	int 		result;
297
298
	int		verbose = 1;
	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
304
	/* use NULL to indicate a "plain" xsvf file which accounts for
	   additional devices in the scan chain, otherwise the device
305
306
307
	   that should be affected
	*/
	jtag_tap_t *tap = NULL;
308
309
310

	if (argc < 2)
	{
311
		command_print(cmd_ctx, "usage: xsvf <device#|plain> <file> [<variant>] [quiet]");
312
		return ERROR_FAIL;
313
314
	}

315
316
	filename = args[1];		/* we mess with args starting point below, snapshot filename here */

317
318
	if (strcmp(args[0], "plain") != 0)
	{
319
320
321
322
323
324
		tap = jtag_TapByString( args[0] );
		if (!tap )
		{
			command_print( cmd_ctx, "Tap: %s unknown", args[0] );
			return ERROR_FAIL;
		}
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
335
336
	if ((argc > 2) && (strcmp(args[2], "virt2") == 0))
	{
		runtest_requires_tck = 1;
337
338
339
340
341
342
343
		--argc;
		++args;
	}

	if ((argc > 2) && (strcmp(args[2], "quiet") == 0))
	{
		verbose = 0;
344
345
	}

346
	LOG_USER("xsvf processing file: \"%s\"", filename);
347
348

	while( read(xsvf_fd, &opcode, 1) > 0 )
349
	{
350
351
352
353
		/* record the position of the just read opcode within the file */
		file_offset = lseek(xsvf_fd, 0, SEEK_CUR) - 1;

		switch (opcode)
354
		{
355
356
		case XCOMPLETE:
			LOG_DEBUG("XCOMPLETE");
357

358
359
360
361
			result = jtag_execute_queue();
			if (result != ERROR_OK)
			{
				tdo_mismatch = 1;
362
				break;
363
364
			}
			break;
365

366
367
368
369
370
		case XTDOMASK:
			LOG_DEBUG("XTDOMASK");
			if (dr_in_mask && (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_mask) != ERROR_OK))
				do_abort = 1;
			break;
371

372
373
374
375
376
		case XRUNTEST:
			{
				u8	xruntest_buf[4];

				if (read(xsvf_fd, xruntest_buf, 4) < 0)
377
				{
378
379
380
					do_abort = 1;
					break;
				}
381

382
383
384
385
				xruntest = be_to_h_u32(xruntest_buf);
				LOG_DEBUG("XRUNTEST %d 0x%08X", xruntest, xruntest);
			}
			break;
386

387
388
389
		case XREPEAT:
			{
				u8 myrepeat;
390

391
392
393
				if (read(xsvf_fd, &myrepeat, 1) < 0)
					do_abort = 1;
				else
394
				{
395
396
					xrepeat = myrepeat;
					LOG_DEBUG("XREPEAT %d", xrepeat );
397
				}
398
399
			}
			break;
400

401
402
403
404
405
		case XSDRSIZE:
			{
				u8	xsdrsize_buf[4];

				if (read(xsvf_fd, xsdrsize_buf, 4) < 0)
406
				{
407
408
409
					do_abort = 1;
					break;
				}
410

411
412
				xsdrsize = be_to_h_u32(xsdrsize_buf);
				LOG_DEBUG("XSDRSIZE %d", xsdrsize);
413

414
415
416
				if( dr_out_buf ) free(dr_out_buf);
				if( dr_in_buf)   free(dr_in_buf);
				if( dr_in_mask)  free(dr_in_mask);
417

418
419
420
421
422
				dr_out_buf = malloc((xsdrsize + 7) / 8);
				dr_in_buf = malloc((xsdrsize + 7) / 8);
				dr_in_mask = malloc((xsdrsize + 7) / 8);
			}
			break;
423

424
425
426
427
428
429
		case XSDR:		/* these two are identical except for the dr_in_buf */
		case XSDRTDO:
			{
				int limit = xrepeat;
				int	matched = 0;
				int attempt;
430

431
				const char* op_name = (opcode == XSDR ? "XSDR" : "XSDRTDO");
432

433
434
435
436
437
				if (xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK)
				{
					do_abort = 1;
					break;
				}
438

439
440
441
				if (opcode == XSDRTDO)
				{
					if(xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf)  != ERROR_OK )
442
					{
443
						do_abort = 1;
444
445
						break;
					}
446
				}
447

448
449
				if (limit < 1)
					limit = 1;
450

451
				LOG_DEBUG("%s %d", op_name, xsdrsize);
452

453
454
455
				for( attempt=0; attempt<limit;  ++attempt )
				{
					scan_field_t field;
456

457
					if( attempt>0 )
458
					{
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
						/* perform the XC9500 exception handling sequence shown in xapp067.pdf and
						   illustrated in psuedo code at end of this file.  We start from state
						   DRPAUSE:
						   go to Exit2-DR
						   go to Shift-DR
						   go to Exit1-DR
						   go to Update-DR
						   go to Run-Test/Idle

						   This sequence should be harmless for other devices, and it
						   will be skipped entirely if xrepeat is set to zero.
						*/

						static tap_state_t exception_path[] = {
							TAP_DREXIT2,
							TAP_DRSHIFT,
							TAP_DREXIT1,
							TAP_DRUPDATE,
							TAP_IDLE,
						};

						jtag_add_pathmove( sizeof(exception_path)/sizeof(exception_path[0]), exception_path);

						if (verbose)
							LOG_USER("%s mismatch, xsdrsize=%d retry=%d", op_name, xsdrsize, attempt);
					}
485

486
487
488
489
490
					field.tap = tap;
					field.num_bits = xsdrsize;
					field.out_value = dr_out_buf;
					field.out_mask = NULL;
					field.in_value = NULL;
491

492
					jtag_set_check_value(&field, dr_in_buf, dr_in_mask, NULL);
493

494
495
496
497
					if (tap == NULL)
						jtag_add_plain_dr_scan(1, &field, TAP_DRPAUSE);
					else
						jtag_add_dr_scan(1, &field, TAP_DRPAUSE);
498

499
500
501
					/* LOG_DEBUG("FLUSHING QUEUE"); */
					result = jtag_execute_queue();
					if (result == ERROR_OK)
502
					{
503
						matched = 1;
504
505
						break;
					}
506
				}
507

508
509
510
511
512
513
				if (!matched)
				{
					LOG_USER( "%s mismatch", op_name);
					tdo_mismatch = 1;
					break;
				}
514

515
516
517
518
519
520
521
522
523
				/* See page 19 of XSVF spec regarding opcode "XSDR" */
				if (xruntest)
				{
					xsvf_add_statemove(TAP_IDLE);

					if (runtest_requires_tck)
						jtag_add_clocks(xruntest);
					else
						jtag_add_sleep(xruntest);
524
				}
525
526
527
528
				else if (xendir != TAP_DRPAUSE)	/* we are already in TAP_DRPAUSE */
					xsvf_add_statemove(xenddr);
			}
			break;
529

530
531
532
533
		case XSETSDRMASKS:
			LOG_ERROR("unsupported XSETSDRMASKS\n");
			unsupported = 1;
			break;
534

535
536
537
538
		case XSDRINC:
			LOG_ERROR("unsupported XSDRINC\n");
			unsupported = 1;
			break;
539

540
541
542
543
		case XSDRB:
			LOG_ERROR("unsupported XSDRB\n");
			unsupported = 1;
			break;
544

545
546
547
548
		case XSDRC:
			LOG_ERROR("unsupported XSDRC\n");
			unsupported = 1;
			break;
549

550
551
552
553
		case XSDRE:
			LOG_ERROR("unsupported XSDRE\n");
			unsupported = 1;
			break;
554

555
556
557
558
		case XSDRTDOB:
			LOG_ERROR("unsupported XSDRTDOB\n");
			unsupported = 1;
			break;
559

560
561
562
563
		case XSDRTDOC:
			LOG_ERROR("unsupported XSDRTDOC\n");
			unsupported = 1;
			break;
564

565
566
567
568
569
570
571
572
573
574
		case XSDRTDOE:
			LOG_ERROR("unsupported XSDRTDOE\n");
			unsupported = 1;
			break;

		case XSTATE:
			{
				tap_state_t	mystate;
				tap_state_t*	path;
				int 			path_len;
575

576
				if (read(xsvf_fd, &uc, 1) < 0)
577
				{
578
579
580
					do_abort = 1;
					break;
				}
581

582
				mystate = xsvf_to_tap(uc);
583

584
				LOG_DEBUG("XSTATE 0x%02X %s", uc, tap_state_name(mystate) );
585

586
587
				path = calloc(XSTATE_MAX_PATH, 4);
				path_len = 1;
588

589
590
591
592
593
594
				path[0] = mystate;
				if (xsvf_read_xstates(xsvf_fd, path, XSTATE_MAX_PATH, &path_len) != ERROR_OK)
					do_abort = 1;
				else
				{
					int i,lasti;
595

596
597
598
599
600
					/* here the trick is that jtag_add_pathmove() must end in a stable
					 * state, so we must only invoke jtag_add_tlr() when we absolutely
					 * have to
					 */
					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
609
							lasti=i+1;
							jtag_add_tlr();
610
						}
611
					}
612
613
614
615
					if(i>=lasti)
					{
						jtag_add_pathmove(i-lasti, path+lasti);
					}
616
				}
617
618
619
				free(path);
			}
			break;
620

621
		case XENDIR:
622

623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
			if (read(xsvf_fd, &uc, 1) < 0)
			{
				do_abort = 1;
				break;
			}

			/* see page 22 of XSVF spec */
			if( uc == 0 )
				xendir = TAP_IDLE;
			else if( uc == 1 )
				xendir = TAP_IRPAUSE;
			else
			{
				LOG_ERROR("illegial XENDIR argument: 0x%02X", uc);
				unsupported = 1;
				break;
			}
640

641
642
			LOG_DEBUG("XENDIR 0x%02X %s", uc, tap_state_name(xendir));
			break;
643

644
		case XENDDR:
645

646
647
648
			if (read(xsvf_fd, &uc, 1) < 0)
			{
				do_abort = 1;
649
				break;
650
651
652
653
654
655
656
657
658
659
660
661
662
			}

			/* see page 22 of XSVF spec */
			if( uc == 0 )
				xenddr = TAP_IDLE;
			else if( uc == 1 )
				xenddr = TAP_DRPAUSE;
			else
			{
				LOG_ERROR("illegial XENDDR argument: 0x%02X", uc);
				unsupported = 1;
				break;
			}
663

664
665
			LOG_DEBUG("XENDDR %02X %s", uc, tap_state_name(xenddr));
			break;
666

667
668
669
670
671
672
673
674
675
676
677
678
		case XSIR:
		case XSIR2:
			{
				u8	short_buf[2];
				u8*	ir_buf;
				int bitcount;
				tap_state_t my_end_state = xruntest ? TAP_IDLE : xendir;

				if( opcode == XSIR )
				{
					/* one byte bitcount */
					if (read(xsvf_fd, short_buf, 1) < 0)
679
					{
680
681
682
						do_abort = 1;
						break;
					}
683
684
685
686
687
688
					bitcount = short_buf[0];
					LOG_DEBUG("XSIR %d", bitcount);
				}
				else
				{
					if (read(xsvf_fd, short_buf, 2) < 0)
689
					{
690
						do_abort = 1;
691
						break;
692
					}
693
694
					bitcount = be_to_h_u16(short_buf);
					LOG_DEBUG("XSIR2 %d", bitcount);
695
				}
696

697
				ir_buf = malloc((bitcount+7) / 8);
698

699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
				if (xsvf_read_buffer(bitcount, xsvf_fd, ir_buf) != ERROR_OK)
					do_abort = 1;
				else
				{
					scan_field_t field;

					field.tap = tap;
					field.num_bits = bitcount;
					field.out_value = ir_buf;
					field.out_mask = NULL;
					field.in_value = NULL;
					field.in_check_value = NULL;
					field.in_check_mask = NULL;
					field.in_handler = NULL;
					field.in_handler_priv = NULL;

					if (tap == NULL)
						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
723
						if (runtest_requires_tck)
							jtag_add_clocks(xruntest);
724
						else
725
726
							jtag_add_sleep(xruntest);
					}
727

728
729
730
731
					/* Note that an -irmask of non-zero in your config file
					 * can cause this to fail.  Setting -irmask to zero cand work
					 * around the problem.
					 */
732

733
734
735
736
737
					/* LOG_DEBUG("FLUSHING QUEUE"); */
					result = jtag_execute_queue();
					if(result != ERROR_OK)
					{
						tdo_mismatch = 1;
738
739
					}
				}
740
741
742
				free(ir_buf);
			}
			break;
743

744
745
		case XCOMMENT:
			{
746
				unsigned int ndx = 0;
747
				char 	comment[128];
748

749
750
751
				do
				{
					if (read(xsvf_fd, &uc, 1) < 0)
752
					{
753
754
755
						do_abort = 1;
						break;
					}
756

757
758
					if ( ndx < sizeof(comment)-1 )
						comment[ndx++] = uc;
759

760
				} while (uc != 0);
761

762
763
764
765
766
				comment[sizeof(comment)-1] = 0;		/* regardless, terminate */
				if (verbose)
					LOG_USER(comment);
			}
			break;
767

768
769
770
771
772
		case XWAIT:
			{
				/* expected in stream:
				   XWAIT <u8 wait_state> <u8 end_state> <u32 usecs>
				*/
773

774
775
776
				u8	wait;
				u8	end;
				u8	delay_buf[4];
777

778
779
780
				tap_state_t wait_state;
				tap_state_t end_state;
				int 	delay;
781

782
783
784
785
786
787
788
				if ( read(xsvf_fd, &wait, 1) < 0
				  || read(xsvf_fd, &end, 1) < 0
				  || read(xsvf_fd, delay_buf, 4) < 0)
				{
					do_abort = 1;
					break;
				}
789

790
791
792
				wait_state = xsvf_to_tap(wait);
				end_state  = xsvf_to_tap(end);
				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
797
798
				if (runtest_requires_tck && wait_state == TAP_IDLE )
				{
					jtag_add_runtest(delay, end_state);
799
				}
800
				else
801
				{
802
803
804
805
806
807
					xsvf_add_statemove( wait_state );
					jtag_add_sleep(delay);
					xsvf_add_statemove( end_state );
				}
			}
			break;
808

809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
		case XWAITSTATE:
			{
				/* expected in stream:
				   XWAITSTATE <u8 wait_state> <u8 end_state> <u32 clock_count> <u32 usecs>
				*/

				u8  clock_buf[4];
				u8  	usecs_buf[4];
				u8	wait;
				u8	end;
				tap_state_t wait_state;
				tap_state_t end_state;
				int clock_count;
				int usecs;

				if ( read(xsvf_fd, &wait, 1) < 0
				 ||  read(xsvf_fd, &end, 1) < 0
				 ||  read(xsvf_fd, clock_buf, 4) < 0
				 ||  read(xsvf_fd, usecs_buf, 4) < 0 )
				{
					do_abort = 1;
					break;
				}
832

833
834
				wait_state = xsvf_to_tap( wait );
				end_state  = xsvf_to_tap( end );
835

836
837
				clock_count = be_to_h_u32(clock_buf);
				usecs       = be_to_h_u32(usecs_buf);
838

839
840
841
842
				LOG_DEBUG("XWAITSTATE %s %s clocks:%i usecs:%i",
					tap_state_name(wait_state),
					tap_state_name(end_state),
					clock_count, usecs);
843

844
845
846
847
848
849
850
851
852
853
				/* the following states are 'stable', meaning that they have a transition
				 * in the state diagram back to themselves.  This is necessary because we will
				 * be issuing a number of clocks in this state.  This set of allowed states is also
				 * determined by the SVF RUNTEST command's allowed states.
				 */
				if (wait_state != TAP_IRPAUSE && wait_state != TAP_DRPAUSE && wait_state != TAP_RESET && wait_state != TAP_IDLE)
				{
					LOG_ERROR("illegal XWAITSTATE wait_state: \"%s\"", tap_state_name( wait_state ));
					unsupported = 1;
				}
854

855
				xsvf_add_statemove( wait_state );
856

857
				jtag_add_clocks( clock_count );
858

859
				jtag_add_sleep( usecs );
860

861
862
863
				xsvf_add_statemove( end_state );
			}
			break;
864

865
866
867
868
869
870
		case LCOUNT:
			{
				/* expected in stream:
				   LCOUNT <u32 loop_count>
				*/
				u8  count_buf[4];
871

872
				if ( read(xsvf_fd, count_buf, 4) < 0 )
873
				{
874
875
876
					do_abort = 1;
					break;
				}
877

878
879
880
881
				loop_count = be_to_h_u32(count_buf);
				LOG_DEBUG("LCOUNT %d", loop_count);
			}
			break;
882

883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
		case LDELAY:
			{
				/* expected in stream:
				   LDELAY <u8 wait_state> <u32 clock_count> <u32 usecs_to_sleep>
				*/
				u8	state;
				u8  clock_buf[4];
				u8  usecs_buf[4];

				if ( read(xsvf_fd, &state, 1) < 0
				  || read(xsvf_fd, clock_buf, 4) < 0
				  ||	 read(xsvf_fd, usecs_buf, 4) < 0 )
				{
					do_abort = 1;
					break;
898
899
				}

900
901
902
				loop_state  = xsvf_to_tap(state);
				loop_clocks = be_to_h_u32(clock_buf);
				loop_usecs  = be_to_h_u32(usecs_buf);
903

904
905
906
				LOG_DEBUG("LDELAY %s clocks:%d usecs:%d", tap_state_name(loop_state), loop_clocks, loop_usecs);
			}
			break;
907

908
909
910
911
912
913
914
915
		/* LSDR is more like XSDRTDO than it is like XSDR.  It uses LDELAY which
		 * comes with clocks !AND! sleep requirements.
		 */
		case LSDR:
			{
				int limit = loop_count;
				int matched = 0;
				int attempt;
916

917
				LOG_DEBUG("LSDR");
918

919
920
921
922
923
924
				if ( xsvf_read_buffer(xsdrsize, xsvf_fd, dr_out_buf) != ERROR_OK
				  || xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_buf) != ERROR_OK )
				{
					do_abort = 1;
					break;
				}
925

926
927
				if (limit < 1)
					limit = 1;
928

929
930
931
				for( attempt=0; attempt<limit;  ++attempt )
				{
					scan_field_t field;
932

933
934
935
					xsvf_add_statemove( loop_state );
					jtag_add_clocks(loop_clocks);
					jtag_add_sleep(loop_usecs);
936

937
938
939
940
941
					field.tap = tap;
					field.num_bits = xsdrsize;
					field.out_value = dr_out_buf;
					field.out_mask = NULL;
					field.in_value = NULL;
942

943
944
945
946
947
948
949
950
					if (attempt > 0 && verbose)
						LOG_USER("LSDR retry %d", attempt);

					jtag_set_check_value(&field, dr_in_buf, dr_in_mask, NULL);
					if (tap == NULL)
						jtag_add_plain_dr_scan(1, &field, TAP_DRPAUSE);
					else
						jtag_add_dr_scan(1, &field, TAP_DRPAUSE);
951

952
953
954
					/* LOG_DEBUG("FLUSHING QUEUE"); */
					result = jtag_execute_queue();
					if(result == ERROR_OK)
955
					{
956
						matched = 1;
957
958
						break;
					}
959
				}
960

961
				if (!matched )
962
				{
963
964
965
966
967
968
					LOG_USER( "LSDR mismatch" );
					tdo_mismatch = 1;
					break;
				}
			}
			break;
969

970
971
972
		case XTRST:
			{
				u8	trst_mode;
973

974
975
976
977
				if (read(xsvf_fd, &trst_mode, 1) < 0)
				{
					do_abort = 1;
					break;
978
979
				}

980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
				switch( trst_mode )
				{
				case XTRST_ON:
					jtag_add_reset(1, 0);
					break;
				case XTRST_OFF:
				case XTRST_Z:
					jtag_add_reset(0, 0);
					break;
				case XTRST_ABSENT:
					break;
				default:
					LOG_ERROR( "XTRST mode argument (0x%02X) out of range", trst_mode );
					do_abort = 1;
				}
			}
			break;

		default:
			LOG_ERROR("unknown xsvf command (0x%02X)\n", uc);
			unsupported = 1;
For faster browsing, not all history is shown. View entire blame