jtag.c 75 KB
Newer Older
1
2
3
4
/***************************************************************************
 *   Copyright (C) 2005 by Dominic Rath                                    *
 *   Dominic.Rath@gmx.de                                                   *
 *                                                                         *
5
 *   Copyright (C) 2007,2008 yvind Harboe                                 *
6
7
 *   oyvind.harboe@zylin.com                                               *
 *                                                                         *
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 *   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.             *
 ***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "replacements.h"

#include "jtag.h"

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

#include "stdlib.h"
#include "string.h"
#include <unistd.h>

38
39
/* note that this is not marked as static as it must be available from outside jtag.c for those
   that implement the jtag_xxx() minidriver layer
oharboe's avatar
oharboe committed
40
*/
41
int jtag_error=ERROR_OK;
oharboe's avatar
oharboe committed
42
43


44
45
char* tap_state_strings[16] =
{
46
	"tlr",
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
	"sds", "cd", "sd", "e1d", "pd", "e2d", "ud",
	"rti",
	"sis", "ci", "si", "e1i", "pi", "e2i", "ui"
};

typedef struct cmd_queue_page_s
{
	void *address;
	size_t used;
	struct cmd_queue_page_s *next;
} cmd_queue_page_t;

#define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
static cmd_queue_page_t *cmd_queue_pages = NULL;

/* tap_move[i][j]: tap movement command to go from state i to state j
 * 0: Test-Logic-Reset
 * 1: Run-Test/Idle
 * 2: Shift-DR
 * 3: Pause-DR
 * 4: Shift-IR
 * 5: Pause-IR
69
 *
70
 * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code
71
72
73
 */
u8 tap_move[6][6] =
{
74
75
76
77
78
79
80
/*	  RESET  IDLE  DRSHIFT  DRPAUSE  IRSHIFT  IRPAUSE             */
	{  0x7f, 0x00,    0x17,    0x0a,    0x1b,    0x16},	/* RESET */
	{  0x7f, 0x00,    0x25,    0x05,    0x2b,    0x0b},	/* IDLE */
	{  0x7f, 0x31,    0x00,    0x01,    0x0f,    0x2f},	/* DRSHIFT  */
	{  0x7f, 0x30,    0x20,    0x17,    0x1e,    0x2f},	/* DRPAUSE  */
	{  0x7f, 0x31,    0x07,    0x17,    0x00,    0x01},	/* IRSHIFT  */
	{  0x7f, 0x30,    0x1c,    0x17,    0x20,    0x2f}	/* IRPAUSE  */
81
82
83
84
85
86
87
88
89
};

int tap_move_map[16] = {
	0, -1, -1,  2, -1,  3, -1, -1,
	1, -1, -1,  4, -1,  5, -1, -1
};

tap_transition_t tap_transitions[16] =
{
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
	{TAP_RESET, TAP_IDLE},		/* RESET */
	{TAP_IRSELECT, TAP_DRCAPTURE},		/* DRSELECT */
	{TAP_DREXIT1, TAP_DRSHIFT},		/* DRCAPTURE  */
	{TAP_DREXIT1, TAP_DRSHIFT},		/* DRSHIFT  */
	{TAP_DRUPDATE,  TAP_DRPAUSE}, 		/* DREXIT1 */
	{TAP_DREXIT2, TAP_DRPAUSE},		/* DRPAUSE  */
	{TAP_DRUPDATE,  TAP_DRSHIFT},		/* DREXIT2 */
	{TAP_DRSELECT, TAP_IDLE},		/* DRUPDATE  */
	{TAP_DRSELECT, TAP_IDLE},		/* IDLE */
	{TAP_RESET, TAP_IRCAPTURE},		/* IRSELECT */
	{TAP_IREXIT1, TAP_IRSHIFT},		/* IRCAPTURE  */
	{TAP_IREXIT1, TAP_IRSHIFT},		/* IRSHIFT  */
	{TAP_IRUPDATE,  TAP_IRPAUSE}, 		/* IREXIT1 */
	{TAP_IREXIT2, TAP_IRPAUSE},		/* IRPAUSE  */
	{TAP_IRUPDATE,  TAP_IRSHIFT},		/* IREXIT2 */
	{TAP_DRSELECT, TAP_IDLE}		/* IRUPDATE  */
106
107
108
109
};

char* jtag_event_strings[] =
{
110
	"JTAG controller reset (RESET or TRST)"
111
112
};

113
114
115
116
117
118
119
const Jim_Nvp nvp_jtag_tap_event[] = {
	{ .value = JTAG_TAP_EVENT_ENABLE,       .name = "tap-enable" },
	{ .value = JTAG_TAP_EVENT_DISABLE,      .name = "tap-disable" },

	{ .name = NULL, .value = -1 }
};

120
121
122
123
124
/* kludge!!!! these are just global variables that the
 * interface use internally. They really belong
 * inside the drivers, but we don't want to break
 * linking the drivers!!!!
 */
125
126
enum tap_state end_state = TAP_RESET;
enum tap_state cur_state = TAP_RESET;
127
128
129
130
131
int jtag_trst = 0;
int jtag_srst = 0;

jtag_command_t *jtag_command_queue = NULL;
jtag_command_t **last_comand_pointer = &jtag_command_queue;
132
133
static jtag_tap_t *jtag_all_taps = NULL;

134
enum reset_types jtag_reset_config = RESET_NONE;
135
136
enum tap_state cmd_queue_end_state = TAP_RESET;
enum tap_state cmd_queue_cur_state = TAP_RESET;
137
138
139
140
141

int jtag_verify_capture_ir = 1;

/* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
int jtag_nsrst_delay = 0; /* default to no nSRST delay */
142
int jtag_ntrst_delay = 0; /* default to no nTRST delay */
143
144
145

/* maximum number of JTAG devices expected in the chain
 */
146
#define JTAG_MAX_CHAIN_SIZE 20
147
148
149
150

/* callbacks to inform high-level handlers about JTAG state changes */
jtag_event_callback_t *jtag_event_callbacks;

oharboe's avatar
   
oharboe committed
151
/* speed in kHz*/
oharboe's avatar
   
oharboe committed
152
static int speed_khz = 0;
oharboe's avatar
   
oharboe committed
153
154
155
/* flag if the kHz speed was defined */
static int hasKHz = 0;

156
157
/* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
 */
158

159
#if BUILD_ECOSBOARD == 1
160
	extern jtag_interface_t zy1000_interface;
161
#endif
162

163
164
165
#if BUILD_PARPORT == 1
	extern jtag_interface_t parport_interface;
#endif
166

167
168
169
#if BUILD_DUMMY == 1
	extern jtag_interface_t dummy_interface;
#endif
170

171
172
173
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
#if BUILD_FT2232_FTD2XX == 1
	extern jtag_interface_t ft2232_interface;
#endif

#if BUILD_FT2232_LIBFTDI == 1
	extern jtag_interface_t ft2232_interface;
#endif

#if BUILD_AMTJTAGACCEL == 1
	extern jtag_interface_t amt_jtagaccel_interface;
#endif

#if BUILD_EP93XX == 1
	extern jtag_interface_t ep93xx_interface;
#endif

#if BUILD_AT91RM9200 == 1
	extern jtag_interface_t at91rm9200_interface;
#endif

#if BUILD_GW16012 == 1
	extern jtag_interface_t gw16012_interface;
#endif

#if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
	extern jtag_interface_t presto_interface;
#endif

#if BUILD_USBPROG == 1
	extern jtag_interface_t usbprog_interface;
#endif

203
204
205
206
#if BUILD_JLINK == 1
	extern jtag_interface_t jlink_interface;
#endif

207
jtag_interface_t *jtag_interfaces[] = {
208
#if BUILD_ECOSBOARD == 1
209
	&zy1000_interface,
210
#endif
211
212
213
#if BUILD_PARPORT == 1
	&parport_interface,
#endif
214
215
216
#if BUILD_DUMMY == 1
	&dummy_interface,
#endif
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
#if BUILD_FT2232_FTD2XX == 1
	&ft2232_interface,
#endif
#if BUILD_FT2232_LIBFTDI == 1
	&ft2232_interface,
#endif
#if BUILD_AMTJTAGACCEL == 1
	&amt_jtagaccel_interface,
#endif
#if BUILD_EP93XX == 1
	&ep93xx_interface,
#endif
#if BUILD_AT91RM9200 == 1
	&at91rm9200_interface,
#endif
#if BUILD_GW16012 == 1
	&gw16012_interface,
#endif
#if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
	&presto_interface,
#endif
#if BUILD_USBPROG == 1
	&usbprog_interface,
240
241
242
#endif
#if BUILD_JLINK == 1
	&jlink_interface,
243
244
245
246
247
248
249
250
251
#endif
	NULL,
};

jtag_interface_t *jtag = NULL;

/* configuration */
jtag_interface_t *jtag_interface = NULL;
int jtag_speed = 0;
oharboe's avatar
   
oharboe committed
252

253
254
255


/* forward declarations */
256
257
258
259
void jtag_add_pathmove(int num_states, enum tap_state *path);
void jtag_add_runtest(int num_cycles, enum tap_state endstate);
void jtag_add_end_state(enum tap_state endstate);
void jtag_add_sleep(u32 us);
260
int jtag_execute_queue(void);
261

262
263
264
265

/* jtag commands */
int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
266
int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
267
268
269
270
271
272
273
274
275
276
277
int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);

int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);

int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
oharboe's avatar
oharboe committed
278
int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
279
280
281

int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);

282

oharboe's avatar
oharboe committed
283
284
285
jtag_tap_t *jtag_AllTaps(void)
{
  return jtag_all_taps;
286
287
};

oharboe's avatar
oharboe committed
288
int
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
jtag_NumTotalTaps(void)
{
	jtag_tap_t *t;
	int n;

	n = 0;
	t = jtag_AllTaps();
	while(t){
		n++;
		t = t->next_tap;
	}
	return n;
}

int
jtag_NumEnabledTaps(void)
{
	jtag_tap_t *t;
	int n;

	n = 0;
	t = jtag_AllTaps();
	while(t){
		if( t->enabled ){
			n++;
		}
		t = t->next_tap;
	}
	return n;
}


jtag_tap_t *jtag_TapByString( const char *s )
{
	jtag_tap_t *t;
	char *cp;

	t = jtag_AllTaps();
	// try name first
	while(t){
		if( 0 == strcmp( t->dotted_name, s ) ){
			break;
		} else {
			t = t->next_tap;
		}
	}
	// backup plan is by number
	if( t == NULL ){
		/* ok - is "s" a number? */
		int n;
		n = strtol( s, &cp, 0 );
		if( (s != cp) && (*cp == 0) ){
			/* Then it is... */
			t = jtag_TapByAbsPosition(n);
		}
	}
	return t;
}

jtag_tap_t *
jtag_TapByJimObj( Jim_Interp *interp, Jim_Obj *o )
{
	jtag_tap_t *t;
	const char *cp;

	cp = Jim_GetString( o, NULL );
	if(cp == NULL){
		cp = "(unknown)";
		t = NULL;
	}  else {
		t = jtag_TapByString( cp );
oharboe's avatar
oharboe committed
360
	}
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
	if( t == NULL ){
		Jim_SetResult_sprintf(interp,"Tap: %s is unknown", cp );
	}
	return t;
}

/* returns a pointer to the n-th device in the scan chain */
jtag_tap_t *
jtag_TapByAbsPosition( int n )
{
	int orig_n;
	jtag_tap_t *t;

	orig_n = n;
	t = jtag_AllTaps();
oharboe's avatar
oharboe committed
376

377
378
379
380
381
382
383
384
	while( t && (n > 0)) {
		n--;
		t = t->next_tap;
    }
	return t;
}


385
386
387
int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
{
	jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
388

389
390
391
392
	if (callback == NULL)
	{
		return ERROR_INVALID_ARGUMENTS;
	}
393

394
395
396
397
398
399
	if (*callbacks_p)
	{
		while ((*callbacks_p)->next)
			callbacks_p = &((*callbacks_p)->next);
		callbacks_p = &((*callbacks_p)->next);
	}
400

401
402
403
404
	(*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
	(*callbacks_p)->callback = callback;
	(*callbacks_p)->priv = priv;
	(*callbacks_p)->next = NULL;
405

406
407
408
409
410
411
	return ERROR_OK;
}

int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
{
	jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
412

413
414
415
416
	if (callback == NULL)
	{
		return ERROR_INVALID_ARGUMENTS;
	}
417

418
419
420
421
422
423
424
425
426
427
	while (*callbacks_p)
	{
		jtag_event_callback_t **next = &((*callbacks_p)->next);
		if ((*callbacks_p)->callback == callback)
		{
			free(*callbacks_p);
			*callbacks_p = *next;
		}
		callbacks_p = next;
	}
428

429
430
431
432
433
434
	return ERROR_OK;
}

int jtag_call_event_callbacks(enum jtag_event event)
{
	jtag_event_callback_t *callback = jtag_event_callbacks;
435

436
	LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
437

438
439
440
441
442
	while (callback)
	{
		callback->callback(event, callback->priv);
		callback = callback->next;
	}
443

444
445
446
447
448
449
450
451
452
453
	return ERROR_OK;
}

/* returns a pointer to the pointer of the last command in queue
 * this may be a pointer to the root pointer (jtag_command_queue)
 * or to the next member of the last but one command
 */
jtag_command_t** jtag_get_last_command_p(void)
{
/*	jtag_command_t *cmd = jtag_command_queue;
454

455
456
457
458
459
	if (cmd)
		while (cmd->next)
			cmd = cmd->next;
	else
		return &jtag_command_queue;
460

461
	return &cmd->next;*/
462

463
464
465
466
467
468
469
470
	return last_comand_pointer;
}


void* cmd_queue_alloc(size_t size)
{
	cmd_queue_page_t **p_page = &cmd_queue_pages;
	int offset;
oharboe's avatar
oharboe committed
471
	u8 *t;
472

473
474
475
476
477
478
479
480
481
482
483
484
485
486
	/*
	 * WARNING:
	 *    We align/round the *SIZE* per below
	 *    so that all pointers returned by
	 *    this function are reasonably well
	 *    aligned.
	 *
	 * If we did not, then an "odd-length" request would cause the
	 * *next* allocation to be at an *odd* address, and because
	 * this function has the same type of api as malloc() - we
	 * must also return pointers that have the same type of
	 * alignment.
	 *
	 * What I do not/have is a reasonable portable means
487
	 * to align by...
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
	 *
	 * The solution here, is based on these suggestions.
	 * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html
	 *
	 */
	union worse_case_align {
	  int i;
	  long l;
	  float f;
	  void *v;
	};
#define ALIGN_SIZE  (sizeof(union worse_case_align))

	// The alignment process.
	size = (size + ALIGN_SIZE -1) & (~(ALIGN_SIZE-1));
503
504
	// Done...

505

506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
	if (*p_page)
	{
		while ((*p_page)->next)
			p_page = &((*p_page)->next);
		if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size)
			p_page = &((*p_page)->next);
	}

	if (!*p_page)
	{
		*p_page = malloc(sizeof(cmd_queue_page_t));
		(*p_page)->used = 0;
		(*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE);
		(*p_page)->next = NULL;
	}

	offset = (*p_page)->used;
	(*p_page)->used += size;
524

oharboe's avatar
oharboe committed
525
	t=(u8 *)((*p_page)->address);
526
527
528
	return t + offset;
}

oharboe's avatar
oharboe committed
529
void cmd_queue_free(void)
530
531
532
533
534
535
536
537
538
539
540
541
542
543
{
	cmd_queue_page_t *page = cmd_queue_pages;

	while (page)
	{
		cmd_queue_page_t *last = page;
		free(page->address);
		page = page->next;
		free(last);
	}

	cmd_queue_pages = NULL;
}

oharboe's avatar
oharboe committed
544
static void jtag_prelude1(void)
545
546
547
{
	if (jtag_trst == 1)
	{
548
		LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
oharboe's avatar
oharboe committed
549
		jtag_error=ERROR_JTAG_TRST_ASSERTED;
550
		return;
551
552
	}

553
	if (cmd_queue_end_state == TAP_RESET)
oharboe's avatar
oharboe committed
554
		jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
555
556
557
558
559
}

static void jtag_prelude(enum tap_state state)
{
	jtag_prelude1();
560

561
	if (state != -1)
562
		jtag_add_end_state(state);
563

oharboe's avatar
oharboe committed
564
	cmd_queue_cur_state = cmd_queue_end_state;
565
566
567
568
}

void jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state)
{
oharboe's avatar
oharboe committed
569
	int retval;
570

571
	jtag_prelude(state);
572

oharboe's avatar
oharboe committed
573
	retval=interface_jtag_add_ir_scan(num_fields, fields, cmd_queue_end_state);
oharboe's avatar
oharboe committed
574
575
576
577
	if (retval!=ERROR_OK)
		jtag_error=retval;
}

oharboe's avatar
oharboe committed
578
int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
579
{
oharboe's avatar
oharboe committed
580
	jtag_command_t **last_cmd;
581
582
583
584
	jtag_tap_t *tap;
	int j;
	int x;
	int nth_tap;
oharboe's avatar
oharboe committed
585
586
587
	int scan_size = 0;


588
	last_cmd = jtag_get_last_command_p();
589

590
591
592
593
594
595
596
597
598
	/* allocate memory for a new list member */
	*last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
	(*last_cmd)->next = NULL;
	last_comand_pointer = &((*last_cmd)->next);
	(*last_cmd)->type = JTAG_SCAN;

	/* allocate memory for ir scan command */
	(*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
	(*last_cmd)->cmd.scan->ir_scan = 1;
599
600
601
	x = jtag_NumEnabledTaps();
	(*last_cmd)->cmd.scan->num_fields = x;	/* one field per device */
	(*last_cmd)->cmd.scan->fields = cmd_queue_alloc(x  * sizeof(scan_field_t));
602
603
	(*last_cmd)->cmd.scan->end_state = state;

604
605
606
	nth_tap = -1;
	tap = NULL;
	for(;;){
607
		int found = 0;
608
609
610
611
612

		// do this here so it is not forgotten
		tap = jtag_NextEnabledTap(tap);
		if( tap == NULL ){
			break;
613
		}
614
615
616
617
618
619
		nth_tap++;
		scan_size = tap->ir_length;
		(*last_cmd)->cmd.scan->fields[nth_tap].tap = tap;
		(*last_cmd)->cmd.scan->fields[nth_tap].num_bits = scan_size;
		(*last_cmd)->cmd.scan->fields[nth_tap].in_value = NULL;
		(*last_cmd)->cmd.scan->fields[nth_tap].in_handler = NULL;	/* disable verification by default */
620
621
622
623

		/* search the list */
		for (j = 0; j < num_fields; j++)
		{
624
			if (tap == fields[j].tap)
625
626
			{
				found = 1;
627
628
				(*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
				(*last_cmd)->cmd.scan->fields[nth_tap].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
629

630
631
632
633
				if (jtag_verify_capture_ir)
				{
					if (fields[j].in_handler==NULL)
					{
634
						jtag_set_check_value((*last_cmd)->cmd.scan->fields+nth_tap, tap->expected, tap->expected_mask, NULL);
635
636
					} else
					{
637
638
639
640
						(*last_cmd)->cmd.scan->fields[nth_tap].in_handler = fields[j].in_handler;
						(*last_cmd)->cmd.scan->fields[nth_tap].in_handler_priv = fields[j].in_handler_priv;
						(*last_cmd)->cmd.scan->fields[nth_tap].in_check_value = tap->expected;
						(*last_cmd)->cmd.scan->fields[nth_tap].in_check_mask = tap->expected_mask;
641
642
					}
				}
643

644
				tap->bypass = 0;
645
646
647
				break;
			}
		}
648

649
650
		if (!found)
		{
651
652
653
654
			/* if a tap isn't listed, set it to BYPASS */
			(*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_set_ones(cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
			(*last_cmd)->cmd.scan->fields[nth_tap].out_mask = NULL;
			tap->bypass = 1;
655

656
		}
657

658
		/* update device information */
659
		buf_cpy((*last_cmd)->cmd.scan->fields[nth_tap].out_value, tap->cur_instr, scan_size);
660
	}
661

662
663
664
	return ERROR_OK;
}

665
void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state)
666
{
oharboe's avatar
oharboe committed
667
	int retval;
668

669
	jtag_prelude(state);
670

oharboe's avatar
oharboe committed
671
	retval=interface_jtag_add_plain_ir_scan(num_fields, fields, cmd_queue_end_state);
672
673
	if (retval!=ERROR_OK)
		jtag_error=retval;
674
675
}

oharboe's avatar
oharboe committed
676
int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
677
678
679
{
	int i;
	jtag_command_t **last_cmd;
680

681
	last_cmd = jtag_get_last_command_p();
682

683
684
685
686
687
688
689
690
691
692
693
694
695
	/* allocate memory for a new list member */
	*last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
	(*last_cmd)->next = NULL;
	last_comand_pointer = &((*last_cmd)->next);
	(*last_cmd)->type = JTAG_SCAN;

	/* allocate memory for ir scan command */
	(*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
	(*last_cmd)->cmd.scan->ir_scan = 1;
	(*last_cmd)->cmd.scan->num_fields = num_fields;
	(*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
	(*last_cmd)->cmd.scan->end_state = state;

696
	for( i = 0 ; i < num_fields ; i++ ){
697
698
		int num_bits = fields[i].num_bits;
		int num_bytes = CEIL(fields[i].num_bits, 8);
699
		(*last_cmd)->cmd.scan->fields[i].tap = fields[i].tap;
700
701
702
703
704
705
706
707
708
709
710
711
		(*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
		(*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
		(*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
		(*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
		(*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
		(*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
		(*last_cmd)->cmd.scan->fields[i].in_handler = NULL;
		(*last_cmd)->cmd.scan->fields[i].in_handler_priv = NULL;
	}
	return ERROR_OK;
}

712
void jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state)
713
{
oharboe's avatar
oharboe committed
714
	int retval;
715

716
	jtag_prelude(state);
717

oharboe's avatar
oharboe committed
718
	retval=interface_jtag_add_dr_scan(num_fields, fields, cmd_queue_end_state);
719
720
	if (retval!=ERROR_OK)
		jtag_error=retval;
721
722
}

oharboe's avatar
oharboe committed
723
int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
724
{
725
726
	int j;
	int nth_tap;
727
728
729
730
	int bypass_devices = 0;
	int field_count = 0;
	int scan_size;

731
	jtag_command_t **last_cmd = jtag_get_last_command_p();
732
	jtag_tap_t *tap;
733
734

	/* count devices in bypass */
735
736
737
738
739
740
741
742
	tap = NULL;
	bypass_devices = 0;
	for(;;){
		tap = jtag_NextEnabledTap(tap);
		if( tap == NULL ){
			break;
		}
		if( tap->bypass ){
743
			bypass_devices++;
744
		}
745
	}
746

747
748
749
750
751
752
753
754
755
756
757
758
	/* allocate memory for a new list member */
	*last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
	last_comand_pointer = &((*last_cmd)->next);
	(*last_cmd)->next = NULL;
	(*last_cmd)->type = JTAG_SCAN;

	/* allocate memory for dr scan command */
	(*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
	(*last_cmd)->cmd.scan->ir_scan = 0;
	(*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
	(*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
	(*last_cmd)->cmd.scan->end_state = state;
759

760
761
762
763
764
765
766
767
	tap = NULL;
	nth_tap = -1;
	for(;;){
		nth_tap++;
		tap = jtag_NextEnabledTap(tap);
		if( tap == NULL ){
			break;
		}
768
		int found = 0;
769
		(*last_cmd)->cmd.scan->fields[field_count].tap = tap;
770

771
772
		for (j = 0; j < num_fields; j++)
		{
773
			if (tap == fields[j].tap)
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
			{
				found = 1;
				scan_size = fields[j].num_bits;
				(*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
				(*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
				(*last_cmd)->cmd.scan->fields[field_count].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
				(*last_cmd)->cmd.scan->fields[field_count].in_value = fields[j].in_value;
				(*last_cmd)->cmd.scan->fields[field_count].in_check_value = fields[j].in_check_value;
				(*last_cmd)->cmd.scan->fields[field_count].in_check_mask = fields[j].in_check_mask;
				(*last_cmd)->cmd.scan->fields[field_count].in_handler = fields[j].in_handler;
				(*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = fields[j].in_handler_priv;
			}
		}
		if (!found)
		{
789
#ifdef _DEBUG_JTAG_IO_
790
			/* if a device isn't listed, the BYPASS register should be selected */
791
			if (! tap->bypass)
792
			{
793
				LOG_ERROR("BUG: no scan data for a device not in BYPASS");
794
795
				exit(-1);
			}
796
#endif
797
798
799
800
801
802
803
804
805
806
807
808
			/* program the scan field to 1 bit length, and ignore it's value */
			(*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
			(*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
			(*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
			(*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
			(*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
			(*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
			(*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
			(*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
		}
		else
		{
809
#ifdef _DEBUG_JTAG_IO_
810
			/* if a device is listed, the BYPASS register must not be selected */
811
			if (tap->bypass)
812
			{
813
				LOG_ERROR("BUG: scan data for a device in BYPASS");
814
				exit(-1);
815
			}
816
#endif
817
818
819
820
821
		}
	}
	return ERROR_OK;
}

822
void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap,
823
		int num_fields,
824
825
		const int *num_bits,
		const u32 *value,
826
827
		enum tap_state end_state)
{
828
	int nth_tap;
829
830
831
832
833
	int field_count = 0;
	int scan_size;
	int bypass_devices = 0;

	jtag_command_t **last_cmd = jtag_get_last_command_p();
834
835
	jtag_tap_t *tap;

836
	/* count devices in bypass */
837
838
839
840
841
842
843
844
	tap = NULL;
	bypass_devices = 0;
	for(;;){
		tap = jtag_NextEnabledTap(tap);
		if( tap == NULL ){
			break;
		}
		if( tap->bypass ){
845
			bypass_devices++;
846
		}
847
	}
848

849
850
851
852
853
854
855
856
857
858
859
860
	/* allocate memory for a new list member */
	*last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
	last_comand_pointer = &((*last_cmd)->next);
	(*last_cmd)->next = NULL;
	(*last_cmd)->type = JTAG_SCAN;

	/* allocate memory for dr scan command */
	(*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
	(*last_cmd)->cmd.scan->ir_scan = 0;
	(*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
	(*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
	(*last_cmd)->cmd.scan->end_state = end_state;
861

862
863
864
865
866
867
868
869
870
	tap = NULL;
	nth_tap = -1;
	for(;;){
		tap = jtag_NextEnabledTap(tap);
		if( tap == NULL ){
			break;
		}
		nth_tap++;
		(*last_cmd)->cmd.scan->fields[field_count].tap = tap;
871

872
		if (tap == target_tap)
873
874
875
876
		{
			int j;
#ifdef _DEBUG_JTAG_IO_
			/* if a device is listed, the BYPASS register must not be selected */
877
			if (tap->bypass)
878
			{
879
				LOG_ERROR("BUG: scan data for a device in BYPASS");
880
881
882
883
884
				exit(-1);
			}
#endif
			for (j = 0; j < num_fields; j++)
			{
oharboe's avatar
oharboe committed
885
				u8 out_value[4];
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
				scan_size = num_bits[j];
				buf_set_u32(out_value, 0, scan_size, value[j]);
				(*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
				(*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
				(*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
				(*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
				(*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
				(*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
				(*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
				(*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
			}
		} else
		{
#ifdef _DEBUG_JTAG_IO_
			/* if a device isn't listed, the BYPASS register should be selected */
901
			if (! tap->bypass)
902
			{
903
				LOG_ERROR("BUG: no scan data for a device not in BYPASS");
904
905
				exit(-1);
			}
906
#endif
907
908
909
910
911
912
913
914
915
916
917
918
919
			/* program the scan field to 1 bit length, and ignore it's value */
			(*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
			(*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
			(*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
			(*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
			(*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
			(*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
			(*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
			(*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
		}
	}
}

920
void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state)
921
{
oharboe's avatar
oharboe committed
922
	int retval;
923

924
	jtag_prelude(state);
925

oharboe's avatar
oharboe committed
926
	retval=interface_jtag_add_plain_dr_scan(num_fields, fields, cmd_queue_end_state);
927
928
	if (retval!=ERROR_OK)
		jtag_error=retval;
929
930
}

oharboe's avatar
oharboe committed
931
int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
932
933
934
{
	int i;
	jtag_command_t **last_cmd = jtag_get_last_command_p();
935

936
937
938
939
940
941
942
943
944
945
946
947
	/* allocate memory for a new list member */
	*last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
	last_comand_pointer = &((*last_cmd)->next);
	(*last_cmd)->next = NULL;
	(*last_cmd)->type = JTAG_SCAN;

	/* allocate memory for scan command */
	(*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
	(*last_cmd)->cmd.scan->ir_scan = 0;
	(*last_cmd)->cmd.scan->num_fields = num_fields;
	(*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
	(*last_cmd)->cmd.scan->end_state = state;
948

949
950
951
952
	for (i = 0; i < num_fields; i++)
	{
		int num_bits = fields[i].num_bits;
		int num_bytes = CEIL(fields[i].num_bits, 8);
953
		(*last_cmd)->cmd.scan->fields[i].tap = fields[i].tap;
954
955
956
957
958
959
960
961
962
963
964
965
		(*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
		(*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
		(*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
		(*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
		(*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
		(*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
		(*last_cmd)->cmd.scan->fields[i].in_handler = fields[i].in_handler;
		(*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[i].in_handler_priv;
	}

	return ERROR_OK;
}
oharboe's avatar
oharboe committed
966

967
void jtag_add_tlr(void)
968
{
969
	jtag_prelude(TAP_RESET);
970

971
	int retval;
972
	retval=interface_jtag_add_tlr();
973
974
	if (retval!=ERROR_OK)
		jtag_error=retval;
oharboe's avatar
oharboe committed
975
976
}

977
int MINIDRIVER(interface_jtag_add_tlr)()
oharboe's avatar
oharboe committed
978
{
979
	enum tap_state state = TAP_RESET;
oharboe's avatar
oharboe committed
980
	jtag_command_t **last_cmd = jtag_get_last_command_p();
981

oharboe's avatar
oharboe committed
982
983
984
985
986
987
988
989
	/* allocate memory for a new list member */
	*last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
	last_comand_pointer = &((*last_cmd)->next);
	(*last_cmd)->next = NULL;
	(*last_cmd)->type = JTAG_STATEMOVE;

	(*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t));
	(*last_cmd)->cmd.statemove->end_state = state;
990
991


992
993
994
	return ERROR_OK;
}

995
void jtag_add_pathmove(int num_states, enum tap_state *path)
996
{
oharboe's avatar
oharboe committed
997
998
999
1000
	enum tap_state cur_state=cmd_queue_cur_state;
	int i;
	int retval;

For faster browsing, not all history is shown. View entire blame