core.c 43.3 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
46
47
48
 *                                                                         *
 *   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;

static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state),
		int in_num_fields, scan_field_t *in_fields, tap_state_t state);

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
81
82
83
84
85
86
87

/**
 * List all TAPs that have been created.
 */
static jtag_tap_t *__jtag_all_taps = NULL;
/**
 * 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
typedef struct jtag_event_callback_s
{
	jtag_event_handler_t          callback;
	void*                         priv;
	struct jtag_event_callback_s* next;
} jtag_event_callback_t;

108
/* callbacks to inform high-level handlers about JTAG state changes */
109
static jtag_event_callback_t *jtag_event_callbacks;
110
111
112

/* speed in kHz*/
static int speed_khz = 0;
113
114
115
/* 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;
116
static int jtag_speed = 0;
117

118
static struct jtag_interface_s *jtag = NULL;
119
120
121
122

/* configuration */
jtag_interface_t *jtag_interface = NULL;

123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
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;
}

140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
/************/

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;
}

/************/
166

167
168
169
170
171
172
173
174
175
176
177
178
179
180
jtag_tap_t *jtag_all_taps(void)
{
	return __jtag_all_taps;
};

unsigned jtag_tap_count(void)
{
	return jtag_num_taps;
}

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

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

	jtag_tap_t **tap = &__jtag_all_taps;
zwelch's avatar
zwelch committed
196
	while (*tap != NULL)
197
198
199
200
		tap = &(*tap)->next_tap;
	*tap = t;
}

zwelch's avatar
zwelch committed
201
202
203
204
205
206
207
208
209
210
211
/* returns a pointer to the n-th device in the scan chain */
static inline jtag_tap_t *jtag_tap_by_position(unsigned n)
{
	jtag_tap_t *t = jtag_all_taps();

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

	return t;
}

212
213
214
215
jtag_tap_t *jtag_tap_by_string(const char *s)
{
	/* try by name first */
	jtag_tap_t *t = jtag_all_taps();
zwelch's avatar
zwelch committed
216

217
218
219
220
221
222
223
224
	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 */
225
226
	unsigned n;
	if (parse_uint(s, &n) != ERROR_OK)
227
228
		return NULL;

zwelch's avatar
zwelch committed
229
230
231
232
233
234
235
236
237
238
	/* 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;
239
240
241
242
243
244
245
246
247
248
249
250
251
}

jtag_tap_t *jtag_tap_by_jim_obj(Jim_Interp *interp, Jim_Obj *o)
{
	const char *cp = Jim_GetString(o, NULL);
	jtag_tap_t *t = cp ? jtag_tap_by_string(cp) : NULL;
	if (NULL == cp)
		cp = "(unknown)";
	if (NULL == t)
		Jim_SetResult_sprintf(interp, "Tap '%s' could not be found", cp);
	return t;
}

252
253
254
255
256
257
258
259
260
261
262
263
jtag_tap_t* jtag_tap_next_enabled(jtag_tap_t* p)
{
	p = p ? p->next_tap : jtag_all_taps();
	while (p)
	{
		if (p->enabled)
			return p;
		p = p->next_tap;
	}
	return NULL;
}

264
265
266
267
268
269
const char *jtag_tap_name(const jtag_tap_t *tap)
{
	return (tap == NULL) ? "(unknown)" : tap->dotted_name;
}


zwelch's avatar
zwelch committed
270
int jtag_register_event_callback(jtag_event_handler_t callback, void *priv)
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
{
	jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;

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

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

	(*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
	(*callbacks_p)->callback = callback;
	(*callbacks_p)->priv = priv;
	(*callbacks_p)->next = NULL;

	return ERROR_OK;
}

zwelch's avatar
zwelch committed
294
int jtag_unregister_event_callback(jtag_event_handler_t callback, void *priv)
295
{
zwelch's avatar
zwelch committed
296
297
	jtag_event_callback_t **callbacks_p;
	jtag_event_callback_t **next;
298
299
300
301
302
303

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

zwelch's avatar
zwelch committed
304
305
306
	for (callbacks_p = &jtag_event_callbacks;
			*callbacks_p != NULL;
			callbacks_p = next)
307
	{
zwelch's avatar
zwelch committed
308
309
310
311
312
		next = &((*callbacks_p)->next);

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

313
314
315
316
317
318
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)
{
	jtag_event_callback_t *callback = jtag_event_callbacks;

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

	while (callback)
	{
zwelch's avatar
zwelch committed
331
332
333
334
		jtag_event_callback_t *next;

		/* callback may remove itself */
		next = callback->next;
335
		callback->callback(event, callback->priv);
zwelch's avatar
zwelch committed
336
		callback = next;
337
338
339
340
341
342
343
344
345
346
347
348
349
350
	}

	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
351
	assert(state != TAP_INVALID);
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372

	cmd_queue_cur_state = state;
}

void jtag_alloc_in_value32(scan_field_t *field)
{
	interface_jtag_alloc_in_value32(field);
}

void jtag_add_ir_scan_noverify(int in_count, const scan_field_t *in_fields,
		tap_state_t state)
{
	jtag_prelude(state);

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


void jtag_add_ir_scan(int in_num_fields, scan_field_t *in_fields, tap_state_t state)
{
373
374
	assert(state != TAP_RESET);

zwelch's avatar
zwelch committed
375
	if (jtag_verify && jtag_verify_capture_ir)
376
377
378
379
380
381
382
383
	{
		/* 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
384
385
			in_fields[j].check_value = in_fields[j].tap->expected;
			in_fields[j].check_mask = in_fields[j].tap->expected_mask;
386
387
388
389
390
391
392
393
394
395
396
		}
		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);
	}
}

void jtag_add_plain_ir_scan(int in_num_fields, const scan_field_t *in_fields,
		tap_state_t state)
{
397
398
	assert(state != TAP_RESET);

399
400
401
402
403
404
405
	jtag_prelude(state);

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

406
void jtag_add_callback(jtag_callback1_t f, jtag_callback_data_t data0)
407
{
408
	interface_jtag_add_callback(f, data0);
409
410
}

411
void jtag_add_callback4(jtag_callback_t f, jtag_callback_data_t data0,
412
413
414
		jtag_callback_data_t data1, jtag_callback_data_t data2,
		jtag_callback_data_t data3)
{
415
	interface_jtag_add_callback4(f, data0, data1, data2, data3);
416
417
}

418
419
static int jtag_check_value_inner(uint8_t *captured, uint8_t *in_check_value,
		uint8_t *in_check_mask, int num_bits);
420

421
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)
422
{
423
	return jtag_check_value_inner((uint8_t *)data0, (uint8_t *)data1, (uint8_t *)data2, (int)data3);
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
}

static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state),
		int in_num_fields, scan_field_t *in_fields, tap_state_t state)
{
	for (int i = 0; i < in_num_fields; i++)
	{
		struct scan_field_s *field = &in_fields[i];
		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 */
447
			jtag_add_callback4(jtag_check_value_mask_callback, (jtag_callback_data_t)in_fields[i].in_value,
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
				(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;
		}
	}
}

void jtag_add_dr_scan_check(int in_num_fields, scan_field_t *in_fields, tap_state_t state)
{
	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);
	}
}


void jtag_add_dr_scan(int in_num_fields, const scan_field_t *in_fields,
		tap_state_t state)
{
478
	assert(state != TAP_RESET);
479

480
481
482
483
484
485
486
487
488
489
	jtag_prelude(state);

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

void jtag_add_plain_dr_scan(int in_num_fields, const scan_field_t *in_fields,
		tap_state_t state)
{
490
	assert(state != TAP_RESET);
491

492
493
494
495
496
497
498
499
	jtag_prelude(state);

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

void jtag_add_dr_out(jtag_tap_t* tap,
500
		int num_fields, const int* num_bits, const uint32_t* value,
501
502
		tap_state_t end_state)
{
503
	assert(end_state != TAP_RESET);
504
505
506
507
508
509
510
511
512
513
514
515
516
	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());
517

518
	/* NOTE: order here matches TRST path in jtag_add_reset() */
519
	jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
520
	jtag_notify_event(JTAG_TRST_ASSERTED);
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
}

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;
		}

544
		if (tap_state_transition(cur_state, true)  != path[i]
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
		  && 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];
}

561
562
563
564
int jtag_add_statemove(tap_state_t goal_state)
{
	tap_state_t cur_state = cmd_queue_cur_state;

565
	LOG_DEBUG("cur_state=%s goal_state=%s",
566
		tap_state_name(cur_state),
567
		tap_state_name(goal_state));
568
569


570
571
572
573
	/* 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)
574
		jtag_add_tlr();
575
576
577
	else if (goal_state == cur_state)
		/* nothing to do */ ;

578
	else if (tap_is_state_stable(cur_state) && tap_is_state_stable(goal_state))
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
	{
		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];
		assert(tms_count < DIM(moves));

		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);
	}
595
	else if (tap_state_transition(cur_state, true)  == goal_state
596
		||   tap_state_transition(cur_state, false) == goal_state)
597
598
599
600
601
602
603
604
605
606
	{
		jtag_add_pathmove(1, &goal_state);
	}

	else
		return ERROR_FAIL;

	return ERROR_OK;
}

607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
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;
634
	int new_srst = 0;
635
	int new_trst = 0;
636

637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
	/* 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;
	}

659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
	/* 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;
	}

676
677
678
	/* Maybe change TRST and/or SRST signal state */
	if (jtag_srst != new_srst || jtag_trst != new_trst) {
		int retval;
679

680
681
682
683
684
685
686
687
688
689
		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;
		}
690
	}
691
692
693
694
695

	/* 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
696
		{
697
			LOG_DEBUG("SRST line asserted");
oharboe's avatar
oharboe committed
698
699
700
			if (jtag_nsrst_assert_width)
				jtag_add_sleep(jtag_nsrst_assert_width * 1000);
		}
701
702
703
704
705
		else {
			LOG_DEBUG("SRST line released");
			if (jtag_nsrst_delay)
				jtag_add_sleep(jtag_nsrst_delay * 1000);
		}
706
707
	}

708
709
710
711
712
713
714
715
	/* 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");
716
717
718
		jtag_set_end_state(TAP_RESET);
		jtag_add_tlr();

719
720
721
722
723
	} 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
724
725
			if (jtag_ntrst_assert_width)
				jtag_add_sleep(jtag_ntrst_assert_width * 1000);
726
727
728
729
		} else {
			LOG_DEBUG("TRST line released");
			if (jtag_ntrst_delay)
				jtag_add_sleep(jtag_ntrst_delay * 1000);
730

731
732
733
734
735
736
			/* 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);
737
			jtag_notify_event(JTAG_TRST_ASSERTED);
738
		}
739
740
741
742
743
744
745
746
747
748
	}
}

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
749
	if (state != TAP_INVALID)
750
751
752
753
754
755
756
757
758
		cmd_queue_end_state = state;
	return cmd_queue_end_state;
}

tap_state_t jtag_get_end_state(void)
{
	return cmd_queue_end_state;
}

759
void jtag_add_sleep(uint32_t us)
760
761
762
763
764
765
{
	/// @todo Here, keep_alive() appears to be a layering violation!!!
	keep_alive();
	jtag_set_error(interface_jtag_add_sleep(us));
}

766
767
static int jtag_check_value_inner(uint8_t *captured, uint8_t *in_check_value,
		uint8_t *in_check_mask, int num_bits)
768
769
770
771
772
773
774
775
776
777
{
	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
778
	if (compare_failed) {
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
		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);
802
803
		}

804
		retval = ERROR_JTAG_QUEUE_FAILED;
805
806
807
808
	}
	return retval;
}

zwelch's avatar
zwelch committed
809
void jtag_check_value_mask(scan_field_t *field, uint8_t *value, uint8_t *mask)
810
811
812
{
	assert(field->in_value != NULL);

zwelch's avatar
zwelch committed
813
	if (value == NULL)
814
815
816
817
818
819
820
	{
		/* no checking to do */
		return;
	}

	jtag_execute_queue_noclear();

zwelch's avatar
zwelch committed
821
	int retval = jtag_check_value_inner(field->in_value, value, mask, field->num_bits);
822
823
824
825
826
827
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
	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)
{
	jtag_tap_t *tap = priv;

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

865
		/* current instruction is either BYPASS or IDCODE */
866
867
868
869
870
871
872
		buf_set_ones(tap->cur_instr, tap->ir_length);
		tap->bypass = 1;
	}

	return ERROR_OK;
}

873
void jtag_sleep(uint32_t us)
874
875
876
877
{
	alive_sleep(us/1000);
}

878
879
880
881
/* 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.
 */
882
883
884
885
886
887
#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)

888
889
890
/* 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.
 */
891
892
#define END_OF_CHAIN_FLAG	0x000000ff

David Brownell's avatar
David Brownell committed
893
894
895
/* a larger IR length than we ever expect to autoprobe */
#define JTAG_IRLEN_MAX		60

zwelch's avatar
zwelch committed
896
static int jtag_examine_chain_execute(uint8_t *idcode_buffer, unsigned num_idcode)
897
898
899
900
901
902
903
904
905
906
{
	scan_field_t field = {
			.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++)
907
		buf_set_u32(idcode_buffer, i * 32, 32, END_OF_CHAIN_FLAG);
908

909
910
	jtag_add_plain_dr_scan(1, &field, TAP_DRPAUSE);
	jtag_add_tlr();
911
912
913
	return jtag_execute_queue();
}

zwelch's avatar
zwelch committed
914
static bool jtag_examine_chain_check(uint8_t *idcodes, unsigned count)
915
{
zwelch's avatar
zwelch committed
916
917
	uint8_t zero_check = 0x0;
	uint8_t one_check = 0xff;
918
919
920
921
922
923
924
925

	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,
926
927
928
929
930
931
932
933
934
	 * 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
	 */
935
936
	if (zero_check == 0x00 || one_check == 0xff)
	{
937
938
939
		LOG_ERROR("JTAG scan chain interrogation failed: all %s",
				(zero_check == 0x00) ? "zeroes" : "ones");
		LOG_ERROR("Check JTAG interface, timings, target power, etc.");
940
941
942
943
944
945
		return false;
	}
	return true;
}

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

958
static bool jtag_idcode_is_final(uint32_t idcode)
959
{
960
961
962
963
964
965
	/*
	 * 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;
966
967
968
969
970
971
972
}

/**
 * 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.
973
 * Returns TRUE iff garbage was found.
974
 */
975
static bool jtag_examine_chain_end(uint8_t *idcodes, unsigned count, unsigned max)
976
977
{
	bool triggered = false;
978
	for (; count < max - 31; count += 32)
979
	{
980
		uint32_t idcode = buf_get_u32(idcodes, count, 32);
981
982
983

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

static bool jtag_examine_chain_match_tap(const struct jtag_tap_s *tap)
{
994
995
	/* ignore expected BYPASS codes; warn otherwise */
	if (0 == tap->expected_ids_cnt && !tap->idcode)
996
997
998
		return true;

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