core.c 44.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
 *                                                                         *
 *   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 "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;

45
46
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);
47

48
49
50
51
52
53
54
55
56
57
58
/**
 * 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;
59

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

68
69
/*
 * JTAG adapters must initialize with TRST and SRST de-asserted
70
71
72
 * (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.
73
 */
74
75
static int jtag_trst = -1;
static int jtag_srst = -1;
76
77
78
79

/**
 * List all TAPs that have been created.
 */
80
static struct jtag_tap *__jtag_all_taps = NULL;
81
82
83
84
85
86
/**
 * 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;

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

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

/* 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
97
98
static int jtag_nsrst_assert_width = 0; /* width of assertion */
static int jtag_ntrst_assert_width = 0; /* width of assertion */
99

100
101
102
103
104
105
106
107
108
109
110
111
/**
 * 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;
};
112

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

/* speed in kHz*/
static int speed_khz = 0;
118
119
120
/* 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;
121
static int jtag_speed = 0;
122

123
static struct jtag_interface *jtag = NULL;
124
125

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

128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
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;
}

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

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

/************/
171

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

unsigned jtag_tap_count(void)
{
	return jtag_num_taps;
}

unsigned jtag_tap_count_enabled(void)
{
184
	struct jtag_tap *t = jtag_all_taps();
185
	unsigned n = 0;
zwelch's avatar
zwelch committed
186
	while (t)
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.
196
void jtag_tap_add(struct jtag_tap *t)
197
198
199
{
	t->abs_chain_position = jtag_num_taps++;

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

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

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

	return t;
}

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

222
223
224
225
226
227
228
229
	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 */
230
231
	unsigned n;
	if (parse_uint(s, &n) != ERROR_OK)
232
233
		return NULL;

zwelch's avatar
zwelch committed
234
235
236
237
238
239
240
241
242
243
	/* 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;
244
245
}

246
struct jtag_tap* jtag_tap_next_enabled(struct jtag_tap* p)
247
248
249
250
251
252
253
254
255
256
257
{
	p = p ? p->next_tap : jtag_all_taps();
	while (p)
	{
		if (p->enabled)
			return p;
		p = p->next_tap;
	}
	return NULL;
}

258
const char *jtag_tap_name(const struct jtag_tap *tap)
259
260
261
262
263
{
	return (tap == NULL) ? "(unknown)" : tap->dotted_name;
}


zwelch's avatar
zwelch committed
264
int jtag_register_event_callback(jtag_event_handler_t callback, void *priv)
265
{
266
	struct jtag_event_callback **callbacks_p = &jtag_event_callbacks;
267
268
269
270
271
272
273
274
275
276
277
278
279

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

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

280
	(*callbacks_p) = malloc(sizeof(struct jtag_event_callback));
281
282
283
284
285
286
287
	(*callbacks_p)->callback = callback;
	(*callbacks_p)->priv = priv;
	(*callbacks_p)->next = NULL;

	return ERROR_OK;
}

zwelch's avatar
zwelch committed
288
int jtag_unregister_event_callback(jtag_event_handler_t callback, void *priv)
289
{
290
291
	struct jtag_event_callback **callbacks_p;
	struct jtag_event_callback **next;
292
293
294
295
296
297

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

zwelch's avatar
zwelch committed
298
299
300
	for (callbacks_p = &jtag_event_callbacks;
			*callbacks_p != NULL;
			callbacks_p = next)
301
	{
zwelch's avatar
zwelch committed
302
303
304
305
306
		next = &((*callbacks_p)->next);

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

307
308
309
310
311
312
313
314
315
316
317
318
		if ((*callbacks_p)->callback == callback)
		{
			free(*callbacks_p);
			*callbacks_p = *next;
		}
	}

	return ERROR_OK;
}

int jtag_call_event_callbacks(enum jtag_event event)
{
319
	struct jtag_event_callback *callback = jtag_event_callbacks;
320
321
322
323
324

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

	while (callback)
	{
325
		struct jtag_event_callback *next;
zwelch's avatar
zwelch committed
326
327
328

		/* callback may remove itself */
		next = callback->next;
329
		callback->callback(event, callback->priv);
zwelch's avatar
zwelch committed
330
		callback = next;
331
332
333
334
335
336
337
338
339
340
341
342
343
344
	}

	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
345
	assert(state != TAP_INVALID);
346
347
348
349

	cmd_queue_cur_state = state;
}

350
void jtag_alloc_in_value32(struct scan_field *field)
351
352
353
354
{
	interface_jtag_alloc_in_value32(field);
}

355
void jtag_add_ir_scan_noverify(int in_count, const struct scan_field *in_fields,
356
357
358
359
360
361
362
363
364
		tap_state_t state)
{
	jtag_prelude(state);

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


365
void jtag_add_ir_scan(int in_num_fields, struct scan_field *in_fields, tap_state_t state)
366
{
367
368
	assert(state != TAP_RESET);

zwelch's avatar
zwelch committed
369
	if (jtag_verify && jtag_verify_capture_ir)
370
371
372
373
374
375
376
377
	{
		/* 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
378
379
			in_fields[j].check_value = in_fields[j].tap->expected;
			in_fields[j].check_mask = in_fields[j].tap->expected_mask;
380
381
382
383
384
385
386
387
		}
		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);
	}
}

388
void jtag_add_plain_ir_scan(int in_num_fields, const struct scan_field *in_fields,
389
390
		tap_state_t state)
{
391
392
	assert(state != TAP_RESET);

393
394
395
396
397
398
399
	jtag_prelude(state);

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

400
401
static int jtag_check_value_inner(uint8_t *captured, uint8_t *in_check_value,
		uint8_t *in_check_mask, int num_bits);
402

403
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)
404
{
405
	return jtag_check_value_inner((uint8_t *)data0, (uint8_t *)data1, (uint8_t *)data2, (int)data3);
406
407
}

408
409
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)
410
411
412
{
	for (int i = 0; i < in_num_fields; i++)
	{
413
		struct scan_field *field = &in_fields[i];
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
		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 */
429
			jtag_add_callback4(jtag_check_value_mask_callback, (jtag_callback_data_t)in_fields[i].in_value,
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
				(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;
		}
	}
}

445
void jtag_add_dr_scan_check(int in_num_fields, struct scan_field *in_fields, tap_state_t state)
446
447
448
449
450
451
452
453
454
455
456
{
	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);
	}
}


457
void jtag_add_dr_scan(int in_num_fields, const struct scan_field *in_fields,
458
459
		tap_state_t state)
{
460
	assert(state != TAP_RESET);
461

462
463
464
465
466
467
468
	jtag_prelude(state);

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

469
void jtag_add_plain_dr_scan(int in_num_fields, const struct scan_field *in_fields,
470
471
		tap_state_t state)
{
472
	assert(state != TAP_RESET);
473

474
475
476
477
478
479
480
481
482
483
484
	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_tlr(void)
{
	jtag_prelude(TAP_RESET);
	jtag_set_error(interface_jtag_add_tlr());
485

486
	/* NOTE: order here matches TRST path in jtag_add_reset() */
487
	jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
488
	jtag_notify_event(JTAG_TRST_ASSERTED);
489
490
}

491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
/**
 * If supported by the underlying adapter, this clocks a raw bit sequence
 * onto TMS for switching betwen JTAG and SWD modes.
 *
 * DO NOT use this to bypass the integrity checks and logging provided
 * by the jtag_add_pathmove() and jtag_add_statemove() calls.
 *
 * @param nbits How many bits to clock out.
 * @param seq The bit sequence.  The LSB is bit 0 of seq[0].
 * @param state The JTAG tap state to record on completion.  Use
 *	TAP_INVALID to represent being in in SWD mode.
 *
 * @todo Update naming conventions to stop assuming everything is JTAG.
 */
int jtag_add_tms_seq(unsigned nbits, const uint8_t *seq, enum tap_state state)
{
	int retval;

	if (!(jtag->supported & DEBUG_CAP_TMS_SEQ))
		return ERROR_JTAG_NOT_IMPLEMENTED;

	jtag_checks();
	cmd_queue_cur_state = state;

	retval = interface_add_tms_seq(nbits, seq);
	jtag_set_error(retval);
	return retval;
}

520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
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;
		}

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

558
559
560
561
int jtag_add_statemove(tap_state_t goal_state)
{
	tap_state_t cur_state = cmd_queue_cur_state;

562
563
564
565
566
567
	if (goal_state != cur_state)
	{
		LOG_DEBUG("cur_state=%s goal_state=%s",
			tap_state_name(cur_state),
			tap_state_name(goal_state));
	}
568

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

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

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

	else
		return ERROR_FAIL;

	return ERROR_OK;
}

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

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

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

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

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

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

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

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

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

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

tap_state_t jtag_get_end_state(void)
{
	return cmd_queue_end_state;
}

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

765
766
static int jtag_check_value_inner(uint8_t *captured, uint8_t *in_check_value,
		uint8_t *in_check_mask, int num_bits)
767
768
{
	int retval = ERROR_OK;
David Brownell's avatar
David Brownell committed
769
	int compare_failed;
770
771
772
773
774
775

	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
776
	if (compare_failed) {
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
		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);
800
801
		}

802
		retval = ERROR_JTAG_QUEUE_FAILED;
803
804
805
806
	}
	return retval;
}

807
void jtag_check_value_mask(struct scan_field *field, uint8_t *value, uint8_t *mask)
808
809
810
{
	assert(field->in_value != NULL);

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

	jtag_execute_queue_noclear();

zwelch's avatar
zwelch committed
819
	int retval = jtag_check_value_inner(field->in_value, value, mask, field->num_bits);
820
821
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
	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)
{
857
	struct jtag_tap *tap = priv;
858
859
860

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

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

	return ERROR_OK;
}

871
void jtag_sleep(uint32_t us)
872
873
874
875
{
	alive_sleep(us/1000);
}

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

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

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

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

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

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

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

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

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

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

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

990
static bool jtag_examine_chain_match_tap(const struct jtag_tap *tap)
991
{
992
993
	uint32_t idcode = tap->idcode;

994
	/* ignore expected BYPASS codes; warn otherwise */
995
	if (0 == tap->expected_ids_cnt && !idcode)
996
997
		return true;

998
999
1000
	/* optionally ignore the JTAG version field */
	uint32_t mask = tap->ignore_version ? ~(0xff << 24) : ~0;

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