core.c 44 KB
Newer Older
1
/***************************************************************************
2
3
 *   Copyright (C) 2009 Zachary T Welch                                    *
 *   zw@superlucidity.net                                                  *
4
 *                                                                         *
5
 *   Copyright (C) 2007,2008,2009 Øyvind Harboe                            *
6
7
8
9
10
11
 *   oyvind.harboe@zylin.com                                               *
 *                                                                         *
 *   Copyright (C) 2009 SoftPLC Corporation                                *
 *       http://softplc.com                                                *
 *   dick@softplc.com                                                      *
 *                                                                         *
12
13
 *   Copyright (C) 2005 by Dominic Rath                                    *
 *   Dominic.Rath@gmx.de                                                   *
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 *                                                                         *
 *   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 "jtag.h"
#include "minidriver.h"
#include "interface.h"

#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif


/// The number of JTAG queue flushes (for profiling and debugging purposes).
static int jtag_flush_queue_count;

46
47
static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const struct scan_field *in_fields, tap_state_t state),
		int in_num_fields, struct scan_field *in_fields, tap_state_t state);
48

49
50
51
52
53
54
55
56
57
58
59
/**
 * The jtag_error variable is set when an error occurs while executing
 * the queue.  Application code may set this using jtag_set_error(),
 * when an error occurs during processing that should be reported during
 * jtag_execute_queue().
 *
 * Tts value may be checked with jtag_get_error() and cleared with
 * jtag_error_clear().  This value is returned (and cleared) by
 * jtag_execute_queue().
 */
static int jtag_error = ERROR_OK;
60

zwelch's avatar
zwelch committed
61
static const char *jtag_event_strings[] =
62
{
dbrownell's avatar
dbrownell committed
63
	[JTAG_TRST_ASSERTED] = "TAP reset",
64
	[JTAG_TAP_EVENT_SETUP] = "TAP setup",
zwelch's avatar
zwelch committed
65
66
	[JTAG_TAP_EVENT_ENABLE] = "TAP enabled",
	[JTAG_TAP_EVENT_DISABLE] = "TAP disabled",
67
68
};

69
70
/*
 * JTAG adapters must initialize with TRST and SRST de-asserted
71
72
73
 * (they're negative logic, so that means *high*).  But some
 * hardware doesn't necessarily work that way ... so set things
 * up so that jtag_init() always forces that state.
74
 */
75
76
static int jtag_trst = -1;
static int jtag_srst = -1;
77
78
79
80

/**
 * List all TAPs that have been created.
 */
81
static struct jtag_tap *__jtag_all_taps = NULL;
82
83
84
85
86
87
/**
 * The number of TAPs in the __jtag_all_taps list, used to track the
 * assigned chain position to new TAPs
 */
static unsigned jtag_num_taps = 0;

88
89
static enum reset_types jtag_reset_config = RESET_NONE;
static tap_state_t cmd_queue_end_state = TAP_RESET;
90
91
tap_state_t cmd_queue_cur_state = TAP_RESET;

92
static bool jtag_verify_capture_ir = true;
93
static int jtag_verify = 1;
94
95
96
97

/* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
static int jtag_nsrst_delay = 0; /* default to no nSRST delay */
static int jtag_ntrst_delay = 0; /* default to no nTRST delay */
oharboe's avatar
oharboe committed
98
99
static int jtag_nsrst_assert_width = 0; /* width of assertion */
static int jtag_ntrst_assert_width = 0; /* width of assertion */
100

101
102
103
104
105
106
107
108
109
110
111
112
/**
 * Contains a single callback along with a pointer that will be passed
 * when an event occurs.
 */
struct jtag_event_callback {
	/// a event callback
	jtag_event_handler_t callback;
	/// the private data to pass to the callback
	void* priv;
	/// the next callback
	struct jtag_event_callback* next;
};
113

114
/* callbacks to inform high-level handlers about JTAG state changes */
115
static struct jtag_event_callback *jtag_event_callbacks;
116
117
118

/* speed in kHz*/
static int speed_khz = 0;
119
120
121
/* speed to fallback to when RCLK is requested but not supported */
static int rclk_fallback_speed_khz = 0;
static enum {CLOCK_MODE_SPEED, CLOCK_MODE_KHZ, CLOCK_MODE_RCLK} clock_mode;
122
static int jtag_speed = 0;
123

124
static struct jtag_interface *jtag = NULL;
125
126

/* configuration */
127
struct jtag_interface *jtag_interface = NULL;
128

129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
void jtag_set_error(int error)
{
	if ((error == ERROR_OK) || (jtag_error != ERROR_OK))
		return;
	jtag_error = error;
}
int jtag_get_error(void)
{
	return jtag_error;
}
int jtag_error_clear(void)
{
	int temp = jtag_error;
	jtag_error = ERROR_OK;
	return temp;
}

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

static bool jtag_poll = 1;

bool is_jtag_poll_safe(void)
{
	/* Polling can be disabled explicitly with set_enabled(false).
	 * It is also implicitly disabled while TRST is active and
	 * while SRST is gating the JTAG clock.
	 */
	if (!jtag_poll || jtag_trst != 0)
		return false;
	return jtag_srst == 0 || (jtag_reset_config & RESET_SRST_NO_GATING);
}

bool jtag_poll_get_enabled(void)
{
	return jtag_poll;
}

void jtag_poll_set_enabled(bool value)
{
	jtag_poll = value;
}

/************/
172

173
struct jtag_tap *jtag_all_taps(void)
174
175
176
177
178
179
180
181
182
183
184
{
	return __jtag_all_taps;
};

unsigned jtag_tap_count(void)
{
	return jtag_num_taps;
}

unsigned jtag_tap_count_enabled(void)
{
185
	struct jtag_tap *t = jtag_all_taps();
186
	unsigned n = 0;
zwelch's avatar
zwelch committed
187
	while (t)
188
189
190
191
192
193
194
195
196
	{
		if (t->enabled)
			n++;
		t = t->next_tap;
	}
	return n;
}

/// Append a new TAP to the chain of all taps.
197
void jtag_tap_add(struct jtag_tap *t)
198
199
200
{
	t->abs_chain_position = jtag_num_taps++;

201
	struct jtag_tap **tap = &__jtag_all_taps;
zwelch's avatar
zwelch committed
202
	while (*tap != NULL)
203
204
205
206
		tap = &(*tap)->next_tap;
	*tap = t;
}

zwelch's avatar
zwelch committed
207
/* returns a pointer to the n-th device in the scan chain */
208
static inline struct jtag_tap *jtag_tap_by_position(unsigned n)
zwelch's avatar
zwelch committed
209
{
210
	struct jtag_tap *t = jtag_all_taps();
zwelch's avatar
zwelch committed
211
212
213
214
215
216
217

	while (t && n-- > 0)
		t = t->next_tap;

	return t;
}

218
struct jtag_tap *jtag_tap_by_string(const char *s)
219
220
{
	/* try by name first */
221
	struct jtag_tap *t = jtag_all_taps();
zwelch's avatar
zwelch committed
222

223
224
225
226
227
228
229
230
	while (t)
	{
		if (0 == strcmp(t->dotted_name, s))
			return t;
		t = t->next_tap;
	}

	/* no tap found by name, so try to parse the name as a number */
231
232
	unsigned n;
	if (parse_uint(s, &n) != ERROR_OK)
233
234
		return NULL;

zwelch's avatar
zwelch committed
235
236
237
238
239
240
241
242
243
244
	/* FIXME remove this numeric fallback code late June 2010, along
	 * with all info in the User's Guide that TAPs have numeric IDs.
	 * Also update "scan_chain" output to not display the numbers.
	 */
	t = jtag_tap_by_position(n);
	if (t)
		LOG_WARNING("Specify TAP '%s' by name, not number %u",
			t->dotted_name, n);

	return t;
245
246
}

247
struct jtag_tap *jtag_tap_by_jim_obj(Jim_Interp *interp, Jim_Obj *o)
248
249
{
	const char *cp = Jim_GetString(o, NULL);
250
	struct jtag_tap *t = cp ? jtag_tap_by_string(cp) : NULL;
251
252
253
254
255
256
257
	if (NULL == cp)
		cp = "(unknown)";
	if (NULL == t)
		Jim_SetResult_sprintf(interp, "Tap '%s' could not be found", cp);
	return t;
}

258
struct jtag_tap* jtag_tap_next_enabled(struct jtag_tap* p)
259
260
261
262
263
264
265
266
267
268
269
{
	p = p ? p->next_tap : jtag_all_taps();
	while (p)
	{
		if (p->enabled)
			return p;
		p = p->next_tap;
	}
	return NULL;
}

270
const char *jtag_tap_name(const struct jtag_tap *tap)
271
272
273
274
275
{
	return (tap == NULL) ? "(unknown)" : tap->dotted_name;
}


zwelch's avatar
zwelch committed
276
int jtag_register_event_callback(jtag_event_handler_t callback, void *priv)
277
{
278
	struct jtag_event_callback **callbacks_p = &jtag_event_callbacks;
279
280
281
282
283
284
285
286
287
288
289
290
291

	if (callback == NULL)
	{
		return ERROR_INVALID_ARGUMENTS;
	}

	if (*callbacks_p)
	{
		while ((*callbacks_p)->next)
			callbacks_p = &((*callbacks_p)->next);
		callbacks_p = &((*callbacks_p)->next);
	}

292
	(*callbacks_p) = malloc(sizeof(struct jtag_event_callback));
293
294
295
296
297
298
299
	(*callbacks_p)->callback = callback;
	(*callbacks_p)->priv = priv;
	(*callbacks_p)->next = NULL;

	return ERROR_OK;
}

zwelch's avatar
zwelch committed
300
int jtag_unregister_event_callback(jtag_event_handler_t callback, void *priv)
301
{
302
303
	struct jtag_event_callback **callbacks_p;
	struct jtag_event_callback **next;
304
305
306
307
308
309

	if (callback == NULL)
	{
		return ERROR_INVALID_ARGUMENTS;
	}

zwelch's avatar
zwelch committed
310
311
312
	for (callbacks_p = &jtag_event_callbacks;
			*callbacks_p != NULL;
			callbacks_p = next)
313
	{
zwelch's avatar
zwelch committed
314
315
316
317
318
		next = &((*callbacks_p)->next);

		if ((*callbacks_p)->priv != priv)
			continue;

319
320
321
322
323
324
325
326
327
328
329
330
		if ((*callbacks_p)->callback == callback)
		{
			free(*callbacks_p);
			*callbacks_p = *next;
		}
	}

	return ERROR_OK;
}

int jtag_call_event_callbacks(enum jtag_event event)
{
331
	struct jtag_event_callback *callback = jtag_event_callbacks;
332
333
334
335
336

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

	while (callback)
	{
337
		struct jtag_event_callback *next;
zwelch's avatar
zwelch committed
338
339
340

		/* callback may remove itself */
		next = callback->next;
341
		callback->callback(event, callback->priv);
zwelch's avatar
zwelch committed
342
		callback = next;
343
344
345
346
347
348
349
350
351
352
353
354
355
356
	}

	return ERROR_OK;
}

static void jtag_checks(void)
{
	assert(jtag_trst == 0);
}

static void jtag_prelude(tap_state_t state)
{
	jtag_checks();

zwelch's avatar
zwelch committed
357
	assert(state != TAP_INVALID);
358
359
360
361

	cmd_queue_cur_state = state;
}

362
void jtag_alloc_in_value32(struct scan_field *field)
363
364
365
366
{
	interface_jtag_alloc_in_value32(field);
}

367
void jtag_add_ir_scan_noverify(int in_count, const struct scan_field *in_fields,
368
369
370
371
372
373
374
375
376
		tap_state_t state)
{
	jtag_prelude(state);

	int retval = interface_jtag_add_ir_scan(in_count, in_fields, state);
	jtag_set_error(retval);
}


377
void jtag_add_ir_scan(int in_num_fields, struct scan_field *in_fields, tap_state_t state)
378
{
379
380
	assert(state != TAP_RESET);

zwelch's avatar
zwelch committed
381
	if (jtag_verify && jtag_verify_capture_ir)
382
383
384
385
386
387
388
389
	{
		/* 8 x 32 bit id's is enough for all invocations */

		for (int j = 0; j < in_num_fields; j++)
		{
			/* if we are to run a verification of the ir scan, we need to get the input back.
			 * We may have to allocate space if the caller didn't ask for the input back.
			 */
zwelch's avatar
zwelch committed
390
391
			in_fields[j].check_value = in_fields[j].tap->expected;
			in_fields[j].check_mask = in_fields[j].tap->expected_mask;
392
393
394
395
396
397
398
399
		}
		jtag_add_scan_check(jtag_add_ir_scan_noverify, in_num_fields, in_fields, state);
	} else
	{
		jtag_add_ir_scan_noverify(in_num_fields, in_fields, state);
	}
}

400
void jtag_add_plain_ir_scan(int in_num_fields, const struct scan_field *in_fields,
401
402
		tap_state_t state)
{
403
404
	assert(state != TAP_RESET);

405
406
407
408
409
410
411
	jtag_prelude(state);

	int retval = interface_jtag_add_plain_ir_scan(
			in_num_fields, in_fields, state);
	jtag_set_error(retval);
}

412
void jtag_add_callback(jtag_callback1_t f, jtag_callback_data_t data0)
413
{
414
	interface_jtag_add_callback(f, data0);
415
416
}

417
void jtag_add_callback4(jtag_callback_t f, jtag_callback_data_t data0,
418
419
420
		jtag_callback_data_t data1, jtag_callback_data_t data2,
		jtag_callback_data_t data3)
{
421
	interface_jtag_add_callback4(f, data0, data1, data2, data3);
422
423
}

424
425
static int jtag_check_value_inner(uint8_t *captured, uint8_t *in_check_value,
		uint8_t *in_check_mask, int num_bits);
426

427
static int jtag_check_value_mask_callback(jtag_callback_data_t data0, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3)
428
{
429
	return jtag_check_value_inner((uint8_t *)data0, (uint8_t *)data1, (uint8_t *)data2, (int)data3);
430
431
}

432
433
static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const struct scan_field *in_fields, tap_state_t state),
		int in_num_fields, struct scan_field *in_fields, tap_state_t state)
434
435
436
{
	for (int i = 0; i < in_num_fields; i++)
	{
437
		struct scan_field *field = &in_fields[i];
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
		field->allocated = 0;
		field->modified = 0;
		if (field->check_value || field->in_value)
			continue;
		interface_jtag_add_scan_check_alloc(field);
		field->modified = 1;
	}

	jtag_add_scan(in_num_fields, in_fields, state);

	for (int i = 0; i < in_num_fields; i++)
	{
		if ((in_fields[i].check_value != NULL) && (in_fields[i].in_value != NULL))
		{
			/* this is synchronous for a minidriver */
453
			jtag_add_callback4(jtag_check_value_mask_callback, (jtag_callback_data_t)in_fields[i].in_value,
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
				(jtag_callback_data_t)in_fields[i].check_value,
				(jtag_callback_data_t)in_fields[i].check_mask,
				(jtag_callback_data_t)in_fields[i].num_bits);
		}
		if (in_fields[i].allocated)
		{
			free(in_fields[i].in_value);
		}
		if (in_fields[i].modified)
		{
			in_fields[i].in_value = NULL;
		}
	}
}

469
void jtag_add_dr_scan_check(int in_num_fields, struct scan_field *in_fields, tap_state_t state)
470
471
472
473
474
475
476
477
478
479
480
{
	if (jtag_verify)
	{
		jtag_add_scan_check(jtag_add_dr_scan, in_num_fields, in_fields, state);
	} else
	{
		jtag_add_dr_scan(in_num_fields, in_fields, state);
	}
}


481
void jtag_add_dr_scan(int in_num_fields, const struct scan_field *in_fields,
482
483
		tap_state_t state)
{
484
	assert(state != TAP_RESET);
485

486
487
488
489
490
491
492
	jtag_prelude(state);

	int retval;
	retval = interface_jtag_add_dr_scan(in_num_fields, in_fields, state);
	jtag_set_error(retval);
}

493
void jtag_add_plain_dr_scan(int in_num_fields, const struct scan_field *in_fields,
494
495
		tap_state_t state)
{
496
	assert(state != TAP_RESET);
497

498
499
500
501
502
503
504
	jtag_prelude(state);

	int retval;
	retval = interface_jtag_add_plain_dr_scan(in_num_fields, in_fields, state);
	jtag_set_error(retval);
}

505
void jtag_add_dr_out(struct jtag_tap* tap,
506
		int num_fields, const int* num_bits, const uint32_t* value,
507
508
		tap_state_t end_state)
{
509
	assert(end_state != TAP_RESET);
510
511
512
513
514
515
516
517
518
519
520
521
522
	assert(end_state != TAP_INVALID);

	cmd_queue_cur_state = end_state;

	interface_jtag_add_dr_out(tap,
			num_fields, num_bits, value,
			end_state);
}

void jtag_add_tlr(void)
{
	jtag_prelude(TAP_RESET);
	jtag_set_error(interface_jtag_add_tlr());
523

524
	/* NOTE: order here matches TRST path in jtag_add_reset() */
525
	jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
526
	jtag_notify_event(JTAG_TRST_ASSERTED);
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
}

void jtag_add_pathmove(int num_states, const tap_state_t *path)
{
	tap_state_t cur_state = cmd_queue_cur_state;

	/* the last state has to be a stable state */
	if (!tap_is_state_stable(path[num_states - 1]))
	{
		LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
		jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE);
		return;
	}

	for (int i = 0; i < num_states; i++)
	{
		if (path[i] == TAP_RESET)
		{
			LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
			jtag_set_error(ERROR_JTAG_STATE_INVALID);
			return;
		}

550
		if (tap_state_transition(cur_state, true)  != path[i]
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
		  && tap_state_transition(cur_state, false) != path[i])
		{
			LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
					tap_state_name(cur_state), tap_state_name(path[i]));
			jtag_set_error(ERROR_JTAG_TRANSITION_INVALID);
			return;
		}
		cur_state = path[i];
	}

	jtag_checks();

	jtag_set_error(interface_jtag_add_pathmove(num_states, path));
	cmd_queue_cur_state = path[num_states - 1];
}

567
568
569
570
int jtag_add_statemove(tap_state_t goal_state)
{
	tap_state_t cur_state = cmd_queue_cur_state;

571
	LOG_DEBUG("cur_state=%s goal_state=%s",
572
		tap_state_name(cur_state),
573
		tap_state_name(goal_state));
574
575


576
577
578
579
	/* If goal is RESET, be paranoid and force that that transition
	 * (e.g. five TCK cycles, TMS high).  Else trust "cur_state".
	 */
	if (goal_state == TAP_RESET)
580
		jtag_add_tlr();
581
582
583
	else if (goal_state == cur_state)
		/* nothing to do */ ;

584
	else if (tap_is_state_stable(cur_state) && tap_is_state_stable(goal_state))
585
586
587
588
	{
		unsigned tms_bits  = tap_get_tms_path(cur_state, goal_state);
		unsigned tms_count = tap_get_tms_path_len(cur_state, goal_state);
		tap_state_t moves[8];
589
		assert(tms_count < ARRAY_SIZE(moves));
590
591
592
593
594
595
596
597
598
599
600

		for (unsigned i = 0; i < tms_count; i++, tms_bits >>= 1)
		{
			bool bit = tms_bits & 1;

			cur_state = tap_state_transition(cur_state, bit);
			moves[i] = cur_state;
		}

		jtag_add_pathmove(tms_count, moves);
	}
601
	else if (tap_state_transition(cur_state, true)  == goal_state
602
		||   tap_state_transition(cur_state, false) == goal_state)
603
604
605
606
607
608
609
610
611
612
	{
		jtag_add_pathmove(1, &goal_state);
	}

	else
		return ERROR_FAIL;

	return ERROR_OK;
}

613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
void jtag_add_runtest(int num_cycles, tap_state_t state)
{
	jtag_prelude(state);
	jtag_set_error(interface_jtag_add_runtest(num_cycles, state));
}


void jtag_add_clocks(int num_cycles)
{
	if (!tap_is_state_stable(cmd_queue_cur_state))
	{
		 LOG_ERROR("jtag_add_clocks() called with TAP in unstable state \"%s\"",
				 tap_state_name(cmd_queue_cur_state));
		 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE);
		 return;
	}

	if (num_cycles > 0)
	{
		jtag_checks();
		jtag_set_error(interface_jtag_add_clocks(num_cycles));
	}
}

void jtag_add_reset(int req_tlr_or_trst, int req_srst)
{
	int trst_with_tlr = 0;
640
	int new_srst = 0;
641
	int new_trst = 0;
642

643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
	/* Without SRST, we must use target-specific JTAG operations
	 * on each target; callers should not be requesting SRST when
	 * that signal doesn't exist.
	 *
	 * RESET_SRST_PULLS_TRST is a board or chip level quirk, which
	 * can kick in even if the JTAG adapter can't drive TRST.
	 */
	if (req_srst) {
		if (!(jtag_reset_config & RESET_HAS_SRST)) {
			LOG_ERROR("BUG: can't assert SRST");
			jtag_set_error(ERROR_FAIL);
			return;
		}
		if ((jtag_reset_config & RESET_SRST_PULLS_TRST) != 0
				&& !req_tlr_or_trst) {
			LOG_ERROR("BUG: can't assert only SRST");
			jtag_set_error(ERROR_FAIL);
			return;
		}
		new_srst = 1;
	}

665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
	/* JTAG reset (entry to TAP_RESET state) can always be achieved
	 * using TCK and TMS; that may go through a TAP_{IR,DR}UPDATE
	 * state first.  TRST accelerates it, and bypasses those states.
	 *
	 * RESET_TRST_PULLS_SRST is a board or chip level quirk, which
	 * can kick in even if the JTAG adapter can't drive SRST.
	 */
	if (req_tlr_or_trst) {
		if (!(jtag_reset_config & RESET_HAS_TRST))
			trst_with_tlr = 1;
		else if ((jtag_reset_config & RESET_TRST_PULLS_SRST) != 0
				&& !req_srst)
			trst_with_tlr = 1;
		else
			new_trst = 1;
	}

682
683
684
	/* Maybe change TRST and/or SRST signal state */
	if (jtag_srst != new_srst || jtag_trst != new_trst) {
		int retval;
685

686
687
688
689
690
691
692
693
694
695
		retval = interface_jtag_add_reset(new_trst, new_srst);
		if (retval != ERROR_OK)
			jtag_set_error(retval);
		else
			retval = jtag_execute_queue();

		if (retval != ERROR_OK) {
			LOG_ERROR("TRST/SRST error %d", retval);
			return;
		}
696
	}
697
698
699
700
701

	/* SRST resets everything hooked up to that signal */
	if (jtag_srst != new_srst) {
		jtag_srst = new_srst;
		if (jtag_srst)
oharboe's avatar
oharboe committed
702
		{
703
			LOG_DEBUG("SRST line asserted");
oharboe's avatar
oharboe committed
704
705
706
			if (jtag_nsrst_assert_width)
				jtag_add_sleep(jtag_nsrst_assert_width * 1000);
		}
707
708
709
710
711
		else {
			LOG_DEBUG("SRST line released");
			if (jtag_nsrst_delay)
				jtag_add_sleep(jtag_nsrst_delay * 1000);
		}
712
713
	}

714
715
716
717
718
719
720
721
	/* Maybe enter the JTAG TAP_RESET state ...
	 *  - using only TMS, TCK, and the JTAG state machine
	 *  - or else more directly, using TRST
	 *
	 * TAP_RESET should be invisible to non-debug parts of the system.
	 */
	if (trst_with_tlr) {
		LOG_DEBUG("JTAG reset with TLR instead of TRST");
722
723
724
		jtag_set_end_state(TAP_RESET);
		jtag_add_tlr();

725
726
727
728
729
	} else if (jtag_trst != new_trst) {
		jtag_trst = new_trst;
		if (jtag_trst) {
			LOG_DEBUG("TRST line asserted");
			tap_set_state(TAP_RESET);
oharboe's avatar
oharboe committed
730
731
			if (jtag_ntrst_assert_width)
				jtag_add_sleep(jtag_ntrst_assert_width * 1000);
732
733
734
735
		} else {
			LOG_DEBUG("TRST line released");
			if (jtag_ntrst_delay)
				jtag_add_sleep(jtag_ntrst_delay * 1000);
736

737
738
739
740
741
742
			/* We just asserted nTRST, so we're now in TAP_RESET.
			 * Inform possible listeners about this, now that
			 * JTAG instructions and data can be shifted.  This
			 * sequence must match jtag_add_tlr().
			 */
			jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
743
			jtag_notify_event(JTAG_TRST_ASSERTED);
744
		}
745
746
747
748
749
750
751
752
753
754
	}
}

tap_state_t jtag_set_end_state(tap_state_t state)
{
	if ((state == TAP_DRSHIFT)||(state == TAP_IRSHIFT))
	{
		LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
	}

zwelch's avatar
zwelch committed
755
	if (state != TAP_INVALID)
756
757
758
759
760
761
762
763
764
		cmd_queue_end_state = state;
	return cmd_queue_end_state;
}

tap_state_t jtag_get_end_state(void)
{
	return cmd_queue_end_state;
}

765
void jtag_add_sleep(uint32_t us)
766
767
768
769
770
771
{
	/// @todo Here, keep_alive() appears to be a layering violation!!!
	keep_alive();
	jtag_set_error(interface_jtag_add_sleep(us));
}

772
773
static int jtag_check_value_inner(uint8_t *captured, uint8_t *in_check_value,
		uint8_t *in_check_mask, int num_bits)
774
775
776
777
778
779
780
781
782
783
{
	int retval = ERROR_OK;

	int compare_failed = 0;

	if (in_check_mask)
		compare_failed = buf_cmp_mask(captured, in_check_value, in_check_mask, num_bits);
	else
		compare_failed = buf_cmp(captured, in_check_value, num_bits);

zwelch's avatar
zwelch committed
784
	if (compare_failed) {
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
		char *captured_str, *in_check_value_str;
		int bits = (num_bits > DEBUG_JTAG_IOZ)
				? DEBUG_JTAG_IOZ
				: num_bits;

		/* NOTE:  we've lost diagnostic context here -- 'which tap' */

		captured_str = buf_to_str(captured, bits, 16);
		in_check_value_str = buf_to_str(in_check_value, bits, 16);

		LOG_WARNING("Bad value '%s' captured during DR or IR scan:",
				captured_str);
		LOG_WARNING(" check_value: 0x%s", in_check_value_str);

		free(captured_str);
		free(in_check_value_str);

		if (in_check_mask) {
			char *in_check_mask_str;

			in_check_mask_str = buf_to_str(in_check_mask, bits, 16);
			LOG_WARNING(" check_mask: 0x%s", in_check_mask_str);
			free(in_check_mask_str);
808
809
		}

810
		retval = ERROR_JTAG_QUEUE_FAILED;
811
812
813
814
	}
	return retval;
}

815
void jtag_check_value_mask(struct scan_field *field, uint8_t *value, uint8_t *mask)
816
817
818
{
	assert(field->in_value != NULL);

zwelch's avatar
zwelch committed
819
	if (value == NULL)
820
821
822
823
824
825
826
	{
		/* no checking to do */
		return;
	}

	jtag_execute_queue_noclear();

zwelch's avatar
zwelch committed
827
	int retval = jtag_check_value_inner(field->in_value, value, mask, field->num_bits);
828
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
	jtag_set_error(retval);
}



int default_interface_jtag_execute_queue(void)
{
	if (NULL == jtag)
	{
		LOG_ERROR("No JTAG interface configured yet.  "
			"Issue 'init' command in startup scripts "
			"before communicating with targets.");
		return ERROR_FAIL;
	}

	return jtag->execute_queue();
}

void jtag_execute_queue_noclear(void)
{
	jtag_flush_queue_count++;
	jtag_set_error(interface_jtag_execute_queue());
}

int jtag_get_flush_queue_count(void)
{
	return jtag_flush_queue_count;
}

int jtag_execute_queue(void)
{
	jtag_execute_queue_noclear();
	return jtag_error_clear();
}

static int jtag_reset_callback(enum jtag_event event, void *priv)
{
865
	struct jtag_tap *tap = priv;
866
867
868

	if (event == JTAG_TRST_ASSERTED)
	{
zwelch's avatar
zwelch committed
869
870
		tap->enabled = !tap->disabled_after_reset;

871
		/* current instruction is either BYPASS or IDCODE */
872
873
874
875
876
877
878
		buf_set_ones(tap->cur_instr, tap->ir_length);
		tap->bypass = 1;
	}

	return ERROR_OK;
}

879
void jtag_sleep(uint32_t us)
880
881
882
883
{
	alive_sleep(us/1000);
}

884
885
886
887
/* Maximum number of enabled JTAG devices we expect in the scan chain,
 * plus one (to detect garbage at the end).  Devices that don't support
 * IDCODE take up fewer bits, possibly allowing a few more devices.
 */
888
889
890
891
892
893
#define JTAG_MAX_CHAIN_SIZE 20

#define EXTRACT_MFG(X)  (((X) & 0xffe) >> 1)
#define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
#define EXTRACT_VER(X)  (((X) & 0xf0000000) >> 28)

894
895
896
/* A reserved manufacturer ID is used in END_OF_CHAIN_FLAG, so we
 * know that no valid TAP will have it as an IDCODE value.
 */
897
898
#define END_OF_CHAIN_FLAG	0x000000ff

David Brownell's avatar
David Brownell committed
899
900
901
/* a larger IR length than we ever expect to autoprobe */
#define JTAG_IRLEN_MAX		60

zwelch's avatar
zwelch committed
902
static int jtag_examine_chain_execute(uint8_t *idcode_buffer, unsigned num_idcode)
903
{
904
	struct scan_field field = {
905
906
907
908
909
910
911
912
			.tap = NULL,
			.num_bits = num_idcode * 32,
			.out_value = idcode_buffer,
			.in_value = idcode_buffer,
		};

	// initialize to the end of chain ID value
	for (unsigned i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
913
		buf_set_u32(idcode_buffer, i * 32, 32, END_OF_CHAIN_FLAG);
914

915
916
	jtag_add_plain_dr_scan(1, &field, TAP_DRPAUSE);
	jtag_add_tlr();
917
918
919
	return jtag_execute_queue();
}

zwelch's avatar
zwelch committed
920
static bool jtag_examine_chain_check(uint8_t *idcodes, unsigned count)
921
{
zwelch's avatar
zwelch committed
922
923
	uint8_t zero_check = 0x0;
	uint8_t one_check = 0xff;
924
925
926
927
928
929
930
931

	for (unsigned i = 0; i < count * 4; i++)
	{
		zero_check |= idcodes[i];
		one_check &= idcodes[i];
	}

	/* if there wasn't a single non-zero bit or if all bits were one,
932
933
934
935
936
937
938
939
940
	 * the scan is not valid.  We wrote a mix of both values; either
	 *
	 *  - There's a hardware issue (almost certainly):
	 *     + all-zeroes can mean a target stuck in JTAG reset
	 *     + all-ones tends to mean no target
	 *  - The scan chain is WAY longer than we can handle, *AND* either
	 *     + there are several hundreds of TAPs in bypass, or
	 *     + at least a few dozen TAPs all have an all-ones IDCODE
	 */
941
942
	if (zero_check == 0x00 || one_check == 0xff)
	{
943
944
945
		LOG_ERROR("JTAG scan chain interrogation failed: all %s",
				(zero_check == 0x00) ? "zeroes" : "ones");
		LOG_ERROR("Check JTAG interface, timings, target power, etc.");
946
947
948
949
950
951
		return false;
	}
	return true;
}

static void jtag_examine_chain_display(enum log_levels level, const char *msg,
952
		const char *name, uint32_t idcode)
953
954
{
	log_printf_lf(level, __FILE__, __LINE__, __FUNCTION__,
955
956
				  "JTAG tap: %s %16.16s: 0x%08x "
				  "(mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
957
				  name, msg,
958
				  (unsigned int)idcode,
959
960
				  (unsigned int)EXTRACT_MFG(idcode),
				  (unsigned int)EXTRACT_PART(idcode),
961
				  (unsigned int)EXTRACT_VER(idcode));
962
963
}

964
static bool jtag_idcode_is_final(uint32_t idcode)
965
{
966
967
968
969
970
971
	/*
	 * Some devices, such as AVR8, will output all 1's instead
	 * of TDI input value at end of chain.  Allow those values
	 * instead of failing.
	 */
	return idcode == END_OF_CHAIN_FLAG || idcode == 0xFFFFFFFF;
972
973
974
975
976
977
978
}

/**
 * This helper checks that remaining bits in the examined chain data are
 * all as expected, but a single JTAG device requires only 64 bits to be
 * read back correctly.  This can help identify and diagnose problems
 * with the JTAG chain earlier, gives more helpful/explicit error messages.
979
 * Returns TRUE iff garbage was found.
980
 */
981
static bool jtag_examine_chain_end(uint8_t *idcodes, unsigned count, unsigned max)
982
983
{
	bool triggered = false;
984
	for (; count < max - 31; count += 32)
985
	{
986
		uint32_t idcode = buf_get_u32(idcodes, count, 32);
987
988
989

		/* do not trigger the warning if the data looks good */
		if (jtag_idcode_is_final(idcode))
990
991
			continue;
		LOG_WARNING("Unexpected idcode after end of chain: %d 0x%08x",
992
					count, (unsigned int)idcode);
993
994
		triggered = true;
	}
995
	return triggered;
996
997
}

998
static bool jtag_examine_chain_match_tap(const struct jtag_tap *tap)
999
{
1000
1001
	/* ignore expected BYPASS codes; warn otherwise */
	if (0 == tap->expected_ids_cnt && !tap->idcode)
1002
1003
1004
		return true;

	/* Loop over the expected identification codes and test for a match */
David Brownell's avatar
David Brownell committed
1005
1006
1007
	unsigned ii, limit = tap->expected_ids_cnt;

	for (ii = 0; ii < limit; ii++)
1008
1009
	{
		if (tap->idcode == tap->expected_ids[ii])
dbrownell's avatar
dbrownell committed
1010
			return true;
1011
1012
1013
1014

		/* treat "-expected-id 0" as a "don't-warn" wildcard */
		if (0 == tap->expected_ids[ii])
			return true;
1015
1016
	}

1017
1018
	/* If none of the expected ids matched, warn */
	jtag_examine_chain_display(LOG_LVL_WARNING, "UNEXPECTED",
1019
			tap->dotted_name, tap->idcode);
David Brownell's avatar
David Brownell committed
1020
	for (ii = 0; ii < limit; ii++)
1021
1022
	{
		char msg[32];
David Brownell's avatar
David Brownell committed
1023
1024

		snprintf(msg, sizeof(msg), "expected %u of %u", ii + 1, limit);
1025
1026
1027
1028
1029
1030
1031
		jtag_examine_chain_display(LOG_LVL_ERROR, msg,
				tap->dotted_name, tap->expected_ids[ii]);
	}
	return false;
}

/* Try to examine chain layout according to IEEE 1149.1 §12
1032
 * This is called a "blind interrogation" of the scan chain.
1033
 */
1034
static int jtag_examine_chain(void)
1035
{
zwelch's avatar
zwelch committed
1036
	uint8_t idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1037
	unsigned bit_count;
1038
	int retval;
David Brownell's avatar
David Brownell committed
1039
1040
	int tapcount = 0;
	bool autoprobe = false;
1041

1042
1043
1044
	/* DR scan to collect BYPASS or IDCODE register contents.
	 * Then make sure the scan data has both ones and zeroes.
	 */
1045
	LOG_DEBUG("DR scan interrogation for IDCODE/BYPASS");
1046
1047
1048
	retval = jtag_examine_chain_execute(idcode_buffer, JTAG_MAX_CHAIN_SIZE);
	if (retval != ERROR_OK)
		return retval;
1049
1050
1051
1052
	if (!jtag_examine_chain_check(idcode_buffer, JTAG_MAX_CHAIN_SIZE))
		return ERROR_JTAG_INIT_FAILED;

	/* point at the 1st tap */
1053
	struct jtag_tap *tap = jtag_tap_next_enabled(NULL);
David Brownell's avatar
David Brownell committed
1054
1055
1056

	if (!tap)
		autoprobe = true;
1057

1058
	for (bit_count = 0;
1059
1060
			tap && bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;
			tap = jtag_tap_next_enabled(tap))
1061
	{
1062
		uint32_t idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1063

1064
1065
		if ((idcode & 1) == 0)
		{
1066
			/* Zero for LSB indicates a device in bypass */
1067
			LOG_INFO("TAP %s does not have IDCODE",
dbrownell's avatar
dbrownell committed
1068
					tap->dotted_name);
1069
			idcode = 0;
oharboe's avatar
oharboe committed
1070
			tap->hasidcode = false;
1071
1072
1073
1074
1075

			bit_count += 1;
		}
		else
		{
1076
			/* Friendly devices support IDCODE */
1077
			tap->hasidcode = true;
1078
1079
			jtag_examine_chain_display(LOG_LVL_INFO,
					"tap/device found",
dbrownell's avatar
dbrownell committed
1080
					tap->dotted_name, idcode);
1081
1082
1083
1084
1085

			bit_count += 32;
		}
		tap->idcode = idcode;

1086
		/* ensure the TAP ID matches what was expected */
1087
		if (!jtag_examine_chain_match_tap(tap))
1088
			retval = ERROR_JTAG_INIT_SOFT_FAIL;
1089
1090
	}

1091
1092
1093
1094
1095
1096
1097
	/* Fail if too many TAPs were enabled for us to verify them all. */
	if (tap) {
		LOG_ERROR("Too many TAPs enabled; '%s' ignored.",
				tap->dotted_name);
		return ERROR_JTAG_INIT_FAILED;
	}

David Brownell's avatar
David Brownell committed
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
	/* if autoprobing, the tap list is still empty ... populate it! */
	while (autoprobe && bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31) {
		uint32_t idcode;
		char buf[12];

		/* Is there another TAP? */
		idcode = buf_get_u32(idcode_buffer, bit_count, 32);
		if (jtag_idcode_is_final(idcode))
			break;

		/* Default everything in this TAP except IR length.
		 *
		 * REVISIT create a jtag_alloc(chip, tap) routine, and
		 * share it with jim_newtap_cmd().
		 */
		tap = calloc(1, sizeof *tap);
		if (!tap)
			return ERROR_FAIL;

		sprintf(buf, "auto%d", tapcount++);
		tap->chip = strdup(buf);
		tap->tapname = strdup("tap");

		sprintf(buf, "%s.%s", tap->chip, tap->tapname);
		tap->dotted_name = strdup(buf);

		/* tap->ir_length == 0 ... signifying irlen autoprobe */
		tap->ir_capture_mask = 0x03;
		tap->ir_capture_value = 0x01;

		tap->enabled = true;

		if ((idcode & 1) == 0) {
			bit_count += 1;
			tap->hasidcode = false;
		} else {
			bit_count += 32;
			tap->hasidcode = true;
			tap->idcode = idcode;

			tap->expected_ids_cnt = 1;
			tap->expected_ids = malloc(sizeof(uint32_t));
			tap->expected_ids[0] = idcode;
		}

		LOG_WARNING("AUTO %s - use \"jtag newtap "
				"%s %s -expected-id 0x%8.8" PRIx32 " ...\"",
				tap->dotted_name, tap->chip, tap->tapname,
				tap->idcode);

		jtag_tap_init(tap);
	}

1151
1152
1153
1154
1155
1156
	/* After those IDCODE or BYPASS register values should be
	 * only the data we fed into the scan chain.
	 */
	if (jtag_examine_chain_end(idcode_buffer, bit_count,
			8 * sizeof(idcode_buffer))) {
		LOG_ERROR("double-check your JTAG setup (interface, "
1157
				"speed, missing TAPs, ...)");
1158
1159
1160
		return ERROR_JTAG_INIT_FAILED;
	}

1161
1162
1163
1164
	/* Return success or, for backwards compatibility if only
	 * some IDCODE values mismatched, a soft/continuable fault.
	 */
	return retval;
1165
1166
}

1167
1168
1169
1170
/*
 * Validate the date loaded by entry to the Capture-IR state, to help
 * find errors related to scan chain configuration (wrong IR lengths)
 * or communication.
1171
1172
1173
 *
 * Entry state can be anything.  On non-error exit, all TAPs are in
 * bypass mode.  On error exits, the scan chain is reset.
1174
1175
 */
static int jtag_validate_ircapture(void)
1176
{
1177
	struct jtag_tap *tap;
1178
	int total_ir_length = 0;
zwelch's avatar
zwelch committed
1179
	uint8_t *ir_test = NULL;
1180
	struct scan_field field;
1181
	int val;
1182
	int chain_pos = 0;
1183
	int retval;
1184

David Brownell's avatar
David Brownell committed
1185
	/* when autoprobing, accomodate huge IR lengths */
1186
1187
	for (tap = NULL, total_ir_length = 0;
			(tap = jtag_tap_next_enabled(tap)) != NULL;
David Brownell's avatar
David Brownell committed
1188
1189
1190
1191
			total_ir_length += tap->ir_length) {
		if (tap->ir_length == 0)
			total_ir_length += JTAG_IRLEN_MAX;
	}
1192

1193
	/* increase length to add 2 bit sentinel after scan */
1194
	total_ir_length += 2;
1195

Zachary T Welch's avatar
Zachary T Welch committed
1196
	ir_test = malloc(DIV_ROUND_UP(total_ir_length, 8));
1197
1198
1199
	if (ir_test == NULL)
		return ERROR_FAIL;

1200
	/* after this scan, all TAPs will capture BYPASS instructions */
1201
1202
1203
1204
1205
1206
1207
	buf_set_ones(ir_test, total_ir_length);

	field.tap = NULL;
	field.num_bits = total_ir_length;
	field.out_value = ir_test;
	field.in_value = ir_test;

1208
	jtag_add_plain_ir_scan(1, &field, TAP_IDLE);
1209

1210
	LOG_DEBUG("IR capture validation scan");
oharboe's avatar
oharboe committed
1211
1212
	retval = jtag_execute_queue();
	if (retval != ERROR_OK)
1213
		goto done;
1214
1215
1216

	tap = NULL;
	chain_pos = 0;
1217

zwelch's avatar
zwelch committed
1218
	for (;;) {
1219
		tap = jtag_tap_next_enabled(tap);
zwelch's avatar
zwelch committed
1220
		if (tap == NULL) {
1221
1222
1223
			break;
		}

David Brownell's avatar
David Brownell committed
1224
1225
1226
		/* If we're autoprobing, guess IR lengths.  They must be at
		 * least two bits.  Guessing will fail if (a) any TAP does
		 * not conform to the JTAG spec; or (b) when the upper bits
David Brownell's avatar
David Brownell committed
1227
1228
1229
1230
1231
1232
1233
1234
		 * captured from some conforming TAP are nonzero.  Or if
		 * (c) an IR length is longer than 32 bits -- which is only
		 * an implementation limit, which could someday be raised.
		 *
		 * REVISIT optimization:  if there's a *single* TAP we can
		 * lift restrictions (a) and (b) by scanning a recognizable
		 * pattern before the all-ones BYPASS.  Check for where the
		 * pattern starts in the result, instead of an 0...01 value.
David Brownell's avatar
David Brownell committed
1235
1236
1237
1238
1239
1240
1241
1242
		 *
		 * REVISIT alternative approach: escape to some tcl code
		 * which could provide more knowledge, based on IDCODE; and
		 * only guess when that has no success.
		 */
		if (tap->ir_length == 0) {
			tap->ir_length = 2;
			while ((val = buf_get_u32(ir_test, chain_pos,
David Brownell's avatar
David Brownell committed
1243
1244
						tap->ir_length + 1)) == 1
					&& tap->ir_length <= 32) {
David Brownell's avatar
David Brownell committed
1245
1246
1247
1248
1249
1250
				tap->ir_length++;
			}
			LOG_WARNING("AUTO %s - use \"... -irlen %d\"",
					jtag_tap_name(tap), tap->ir_length);
		}

1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
		/* Validate the two LSBs, which must be 01 per JTAG spec.
		 *
		 * Or ... more bits could be provided by TAP declaration.
		 * Plus, some taps (notably in i.MX series chips) violate
		 * this part of the JTAG spec, so their capture mask/value
		 * attributes might disable this test.
		 */
		val = buf_get_u32(ir_test, chain_pos, tap->ir_length);
		if ((val & tap->ir_capture_mask) != tap->ir_capture_value) {
			LOG_ERROR("%s: IR capture error; saw 0x%0*x not 0x%0*x",
					jtag_tap_name(tap),
					(tap->ir_length + 7) / tap->ir_length,
					val,
					(tap->ir_length + 7) / tap->ir_length,
David Brownell's avatar
David Brownell committed
1265
					(unsigned) tap->ir_capture_value);
1266
1267
1268

			retval = ERROR_JTAG_INIT_FAILED;
			goto done;
1269
		}
1270
1271
		LOG_DEBUG("%s: IR capture 0x%0*x", jtag_tap_name(tap),
				(tap->ir_length + 7) / tap->ir_length, val);
1272
1273
1274
		chain_pos += tap->ir_length;
	}

1275
	/* verify the '11' sentinel we wrote is returned at the end */
1276
1277
1278
1279
	val = buf_get_u32(ir_test, chain_pos, 2);
	if (val != 0x3)
	{
		char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1280
1281
1282

		LOG_ERROR("IR capture error at bit %d, saw 0x%s not 0x...3",
				chain_pos, cbuf);
1283
		free(cbuf);
1284
		retval = ERROR_JTAG_INIT_FAILED;
1285
1286
	}

1287
done:
1288
	free(ir_test);
1289
1290
1291
1292
1293
	if (retval != ERROR_OK) {
		jtag_add_tlr();
		jtag_execute_queue();
	}
	return retval;
1294
1295
1296
}


1297
void jtag_tap_init(struct jtag_tap *tap)
1298
{
1299
1300
1301
	unsigned ir_len_bits;
	unsigned ir_len_bytes;

David Brownell's avatar
David Brownell committed
1302
1303
	/* if we're autoprobing, cope with potentially huge ir_length */
	ir_len_bits = tap->ir_length ? : JTAG_IRLEN_MAX;
Zachary T Welch's avatar
Zachary T Welch committed
1304
	ir_len_bytes = DIV_ROUND_UP(ir_len_bits, 8);
1305

1306
1307
1308
1309
1310
1311
1312
	tap->expected = calloc(1, ir_len_bytes);
	tap->expected_mask = calloc(1, ir_len_bytes);
	tap->cur_instr = malloc(ir_len_bytes);

	/// @todo cope better with ir_length bigger than 32 bits
	if (ir_len_bits > 32)
		ir_len_bits = 32;
1313

1314
1315
1316
1317
	buf_set_u32(tap->expected, 0, ir_len_bits, tap->ir_capture_value);
	buf_set_u32(tap->expected_mask, 0, ir_len_bits, tap->ir_capture_mask);

	// TAP will be in bypass mode after jtag_validate_ircapture()
1318
	tap->bypass = 1;
1319
1320
	buf_set_ones(tap->cur_instr, tap->ir_length);

1321
1322
1323
1324
1325
1326
	// register the reset callback for the TAP
	jtag_register_event_callback(&jtag_reset_callback, tap);

	LOG_DEBUG("Created Tap: %s @ abs position %d, "