svf.c 36.9 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*
 * Copyright (C) 2009 by Simon Qian
 * SimonQian@SimonQian.com
 *
 * 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
 */
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


/* 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".
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "svf.h"
#include "jtag.h"
36
#include "time_support.h"
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


// SVF command
typedef enum
{
	ENDDR,
	ENDIR,
	FREQUENCY,
	HDR,
	HIR,
	PIO,
	PIOMAP,
	RUNTEST,
	SDR,
	SIR,
	STATE,
	TDR,
	TIR,
	TRST,
}svf_command_t;

58
const char *svf_command_name[14] =
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
{
	"ENDDR",
	"ENDIR",
	"FREQUENCY",
	"HDR",
	"HIR",
	"PIO",
	"PIOMAP",
	"RUNTEST",
	"SDR",
	"SIR",
	"STATE",
	"TDR",
	"TIR",
	"TRST"
};

typedef enum
{
	TRST_ON,
	TRST_OFF,
	TRST_Z,
	TRST_ABSENT
}trst_mode_t;

const char *svf_trst_mode_name[4] =
{
	"ON",
	"OFF",
	"Z",
	"ABSENT"
};

92
93
94
95
typedef struct
{
	tap_state_t from;
	tap_state_t to;
96
	uint32_t num_of_moves;
97
98
99
	tap_state_t paths[8];
}svf_statemove_t;

100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
/*
 * These paths are from the SVF specification for the STATE command, to be
 * used when the STATE command only includes the final state.  The first
 * element of the path is the "from" (current) state, and the last one is
 * the "to" (target) state.
 *
 * All specified paths are the shortest ones in the JTAG spec, and are thus
 * not (!!) exact matches for the paths used elsewhere in OpenOCD.  Note
 * that PAUSE-to-PAUSE transitions all go through UPDATE and then CAPTURE,
 * which has specific effects on the various registers; they are not NOPs.
 *
 * Paths to RESET are disabled here.  As elsewhere in OpenOCD, and in XSVF
 * and many SVF implementations, we don't want to risk missing that state.
 * To get to RESET, always we ignore the current state.
 */
static const svf_statemove_t svf_statemoves[] =
116
117
118
119
120
121
{
	// from			to				num_of_moves,	paths[8]
//	{TAP_RESET,		TAP_RESET,		1,				{TAP_RESET}},
	{TAP_RESET,		TAP_IDLE,		2,				{TAP_RESET, TAP_IDLE}},
	{TAP_RESET,		TAP_DRPAUSE,	6,				{TAP_RESET, TAP_IDLE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DREXIT1, TAP_DRPAUSE}},
	{TAP_RESET,		TAP_IRPAUSE,	7,				{TAP_RESET, TAP_IDLE, TAP_DRSELECT, TAP_IRSELECT, TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE}},
122

123
124
125
126
//	{TAP_IDLE,		TAP_RESET,		4,				{TAP_IDLE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}},
	{TAP_IDLE,		TAP_IDLE,		1,				{TAP_IDLE}},
	{TAP_IDLE,		TAP_DRPAUSE,	5,				{TAP_IDLE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DREXIT1, TAP_DRPAUSE}},
	{TAP_IDLE,		TAP_IRPAUSE,	6,				{TAP_IDLE, TAP_DRSELECT, TAP_IRSELECT, TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE}},
127

128
129
130
131
//	{TAP_DRPAUSE,	TAP_RESET,		6,				{TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}},
	{TAP_DRPAUSE,	TAP_IDLE,		4,				{TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE, TAP_IDLE}},
	{TAP_DRPAUSE,	TAP_DRPAUSE,	7,				{TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DREXIT1, TAP_DRPAUSE}},
	{TAP_DRPAUSE,	TAP_IRPAUSE,	8,				{TAP_DRPAUSE, TAP_DREXIT2, TAP_DRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE}},
132

133
134
135
136
137
138
//	{TAP_IRPAUSE,	TAP_RESET,		6,				{TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_RESET}},
	{TAP_IRPAUSE,	TAP_IDLE,		4,				{TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE, TAP_IDLE}},
	{TAP_IRPAUSE,	TAP_DRPAUSE,	7,				{TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DREXIT1, TAP_DRPAUSE}},
	{TAP_IRPAUSE,	TAP_IRPAUSE,	8,				{TAP_IRPAUSE, TAP_IREXIT2, TAP_IRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_IRCAPTURE, TAP_IREXIT1, TAP_IRPAUSE}}
};

139
char *svf_tap_state_name[TAP_NUM_STATES];
140
141
142
143
144
145
146
147
148

#define XXR_TDI						(1 << 0)
#define XXR_TDO						(1 << 1)
#define XXR_MASK					(1 << 2)
#define XXR_SMASK					(1 << 3)
typedef struct
{
	int len;
	int data_mask;
zwelch's avatar
zwelch committed
149
150
151
152
	uint8_t *tdi;
	uint8_t *tdo;
	uint8_t *mask;
	uint8_t *smask;
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
}svf_xxr_para_t;

typedef struct
{
	float frequency;
	tap_state_t ir_end_state;
	tap_state_t dr_end_state;
	tap_state_t runtest_run_state;
	tap_state_t runtest_end_state;
	trst_mode_t trst_mode;

	svf_xxr_para_t hir_para;
	svf_xxr_para_t hdr_para;
	svf_xxr_para_t tir_para;
	svf_xxr_para_t tdr_para;
	svf_xxr_para_t sir_para;
	svf_xxr_para_t sdr_para;
}svf_para_t;

svf_para_t svf_para;
173
const svf_para_t svf_para_init =
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
{
//	frequency,	ir_end_state,	dr_end_state,	runtest_run_state,	runtest_end_state,	trst_mode
	0,			TAP_IDLE,		TAP_IDLE,		TAP_IDLE,			TAP_IDLE,			TRST_Z,
//	hir_para
//	{len,	data_mask,	tdi,	tdo,	mask,	smask},
	{0,		0,			NULL,	NULL,	NULL,	NULL},
//	hdr_para
//	{len,	data_mask,	tdi,	tdo,	mask,	smask},
	{0,		0,			NULL,	NULL,	NULL,	NULL},
//	tir_para
//	{len,	data_mask,	tdi,	tdo,	mask,	smask},
	{0,		0,			NULL,	NULL,	NULL,	NULL},
//	tdr_para
//	{len,	data_mask,	tdi,	tdo,	mask,	smask},
	{0,		0,			NULL,	NULL,	NULL,	NULL},
//	sir_para
//	{len,	data_mask,	tdi,	tdo,	mask,	smask},
	{0,		0,			NULL,	NULL,	NULL,	NULL},
//	sdr_para
//	{len,	data_mask,	tdi,	tdo,	mask,	smask},
	{0,		0,			NULL,	NULL,	NULL,	NULL},
};

typedef struct
{
	int line_num;		// used to record line number of the check operation
						// so more information could be printed
	int enabled;		// check is enabled or not
	int buffer_offset;	// buffer_offset to buffers
	int bit_len;		// bit length to check
}svf_check_tdo_para_t;

#define SVF_CHECK_TDO_PARA_SIZE	1024
static svf_check_tdo_para_t *svf_check_tdo_para = NULL;
static int svf_check_tdo_para_index = 0;

#define dimof(a)					(sizeof(a) / sizeof((a)[0]))

static int svf_read_command_from_file(int fd);
static int svf_check_tdo(void);
zwelch's avatar
zwelch committed
214
static int svf_add_check_para(uint8_t enabled, int buffer_offset, int bit_len);
215
216
217
218
219
220
221
222
223
224
225
static int svf_run_command(struct command_context_s *cmd_ctx, char *cmd_str);
static int handle_svf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);

static int svf_fd = 0;
static char *svf_command_buffer = NULL;
static int svf_command_buffer_size = 0;
static int svf_line_number = 1;

static jtag_tap_t *tap = NULL;

#define SVF_MAX_BUFFER_SIZE_TO_COMMIT	(4 * 1024)
zwelch's avatar
zwelch committed
226
static uint8_t *svf_tdi_buffer = NULL, *svf_tdo_buffer = NULL, *svf_mask_buffer = NULL;
227
static int svf_buffer_index = 0, svf_buffer_size = 0;
228
static int svf_quiet = 0;
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265


int svf_register_commands(struct command_context_s *cmd_ctx)
{
	register_command(cmd_ctx, NULL, "svf", handle_svf_command,
		COMMAND_EXEC, "run svf <file>");

	return ERROR_OK;
}

void svf_free_xxd_para(svf_xxr_para_t *para)
{
	if (NULL != para)
	{
		if (para->tdi != NULL)
		{
			free(para->tdi);
			para->tdi = NULL;
		}
		if (para->tdo != NULL)
		{
			free(para->tdo);
			para->tdo = NULL;
		}
		if (para->mask != NULL)
		{
			free(para->mask);
			para->mask = NULL;
		}
		if (para->smask != NULL)
		{
			free(para->smask);
			para->smask = NULL;
		}
	}
}

zwelch's avatar
zwelch committed
266
267
unsigned svf_get_mask_u32(int bitlen)
{
268
	uint32_t bitmask;
zwelch's avatar
zwelch committed
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285

	if (bitlen < 0)
	{
		bitmask = 0;
	}
	else if (bitlen >= 32)
	{
		bitmask = 0xFFFFFFFF;
	}
	else
	{
		bitmask = (1 << bitlen) - 1;
	}

	return bitmask;
}

286
287
288
289
static const char* tap_state_svf_name(tap_state_t state)
{
	const char* ret;

290
	switch (state)
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
	{
	case TAP_RESET:		ret = "RESET";		break;
	case TAP_IDLE:		ret = "IDLE";		break;
	case TAP_DRSELECT:	ret = "DRSELECT";	break;
	case TAP_DRCAPTURE: ret = "DRCAPTURE";	break;
	case TAP_DRSHIFT:	ret = "DRSHIFT";	break;
	case TAP_DREXIT1:	ret = "DREXIT1";	break;
	case TAP_DRPAUSE:	ret = "DRPAUSE";	break;
	case TAP_DREXIT2:	ret = "DREXIT2";	break;
	case TAP_DRUPDATE:	ret = "DRUPDATE";	break;
	case TAP_IRSELECT:	ret = "IRSELECT";	break;
	case TAP_IRCAPTURE: ret = "IRCAPTURE";	break;
	case TAP_IRSHIFT:	ret = "IRSHIFT";	break;
	case TAP_IREXIT1:	ret = "IREXIT1";	break;
	case TAP_IRPAUSE:	ret = "IRPAUSE";	break;
	case TAP_IREXIT2:	ret = "IREXIT2";	break;
	case TAP_IRUPDATE:	ret = "IRUPDATE";	break;
	default:			ret = "???";		break;
	}

	return ret;
}

314
315
316
static int svf_add_statemove(tap_state_t state_to)
{
	tap_state_t state_from = cmd_queue_cur_state;
zwelch's avatar
zwelch committed
317
	uint8_t index;
318
319
320

	for (index = 0; index < dimof(svf_statemoves); index++)
	{
321
		if ((svf_statemoves[index].from == state_from)
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
			&& (svf_statemoves[index].to == state_to))
		{
			if (TAP_RESET == state_from)
			{
				jtag_add_tlr();
				if (svf_statemoves[index].num_of_moves > 1)
				{
					jtag_add_pathmove(svf_statemoves[index].num_of_moves - 1, svf_statemoves[index].paths + 1);
				}
			}
			else
			{
				if (svf_statemoves[index].num_of_moves > 0)
				{
					jtag_add_pathmove(svf_statemoves[index].num_of_moves, svf_statemoves[index].paths);
				}
			}
			return ERROR_OK;
		}
	}
	LOG_ERROR("can not move to %s", tap_state_svf_name(state_to));
	return ERROR_FAIL;
}

346
347
static int handle_svf_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
348
#define SVF_NUM_OF_OPTIONS			1
349
350
	int command_num = 0, i;
	int ret = ERROR_OK;
351
	long long time_ago;
352

353
	if ((argc < 1) || (argc > (1 + SVF_NUM_OF_OPTIONS)))
354
	{
355
		command_print(cmd_ctx, "usage: svf <file> [quiet]");
356
357
358
		return ERROR_FAIL;
	}

359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
	// parse variant
	svf_quiet = 0;
	for (i = 1; i < argc; i++)
	{
		if (!strcmp(args[i], "quiet"))
		{
			svf_quiet = 1;
		}
		else
		{
			LOG_ERROR("unknown variant for svf: %s", args[i]);

			// no need to free anything now
			return ERROR_FAIL;
		}
	}

376
377
378
	if ((svf_fd = open(args[0], O_RDONLY)) < 0)
	{
		command_print(cmd_ctx, "file \"%s\" not found", args[0]);
379
380

		// no need to free anything now
381
382
383
384
385
		return ERROR_FAIL;
	}

	LOG_USER("svf processing file: \"%s\"", args[0]);

386
387
388
	// get time
	time_ago = timeval_ms();

389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
	// init
	svf_line_number = 1;
	svf_command_buffer_size = 0;

	svf_check_tdo_para_index = 0;
	svf_check_tdo_para = malloc(sizeof(svf_check_tdo_para_t) * SVF_CHECK_TDO_PARA_SIZE);
	if (NULL == svf_check_tdo_para)
	{
		LOG_ERROR("not enough memory");
		ret = ERROR_FAIL;
		goto free_all;
	}

	svf_buffer_index = 0;
	// double the buffer size
	// in case current command cannot be commited, and next command is a bit scan command
	// here is 32K bits for this big scan command, it should be enough
	// buffer will be reallocated if buffer size is not enough
zwelch's avatar
zwelch committed
407
	svf_tdi_buffer = (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
408
409
410
411
412
413
	if (NULL == svf_tdi_buffer)
	{
		LOG_ERROR("not enough memory");
		ret = ERROR_FAIL;
		goto free_all;
	}
zwelch's avatar
zwelch committed
414
	svf_tdo_buffer = (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
415
416
417
418
419
420
	if (NULL == svf_tdo_buffer)
	{
		LOG_ERROR("not enough memory");
		ret = ERROR_FAIL;
		goto free_all;
	}
zwelch's avatar
zwelch committed
421
	svf_mask_buffer = (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
422
423
424
425
426
427
428
429
430
	if (NULL == svf_mask_buffer)
	{
		LOG_ERROR("not enough memory");
		ret = ERROR_FAIL;
		goto free_all;
	}
	svf_buffer_size = 2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT;

	memcpy(&svf_para, &svf_para_init, sizeof(svf_para));
431
	for (i = 0; i < (int)dimof(svf_tap_state_name); i++)
432
	{
433
		svf_tap_state_name[i] = (char *)tap_state_svf_name(i);
434
	}
435

436
437
438
	// TAP_RESET
	jtag_add_tlr();

439
	while (ERROR_OK == svf_read_command_from_file(svf_fd))
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
	{
		if (ERROR_OK != svf_run_command(cmd_ctx, svf_command_buffer))
		{
			LOG_ERROR("fail to run command at line %d", svf_line_number);
			ret = ERROR_FAIL;
			break;
		}
		command_num++;
	}
	if (ERROR_OK != jtag_execute_queue())
	{
		ret = ERROR_FAIL;
	}
	else if (ERROR_OK != svf_check_tdo())
	{
		ret = ERROR_FAIL;
	}

458
	// print time
459
	command_print(cmd_ctx, "%lld ms used", timeval_ms() - time_ago);
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
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
free_all:

	close(svf_fd);
	svf_fd = 0;

	// free buffers
	if (svf_command_buffer)
	{
		free(svf_command_buffer);
		svf_command_buffer = NULL;
		svf_command_buffer_size = 0;
	}
	if (svf_check_tdo_para)
	{
		free(svf_check_tdo_para);
		svf_check_tdo_para = NULL;
		svf_check_tdo_para_index = 0;
	}
	if (svf_tdi_buffer)
	{
		free(svf_tdi_buffer);
		svf_tdi_buffer = NULL;
	}
	if (svf_tdo_buffer)
	{
		free(svf_tdo_buffer);
		svf_tdo_buffer = NULL;
	}
	if (svf_mask_buffer)
	{
		free(svf_mask_buffer);
		svf_mask_buffer = NULL;
	}
	svf_buffer_index = 0;
	svf_buffer_size = 0;

	svf_free_xxd_para(&svf_para.hdr_para);
	svf_free_xxd_para(&svf_para.hir_para);
	svf_free_xxd_para(&svf_para.tdr_para);
	svf_free_xxd_para(&svf_para.tir_para);
	svf_free_xxd_para(&svf_para.sdr_para);
	svf_free_xxd_para(&svf_para.sir_para);

	if (ERROR_OK == ret)
	{
		command_print(cmd_ctx, "svf file programmed successfully for %d commands", command_num);
	}
	else
	{
		command_print(cmd_ctx, "svf file programmed failed");
	}

	return ret;
}

#define SVFP_CMD_INC_CNT			1024
static int svf_read_command_from_file(int fd)
{
	char ch, *tmp_buffer = NULL;
	int cmd_pos = 0, cmd_ok = 0, slash = 0, comment = 0;

522
	while (!cmd_ok && (read(fd, &ch, 1) > 0))
523
	{
zwelch's avatar
zwelch committed
524
		switch (ch)
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
		{
		case '!':
			slash = 0;
			comment = 1;
			break;
		case '/':
			if (++slash == 2)
			{
				comment = 1;
			}
			break;
		case ';':
			slash = 0;
			if (!comment)
			{
				cmd_ok = 1;
			}
			break;
		case '\n':
			svf_line_number++;
		case '\r':
			slash = 0;
			comment = 0;
			break;
		default:
			if (!comment)
			{
				if (cmd_pos >= svf_command_buffer_size - 1)
				{
					tmp_buffer = (char*)malloc(svf_command_buffer_size + SVFP_CMD_INC_CNT);		// 1 more byte for '\0'
					if (NULL == tmp_buffer)
					{
						LOG_ERROR("not enough memory");
						return ERROR_FAIL;
					}
					if (svf_command_buffer_size > 0)
					{
						memcpy(tmp_buffer, svf_command_buffer, svf_command_buffer_size);
					}
					if (svf_command_buffer != NULL)
					{
						free(svf_command_buffer);
					}
					svf_command_buffer = tmp_buffer;
					svf_command_buffer_size += SVFP_CMD_INC_CNT;
					tmp_buffer = NULL;
				}
				svf_command_buffer[cmd_pos++] = (char)toupper(ch);
			}
			break;
		}
	}

	if (cmd_ok)
	{
		svf_command_buffer[cmd_pos] = '\0';
		return ERROR_OK;
	}
	else
	{
		return ERROR_FAIL;
	}
}

static int svf_parse_cmd_string(char *str, int len, char **argus, int *num_of_argu)
{
	int pos = 0, num = 0, space_found = 1;

	while (pos < len)
	{
zwelch's avatar
zwelch committed
595
		switch (str[pos])
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
		{
		case '\n':
		case '\r':
		case '!':
		case '/':
			LOG_ERROR("fail to parse svf command");
			return ERROR_FAIL;
			break;
		case ' ':
			space_found = 1;
			str[pos] = '\0';
			break;
		default:
			if (space_found)
			{
				argus[num++] = &str[pos];
				space_found = 0;
			}
			break;
		}
		pos++;
	}

	*num_of_argu = num;

	return ERROR_OK;
}

static int svf_tap_state_is_stable(tap_state_t state)
{
	return ((TAP_RESET == state) || (TAP_IDLE == state) || (TAP_DRPAUSE == state) || (TAP_IRPAUSE == state));
}

static int svf_tap_state_is_valid(tap_state_t state)
{
631
	return state >= 0 && state < TAP_NUM_STATES;
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
}

static int svf_find_string_in_array(char *str, char **strs, int num_of_element)
{
	int i;

	for (i = 0; i < num_of_element; i++)
	{
		if (!strcmp(str, strs[i]))
		{
			return i;
		}
	}
	return 0xFF;
}

zwelch's avatar
zwelch committed
648
static int svf_adjust_array_length(uint8_t **arr, int orig_bit_len, int new_bit_len)
649
650
651
652
653
654
655
656
657
658
{
	int new_byte_len = (new_bit_len + 7) >> 3;

	if ((NULL == *arr) || (((orig_bit_len + 7) >> 3) < ((new_bit_len + 7) >> 3)))
	{
		if (*arr != NULL)
		{
			free(*arr);
			*arr = NULL;
		}
zwelch's avatar
zwelch committed
659
		*arr = (uint8_t*)malloc(new_byte_len);
660
661
662
663
664
665
666
667
668
669
		if (NULL == *arr)
		{
			LOG_ERROR("not enough memory");
			return ERROR_FAIL;
		}
		memset(*arr, 0, new_byte_len);
	}
	return ERROR_OK;
}

zwelch's avatar
zwelch committed
670
static int svf_copy_hexstring_to_binary(char *str, uint8_t **bin, int orig_bit_len, int bit_len)
671
{
672
	int i, str_len = strlen(str), str_hbyte_len = (bit_len + 3) >> 2;
673
	uint8_t ch = 0;
674
675
676
677
678
679
680

	if (ERROR_OK != svf_adjust_array_length(bin, orig_bit_len, bit_len))
	{
		LOG_ERROR("fail to adjust length of array");
		return ERROR_FAIL;
	}

681
	for (i = 0; i < str_hbyte_len; i++)
682
	{
683
684
		ch = 0;
		while (str_len > 0)
685
		{
686
687
688
			ch = str[--str_len];

			if (!isblank(ch))
689
			{
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
				if ((ch >= '0') && (ch <= '9'))
				{
					ch = ch - '0';
					break;
				}
				else if ((ch >= 'A') && (ch <= 'F'))
				{
					ch = ch - 'A' + 10;
					break;
				}
				else
				{
					LOG_ERROR("invalid hex string");
					return ERROR_FAIL;
				}
705
			}
706

707
708
709
			ch = 0;
		}

710
711
		// write bin
		if (i % 2)
712
		{
713
714
			// MSB
			(*bin)[i / 2] |= ch << 4;
715
		}
716
		else
717
		{
718
719
720
			// LSB
			(*bin)[i / 2] = 0;
			(*bin)[i / 2] |= ch;
721
		}
722
	}
723

724
725
726
727
728
	// check valid
	if (str_len > 0 || (ch & ~((1 << (4 - (bit_len % 4))) - 1)) != 0)
	{
		LOG_ERROR("value execede length");
		return ERROR_FAIL;
729
730
731
732
733
734
735
	}

	return ERROR_OK;
}

static int svf_check_tdo(void)
{
zwelch's avatar
zwelch committed
736
	int i, len, index;
737
738
739

	for (i = 0; i < svf_check_tdo_para_index; i++)
	{
zwelch's avatar
zwelch committed
740
741
		index = svf_check_tdo_para[i].buffer_offset;
		len = svf_check_tdo_para[i].bit_len;
742
		if ((svf_check_tdo_para[i].enabled)
zwelch's avatar
zwelch committed
743
			&& buf_cmp_mask(&svf_tdi_buffer[index], &svf_tdo_buffer[index], &svf_mask_buffer[index], len))
744
		{
zwelch's avatar
zwelch committed
745
746
			unsigned bitmask;
			unsigned received, expected, tapmask;
zwelch's avatar
zwelch committed
747
748
			bitmask = svf_get_mask_u32(svf_check_tdo_para[i].bit_len);

zwelch's avatar
zwelch committed
749
750
751
			memcpy(&received, svf_tdi_buffer + index, sizeof(unsigned));
			memcpy(&expected, svf_tdo_buffer + index, sizeof(unsigned));
			memcpy(&tapmask, svf_mask_buffer + index, sizeof(unsigned));
752
			LOG_ERROR("tdo check error at line %d",
zwelch's avatar
zwelch committed
753
					  svf_check_tdo_para[i].line_num);
754
755
756
			LOG_ERROR("read = 0x%X, want = 0x%X, mask = 0x%X",
					  received & bitmask,
					  expected & bitmask,
zwelch's avatar
zwelch committed
757
758
					  tapmask & bitmask);
			return ERROR_FAIL;
759
760
761
762
763
764
765
		}
	}
	svf_check_tdo_para_index = 0;

	return ERROR_OK;
}

zwelch's avatar
zwelch committed
766
static int svf_add_check_para(uint8_t enabled, int buffer_offset, int bit_len)
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
{
	if (svf_check_tdo_para_index >= SVF_CHECK_TDO_PARA_SIZE)
	{
		LOG_ERROR("toooooo many operation undone");
		return ERROR_FAIL;
	}

	svf_check_tdo_para[svf_check_tdo_para_index].line_num = svf_line_number;
	svf_check_tdo_para[svf_check_tdo_para_index].bit_len = bit_len;
	svf_check_tdo_para[svf_check_tdo_para_index].enabled = enabled;
	svf_check_tdo_para[svf_check_tdo_para_index].buffer_offset = buffer_offset;
	svf_check_tdo_para_index++;

	return ERROR_OK;
}

783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
static int svf_execute_tap(void)
{
	if (ERROR_OK != jtag_execute_queue())
	{
		return ERROR_FAIL;
	}
	else if (ERROR_OK != svf_check_tdo())
	{
		return ERROR_FAIL;
	}

	svf_buffer_index = 0;

	return ERROR_OK;
}

799
800
801
802
803
804
805
806
807
808
809
810
811
static int svf_run_command(struct command_context_s *cmd_ctx, char *cmd_str)
{
	char *argus[256], command;
	int num_of_argu = 0, i;

	// tmp variable
	int i_tmp;

	// for RUNTEST
	int run_count;
	float min_time, max_time;
	// for XXR
	svf_xxr_para_t *xxr_para_tmp;
zwelch's avatar
zwelch committed
812
	uint8_t **pbuffer_tmp;
813
814
815
816
	scan_field_t field;
	// for STATE
	tap_state_t *path = NULL, state;

817
818
819
820
	if (!svf_quiet)
	{
		LOG_USER("%s", svf_command_buffer);
	}
821
822
823
824
825
826
827

	if (ERROR_OK != svf_parse_cmd_string(cmd_str, strlen(cmd_str), argus, &num_of_argu))
	{
		return ERROR_FAIL;
	}

	command = svf_find_string_in_array(argus[0], (char **)svf_command_name, dimof(svf_command_name));
zwelch's avatar
zwelch committed
828
	switch (command)
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
	{
	case ENDDR:
	case ENDIR:
		if (num_of_argu != 2)
		{
			LOG_ERROR("invalid parameter of %s", argus[0]);
			return ERROR_FAIL;
		}
		i_tmp = svf_find_string_in_array(argus[1], (char **)svf_tap_state_name, dimof(svf_tap_state_name));
		if (svf_tap_state_is_stable(i_tmp))
		{
			if (command == ENDIR)
			{
				svf_para.ir_end_state = i_tmp;
				LOG_DEBUG("\tir_end_state = %s", svf_tap_state_name[svf_para.ir_end_state]);
			}
			else
			{
				svf_para.dr_end_state = i_tmp;
				LOG_DEBUG("\tdr_end_state = %s", svf_tap_state_name[svf_para.dr_end_state]);
			}
		}
		else
		{
			LOG_ERROR("%s is not valid state", argus[1]);
			return ERROR_FAIL;
		}
		break;
	case FREQUENCY:
		if ((num_of_argu != 1) && (num_of_argu != 3))
		{
			LOG_ERROR("invalid parameter of %s", argus[0]);
			return ERROR_FAIL;
		}
		if (1 == num_of_argu)
		{
			// TODO: set jtag speed to full speed
			svf_para.frequency = 0;
		}
		else
		{
			if (strcmp(argus[2], "HZ"))
			{
				LOG_ERROR("HZ not found in FREQUENCY command");
				return ERROR_FAIL;
			}
875
876
877
878
			if (ERROR_OK != svf_execute_tap())
			{
				return ERROR_FAIL;
			}
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
			svf_para.frequency = atof(argus[1]);
			// TODO: set jtag speed to
			if (svf_para.frequency > 0)
			{
				command_run_linef(cmd_ctx, "jtag_khz %d", (int)svf_para.frequency / 1000);
				LOG_DEBUG("\tfrequency = %f", svf_para.frequency);
			}
		}
		break;
	case HDR:
		xxr_para_tmp = &svf_para.hdr_para;
		goto XXR_common;
	case HIR:
		xxr_para_tmp = &svf_para.hir_para;
		goto XXR_common;
	case TDR:
		xxr_para_tmp = &svf_para.tdr_para;
		goto XXR_common;
	case TIR:
		xxr_para_tmp = &svf_para.tir_para;
		goto XXR_common;
	case SDR:
		xxr_para_tmp = &svf_para.sdr_para;
		goto XXR_common;
	case SIR:
		xxr_para_tmp = &svf_para.sir_para;
		goto XXR_common;
		XXR_common:
		// XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)]
		if ((num_of_argu > 10) || (num_of_argu % 2))
		{
			LOG_ERROR("invalid parameter of %s", argus[0]);
			return ERROR_FAIL;
		}
		i_tmp = xxr_para_tmp->len;
		xxr_para_tmp->len = atoi(argus[1]);
		LOG_DEBUG("\tlength = %d", xxr_para_tmp->len);
		xxr_para_tmp->data_mask = 0;
		for (i = 2; i < num_of_argu; i += 2)
		{
919
			if ((strlen(argus[i + 1]) < 3) || (argus[i + 1][0] != '(') || (argus[i + 1][strlen(argus[i + 1]) - 1] != ')'))
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
			{
				LOG_ERROR("data section error");
				return ERROR_FAIL;
			}
			argus[i + 1][strlen(argus[i + 1]) - 1] = '\0';
			// TDI, TDO, MASK, SMASK
			if (!strcmp(argus[i], "TDI"))
			{
				// TDI
				pbuffer_tmp = &xxr_para_tmp->tdi;
				xxr_para_tmp->data_mask |= XXR_TDI;
			}
			else if (!strcmp(argus[i], "TDO"))
			{
				// TDO
				pbuffer_tmp = &xxr_para_tmp->tdo;
				xxr_para_tmp->data_mask |= XXR_TDO;
			}
			else if (!strcmp(argus[i], "MASK"))
			{
				// MASK
				pbuffer_tmp = &xxr_para_tmp->mask;
				xxr_para_tmp->data_mask |= XXR_MASK;
			}
			else if (!strcmp(argus[i], "SMASK"))
			{
				// SMASK
				pbuffer_tmp = &xxr_para_tmp->smask;
				xxr_para_tmp->data_mask |= XXR_SMASK;
			}
			else
			{
				LOG_ERROR("unknow parameter: %s", argus[i]);
				return ERROR_FAIL;
			}
			if (ERROR_OK != svf_copy_hexstring_to_binary(&argus[i + 1][1], pbuffer_tmp, i_tmp, xxr_para_tmp->len))
			{
				LOG_ERROR("fail to parse hex value");
				return ERROR_FAIL;
			}
zwelch's avatar
zwelch committed
960
			LOG_DEBUG("\t%s = 0x%X", argus[i], (**(int**)pbuffer_tmp) & svf_get_mask_u32(xxr_para_tmp->len));
961
		}
962
		// If a command changes the length of the last scan of the same type and the MASK parameter is absent,
963
964
965
966
967
968
969
970
971
972
973
		// the mask pattern used is all cares
		if (!(xxr_para_tmp->data_mask & XXR_MASK) && (i_tmp != xxr_para_tmp->len))
		{
			// MASK not defined and length changed
			if (ERROR_OK != svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp, xxr_para_tmp->len))
			{
				LOG_ERROR("fail to adjust length of array");
				return ERROR_FAIL;
			}
			buf_set_ones(xxr_para_tmp->mask, xxr_para_tmp->len);
		}
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
		// If TDO is absent, no comparison is needed, set the mask to 0
		if (!(xxr_para_tmp->data_mask & XXR_TDO))
		{
			if (NULL == xxr_para_tmp->tdo)
			{
				if (ERROR_OK != svf_adjust_array_length(&xxr_para_tmp->tdo, i_tmp, xxr_para_tmp->len))
				{
					LOG_ERROR("fail to adjust length of array");
					return ERROR_FAIL;
				}
			}
			if (NULL == xxr_para_tmp->mask)
			{
				if (ERROR_OK != svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp, xxr_para_tmp->len))
				{
					LOG_ERROR("fail to adjust length of array");
					return ERROR_FAIL;
				}
			}
			memset(xxr_para_tmp->mask, 0, (xxr_para_tmp->len + 7) >> 3);
		}
995
996
997
998
999
1000
		// do scan if necessary
		if (SDR == command)
		{
			// check buffer size first, reallocate if necessary
			i = svf_para.hdr_para.len + svf_para.sdr_para.len + svf_para.tdr_para.len;
			if ((svf_buffer_size - svf_buffer_index) < ((i + 7) >> 3))
For faster browsing, not all history is shown. View entire blame