cb3e9265cc4e123fc1a27ad9b279da0275ffbf0a
[openocd.git] / src / jtag / core.c
1 /***************************************************************************
2 * Copyright (C) 2009 Zachary T Welch *
3 * zw@superlucidity.net *
4 * *
5 * Copyright (C) 2007,2008,2009 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2009 SoftPLC Corporation *
9 * http://softplc.com *
10 * dick@softplc.com *
11 * *
12 * Copyright (C) 2005 by Dominic Rath *
13 * Dominic.Rath@gmx.de *
14 * *
15 * This program is free software; you can redistribute it and/or modify *
16 * it under the terms of the GNU General Public License as published by *
17 * the Free Software Foundation; either version 2 of the License, or *
18 * (at your option) any later version. *
19 * *
20 * This program is distributed in the hope that it will be useful, *
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
23 * GNU General Public License for more details. *
24 * *
25 * You should have received a copy of the GNU General Public License *
26 * along with this program; if not, write to the *
27 * Free Software Foundation, Inc., *
28 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
29 ***************************************************************************/
30
31 #ifdef HAVE_CONFIG_H
32 #include "config.h"
33 #endif
34
35 #include "jtag.h"
36 #include "swd.h"
37 #include "interface.h"
38 #include <transport/transport.h>
39
40 #ifdef HAVE_STRINGS_H
41 #include <strings.h>
42 #endif
43
44 /* SVF and XSVF are higher level JTAG command sets (for boundary scan) */
45 #include "svf/svf.h"
46 #include "xsvf/xsvf.h"
47
48 /** The number of JTAG queue flushes (for profiling and debugging purposes). */
49 static int jtag_flush_queue_count;
50
51 /* Sleep this # of ms after flushing the queue */
52 static int jtag_flush_queue_sleep;
53
54 static void jtag_add_scan_check(struct jtag_tap *active,
55 void (*jtag_add_scan)(struct jtag_tap *active,
56 int in_num_fields,
57 const struct scan_field *in_fields,
58 tap_state_t state),
59 int in_num_fields, struct scan_field *in_fields, tap_state_t state);
60
61 /**
62 * The jtag_error variable is set when an error occurs while executing
63 * the queue. Application code may set this using jtag_set_error(),
64 * when an error occurs during processing that should be reported during
65 * jtag_execute_queue().
66 *
67 * The value is set and cleared, but never read by normal application code.
68 *
69 * This value is returned (and cleared) by jtag_execute_queue().
70 */
71 static int jtag_error = ERROR_OK;
72
73 static const char *jtag_event_strings[] = {
74 [JTAG_TRST_ASSERTED] = "TAP reset",
75 [JTAG_TAP_EVENT_SETUP] = "TAP setup",
76 [JTAG_TAP_EVENT_ENABLE] = "TAP enabled",
77 [JTAG_TAP_EVENT_DISABLE] = "TAP disabled",
78 };
79
80 /*
81 * JTAG adapters must initialize with TRST and SRST de-asserted
82 * (they're negative logic, so that means *high*). But some
83 * hardware doesn't necessarily work that way ... so set things
84 * up so that jtag_init() always forces that state.
85 */
86 static int jtag_trst = -1;
87 static int jtag_srst = -1;
88
89 /**
90 * List all TAPs that have been created.
91 */
92 static struct jtag_tap *__jtag_all_taps;
93
94 static enum reset_types jtag_reset_config = RESET_NONE;
95 tap_state_t cmd_queue_cur_state = TAP_RESET;
96
97 static bool jtag_verify_capture_ir = true;
98 static int jtag_verify = 1;
99
100 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines
101 *deasserted (in ms) */
102 static int adapter_nsrst_delay; /* default to no nSRST delay */
103 static int jtag_ntrst_delay;/* default to no nTRST delay */
104 static int adapter_nsrst_assert_width; /* width of assertion */
105 static int jtag_ntrst_assert_width; /* width of assertion */
106
107 /**
108 * Contains a single callback along with a pointer that will be passed
109 * when an event occurs.
110 */
111 struct jtag_event_callback {
112 /** a event callback */
113 jtag_event_handler_t callback;
114 /** the private data to pass to the callback */
115 void *priv;
116 /** the next callback */
117 struct jtag_event_callback *next;
118 };
119
120 /* callbacks to inform high-level handlers about JTAG state changes */
121 static struct jtag_event_callback *jtag_event_callbacks;
122
123 /* speed in kHz*/
124 static int speed_khz;
125 /* speed to fallback to when RCLK is requested but not supported */
126 static int rclk_fallback_speed_khz;
127 static enum {CLOCK_MODE_UNSELECTED, CLOCK_MODE_KHZ, CLOCK_MODE_RCLK} clock_mode;
128 static int jtag_speed;
129
130 static struct jtag_interface *jtag;
131
132 /* configuration */
133 struct jtag_interface *jtag_interface;
134
135 void jtag_set_flush_queue_sleep(int ms)
136 {
137 jtag_flush_queue_sleep = ms;
138 }
139
140 void jtag_set_error(int error)
141 {
142 if ((error == ERROR_OK) || (jtag_error != ERROR_OK))
143 return;
144 jtag_error = error;
145 }
146
147 int jtag_error_clear(void)
148 {
149 int temp = jtag_error;
150 jtag_error = ERROR_OK;
151 return temp;
152 }
153
154 /************/
155
156 static bool jtag_poll = 1;
157
158 bool is_jtag_poll_safe(void)
159 {
160 /* Polling can be disabled explicitly with set_enabled(false).
161 * It is also implicitly disabled while TRST is active and
162 * while SRST is gating the JTAG clock.
163 */
164 if (!transport_is_jtag())
165 return jtag_poll;
166
167 if (!jtag_poll || jtag_trst != 0)
168 return false;
169 return jtag_srst == 0 || (jtag_reset_config & RESET_SRST_NO_GATING);
170 }
171
172 bool jtag_poll_get_enabled(void)
173 {
174 return jtag_poll;
175 }
176
177 void jtag_poll_set_enabled(bool value)
178 {
179 jtag_poll = value;
180 }
181
182 /************/
183
184 struct jtag_tap *jtag_all_taps(void)
185 {
186 return __jtag_all_taps;
187 };
188
189 unsigned jtag_tap_count(void)
190 {
191 struct jtag_tap *t = jtag_all_taps();
192 unsigned n = 0;
193 while (t) {
194 n++;
195 t = t->next_tap;
196 }
197 return n;
198 }
199
200 unsigned jtag_tap_count_enabled(void)
201 {
202 struct jtag_tap *t = jtag_all_taps();
203 unsigned n = 0;
204 while (t) {
205 if (t->enabled)
206 n++;
207 t = t->next_tap;
208 }
209 return n;
210 }
211
212 /** Append a new TAP to the chain of all taps. */
213 void jtag_tap_add(struct jtag_tap *t)
214 {
215 unsigned jtag_num_taps = 0;
216
217 struct jtag_tap **tap = &__jtag_all_taps;
218 while (*tap != NULL) {
219 jtag_num_taps++;
220 tap = &(*tap)->next_tap;
221 }
222 *tap = t;
223 t->abs_chain_position = jtag_num_taps;
224 }
225
226 /* returns a pointer to the n-th device in the scan chain */
227 struct jtag_tap *jtag_tap_by_position(unsigned n)
228 {
229 struct jtag_tap *t = jtag_all_taps();
230
231 while (t && n-- > 0)
232 t = t->next_tap;
233
234 return t;
235 }
236
237 struct jtag_tap *jtag_tap_by_string(const char *s)
238 {
239 /* try by name first */
240 struct jtag_tap *t = jtag_all_taps();
241
242 while (t) {
243 if (0 == strcmp(t->dotted_name, s))
244 return t;
245 t = t->next_tap;
246 }
247
248 /* no tap found by name, so try to parse the name as a number */
249 unsigned n;
250 if (parse_uint(s, &n) != ERROR_OK)
251 return NULL;
252
253 /* FIXME remove this numeric fallback code late June 2010, along
254 * with all info in the User's Guide that TAPs have numeric IDs.
255 * Also update "scan_chain" output to not display the numbers.
256 */
257 t = jtag_tap_by_position(n);
258 if (t)
259 LOG_WARNING("Specify TAP '%s' by name, not number %u",
260 t->dotted_name, n);
261
262 return t;
263 }
264
265 struct jtag_tap *jtag_tap_next_enabled(struct jtag_tap *p)
266 {
267 p = p ? p->next_tap : jtag_all_taps();
268 while (p) {
269 if (p->enabled)
270 return p;
271 p = p->next_tap;
272 }
273 return NULL;
274 }
275
276 const char *jtag_tap_name(const struct jtag_tap *tap)
277 {
278 return (tap == NULL) ? "(unknown)" : tap->dotted_name;
279 }
280
281
282 int jtag_register_event_callback(jtag_event_handler_t callback, void *priv)
283 {
284 struct jtag_event_callback **callbacks_p = &jtag_event_callbacks;
285
286 if (callback == NULL)
287 return ERROR_COMMAND_SYNTAX_ERROR;
288
289 if (*callbacks_p) {
290 while ((*callbacks_p)->next)
291 callbacks_p = &((*callbacks_p)->next);
292 callbacks_p = &((*callbacks_p)->next);
293 }
294
295 (*callbacks_p) = malloc(sizeof(struct jtag_event_callback));
296 (*callbacks_p)->callback = callback;
297 (*callbacks_p)->priv = priv;
298 (*callbacks_p)->next = NULL;
299
300 return ERROR_OK;
301 }
302
303 int jtag_unregister_event_callback(jtag_event_handler_t callback, void *priv)
304 {
305 struct jtag_event_callback **p = &jtag_event_callbacks, *temp;
306
307 if (callback == NULL)
308 return ERROR_COMMAND_SYNTAX_ERROR;
309
310 while (*p) {
311 if (((*p)->priv != priv) || ((*p)->callback != callback)) {
312 p = &(*p)->next;
313 continue;
314 }
315
316 temp = *p;
317 *p = (*p)->next;
318 free(temp);
319 }
320
321 return ERROR_OK;
322 }
323
324 int jtag_call_event_callbacks(enum jtag_event event)
325 {
326 struct jtag_event_callback *callback = jtag_event_callbacks;
327
328 LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
329
330 while (callback) {
331 struct jtag_event_callback *next;
332
333 /* callback may remove itself */
334 next = callback->next;
335 callback->callback(event, callback->priv);
336 callback = next;
337 }
338
339 return ERROR_OK;
340 }
341
342 static void jtag_checks(void)
343 {
344 assert(jtag_trst == 0);
345 }
346
347 static void jtag_prelude(tap_state_t state)
348 {
349 jtag_checks();
350
351 assert(state != TAP_INVALID);
352
353 cmd_queue_cur_state = state;
354 }
355
356 void jtag_add_ir_scan_noverify(struct jtag_tap *active, const struct scan_field *in_fields,
357 tap_state_t state)
358 {
359 jtag_prelude(state);
360
361 int retval = interface_jtag_add_ir_scan(active, in_fields, state);
362 jtag_set_error(retval);
363 }
364
365 static void jtag_add_ir_scan_noverify_callback(struct jtag_tap *active,
366 int dummy,
367 const struct scan_field *in_fields,
368 tap_state_t state)
369 {
370 jtag_add_ir_scan_noverify(active, in_fields, state);
371 }
372
373 /* If fields->in_value is filled out, then the captured IR value will be checked */
374 void jtag_add_ir_scan(struct jtag_tap *active, struct scan_field *in_fields, tap_state_t state)
375 {
376 assert(state != TAP_RESET);
377
378 if (jtag_verify && jtag_verify_capture_ir) {
379 /* 8 x 32 bit id's is enough for all invocations */
380
381 /* if we are to run a verification of the ir scan, we need to get the input back.
382 * We may have to allocate space if the caller didn't ask for the input back.
383 */
384 in_fields->check_value = active->expected;
385 in_fields->check_mask = active->expected_mask;
386 jtag_add_scan_check(active, jtag_add_ir_scan_noverify_callback, 1, in_fields,
387 state);
388 } else
389 jtag_add_ir_scan_noverify(active, in_fields, state);
390 }
391
392 void jtag_add_plain_ir_scan(int num_bits, const uint8_t *out_bits, uint8_t *in_bits,
393 tap_state_t state)
394 {
395 assert(out_bits != NULL);
396 assert(state != TAP_RESET);
397
398 jtag_prelude(state);
399
400 int retval = interface_jtag_add_plain_ir_scan(
401 num_bits, out_bits, in_bits, state);
402 jtag_set_error(retval);
403 }
404
405 static int jtag_check_value_inner(uint8_t *captured, uint8_t *in_check_value,
406 uint8_t *in_check_mask, int num_bits);
407
408 static int jtag_check_value_mask_callback(jtag_callback_data_t data0,
409 jtag_callback_data_t data1,
410 jtag_callback_data_t data2,
411 jtag_callback_data_t data3)
412 {
413 return jtag_check_value_inner((uint8_t *)data0,
414 (uint8_t *)data1,
415 (uint8_t *)data2,
416 (int)data3);
417 }
418
419 static void jtag_add_scan_check(struct jtag_tap *active, void (*jtag_add_scan)(
420 struct jtag_tap *active,
421 int in_num_fields,
422 const struct scan_field *in_fields,
423 tap_state_t state),
424 int in_num_fields, struct scan_field *in_fields, tap_state_t state)
425 {
426 jtag_add_scan(active, in_num_fields, in_fields, state);
427
428 for (int i = 0; i < in_num_fields; i++) {
429 if ((in_fields[i].check_value != NULL) && (in_fields[i].in_value != NULL)) {
430 /* this is synchronous for a minidriver */
431 jtag_add_callback4(jtag_check_value_mask_callback,
432 (jtag_callback_data_t)in_fields[i].in_value,
433 (jtag_callback_data_t)in_fields[i].check_value,
434 (jtag_callback_data_t)in_fields[i].check_mask,
435 (jtag_callback_data_t)in_fields[i].num_bits);
436 }
437 }
438 }
439
440 void jtag_add_dr_scan_check(struct jtag_tap *active,
441 int in_num_fields,
442 struct scan_field *in_fields,
443 tap_state_t state)
444 {
445 if (jtag_verify)
446 jtag_add_scan_check(active, jtag_add_dr_scan, in_num_fields, in_fields, state);
447 else
448 jtag_add_dr_scan(active, in_num_fields, in_fields, state);
449 }
450
451
452 void jtag_add_dr_scan(struct jtag_tap *active,
453 int in_num_fields,
454 const struct scan_field *in_fields,
455 tap_state_t state)
456 {
457 assert(state != TAP_RESET);
458
459 jtag_prelude(state);
460
461 int retval;
462 retval = interface_jtag_add_dr_scan(active, in_num_fields, in_fields, state);
463 jtag_set_error(retval);
464 }
465
466 void jtag_add_plain_dr_scan(int num_bits, const uint8_t *out_bits, uint8_t *in_bits,
467 tap_state_t state)
468 {
469 assert(out_bits != NULL);
470 assert(state != TAP_RESET);
471
472 jtag_prelude(state);
473
474 int retval;
475 retval = interface_jtag_add_plain_dr_scan(num_bits, out_bits, in_bits, state);
476 jtag_set_error(retval);
477 }
478
479 void jtag_add_tlr(void)
480 {
481 jtag_prelude(TAP_RESET);
482 jtag_set_error(interface_jtag_add_tlr());
483
484 /* NOTE: order here matches TRST path in jtag_add_reset() */
485 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
486 jtag_notify_event(JTAG_TRST_ASSERTED);
487 }
488
489 /**
490 * If supported by the underlying adapter, this clocks a raw bit sequence
491 * onto TMS for switching betwen JTAG and SWD modes.
492 *
493 * DO NOT use this to bypass the integrity checks and logging provided
494 * by the jtag_add_pathmove() and jtag_add_statemove() calls.
495 *
496 * @param nbits How many bits to clock out.
497 * @param seq The bit sequence. The LSB is bit 0 of seq[0].
498 * @param state The JTAG tap state to record on completion. Use
499 * TAP_INVALID to represent being in in SWD mode.
500 *
501 * @todo Update naming conventions to stop assuming everything is JTAG.
502 */
503 int jtag_add_tms_seq(unsigned nbits, const uint8_t *seq, enum tap_state state)
504 {
505 int retval;
506
507 if (!(jtag->supported & DEBUG_CAP_TMS_SEQ))
508 return ERROR_JTAG_NOT_IMPLEMENTED;
509
510 jtag_checks();
511 cmd_queue_cur_state = state;
512
513 retval = interface_add_tms_seq(nbits, seq, state);
514 jtag_set_error(retval);
515 return retval;
516 }
517
518 void jtag_add_pathmove(int num_states, const tap_state_t *path)
519 {
520 tap_state_t cur_state = cmd_queue_cur_state;
521
522 /* the last state has to be a stable state */
523 if (!tap_is_state_stable(path[num_states - 1])) {
524 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
525 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE);
526 return;
527 }
528
529 for (int i = 0; i < num_states; i++) {
530 if (path[i] == TAP_RESET) {
531 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
532 jtag_set_error(ERROR_JTAG_STATE_INVALID);
533 return;
534 }
535
536 if (tap_state_transition(cur_state, true) != path[i] &&
537 tap_state_transition(cur_state, false) != path[i]) {
538 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
539 tap_state_name(cur_state), tap_state_name(path[i]));
540 jtag_set_error(ERROR_JTAG_TRANSITION_INVALID);
541 return;
542 }
543 cur_state = path[i];
544 }
545
546 jtag_checks();
547
548 jtag_set_error(interface_jtag_add_pathmove(num_states, path));
549 cmd_queue_cur_state = path[num_states - 1];
550 }
551
552 int jtag_add_statemove(tap_state_t goal_state)
553 {
554 tap_state_t cur_state = cmd_queue_cur_state;
555
556 if (goal_state != cur_state) {
557 LOG_DEBUG("cur_state=%s goal_state=%s",
558 tap_state_name(cur_state),
559 tap_state_name(goal_state));
560 }
561
562 /* If goal is RESET, be paranoid and force that that transition
563 * (e.g. five TCK cycles, TMS high). Else trust "cur_state".
564 */
565 if (goal_state == TAP_RESET)
566 jtag_add_tlr();
567 else if (goal_state == cur_state)
568 /* nothing to do */;
569
570 else if (tap_is_state_stable(cur_state) && tap_is_state_stable(goal_state)) {
571 unsigned tms_bits = tap_get_tms_path(cur_state, goal_state);
572 unsigned tms_count = tap_get_tms_path_len(cur_state, goal_state);
573 tap_state_t moves[8];
574 assert(tms_count < ARRAY_SIZE(moves));
575
576 for (unsigned i = 0; i < tms_count; i++, tms_bits >>= 1) {
577 bool bit = tms_bits & 1;
578
579 cur_state = tap_state_transition(cur_state, bit);
580 moves[i] = cur_state;
581 }
582
583 jtag_add_pathmove(tms_count, moves);
584 } else if (tap_state_transition(cur_state, true) == goal_state
585 || tap_state_transition(cur_state, false) == goal_state)
586 jtag_add_pathmove(1, &goal_state);
587 else
588 return ERROR_FAIL;
589
590 return ERROR_OK;
591 }
592
593 void jtag_add_runtest(int num_cycles, tap_state_t state)
594 {
595 jtag_prelude(state);
596 jtag_set_error(interface_jtag_add_runtest(num_cycles, state));
597 }
598
599
600 void jtag_add_clocks(int num_cycles)
601 {
602 if (!tap_is_state_stable(cmd_queue_cur_state)) {
603 LOG_ERROR("jtag_add_clocks() called with TAP in unstable state \"%s\"",
604 tap_state_name(cmd_queue_cur_state));
605 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE);
606 return;
607 }
608
609 if (num_cycles > 0) {
610 jtag_checks();
611 jtag_set_error(interface_jtag_add_clocks(num_cycles));
612 }
613 }
614
615 void swd_add_reset(int req_srst)
616 {
617 if (req_srst) {
618 if (!(jtag_reset_config & RESET_HAS_SRST)) {
619 LOG_ERROR("BUG: can't assert SRST");
620 jtag_set_error(ERROR_FAIL);
621 return;
622 }
623 req_srst = 1;
624 }
625
626 /* Maybe change SRST signal state */
627 if (jtag_srst != req_srst) {
628 int retval;
629
630 retval = interface_jtag_add_reset(0, req_srst);
631 if (retval != ERROR_OK)
632 jtag_set_error(retval);
633 else
634 retval = jtag_execute_queue();
635
636 if (retval != ERROR_OK) {
637 LOG_ERROR("TRST/SRST error");
638 return;
639 }
640
641 /* SRST resets everything hooked up to that signal */
642 jtag_srst = req_srst;
643 if (jtag_srst) {
644 LOG_DEBUG("SRST line asserted");
645 if (adapter_nsrst_assert_width)
646 jtag_add_sleep(adapter_nsrst_assert_width * 1000);
647 } else {
648 LOG_DEBUG("SRST line released");
649 if (adapter_nsrst_delay)
650 jtag_add_sleep(adapter_nsrst_delay * 1000);
651 }
652 }
653 }
654
655 void jtag_add_reset(int req_tlr_or_trst, int req_srst)
656 {
657 int trst_with_tlr = 0;
658 int new_srst = 0;
659 int new_trst = 0;
660
661 /* Without SRST, we must use target-specific JTAG operations
662 * on each target; callers should not be requesting SRST when
663 * that signal doesn't exist.
664 *
665 * RESET_SRST_PULLS_TRST is a board or chip level quirk, which
666 * can kick in even if the JTAG adapter can't drive TRST.
667 */
668 if (req_srst) {
669 if (!(jtag_reset_config & RESET_HAS_SRST)) {
670 LOG_ERROR("BUG: can't assert SRST");
671 jtag_set_error(ERROR_FAIL);
672 return;
673 }
674 if ((jtag_reset_config & RESET_SRST_PULLS_TRST) != 0
675 && !req_tlr_or_trst) {
676 LOG_ERROR("BUG: can't assert only SRST");
677 jtag_set_error(ERROR_FAIL);
678 return;
679 }
680 new_srst = 1;
681 }
682
683 /* JTAG reset (entry to TAP_RESET state) can always be achieved
684 * using TCK and TMS; that may go through a TAP_{IR,DR}UPDATE
685 * state first. TRST accelerates it, and bypasses those states.
686 *
687 * RESET_TRST_PULLS_SRST is a board or chip level quirk, which
688 * can kick in even if the JTAG adapter can't drive SRST.
689 */
690 if (req_tlr_or_trst) {
691 if (!(jtag_reset_config & RESET_HAS_TRST))
692 trst_with_tlr = 1;
693 else if ((jtag_reset_config & RESET_TRST_PULLS_SRST) != 0
694 && !req_srst)
695 trst_with_tlr = 1;
696 else
697 new_trst = 1;
698 }
699
700 /* Maybe change TRST and/or SRST signal state */
701 if (jtag_srst != new_srst || jtag_trst != new_trst) {
702 int retval;
703
704 retval = interface_jtag_add_reset(new_trst, new_srst);
705 if (retval != ERROR_OK)
706 jtag_set_error(retval);
707 else
708 retval = jtag_execute_queue();
709
710 if (retval != ERROR_OK) {
711 LOG_ERROR("TRST/SRST error");
712 return;
713 }
714 }
715
716 /* SRST resets everything hooked up to that signal */
717 if (jtag_srst != new_srst) {
718 jtag_srst = new_srst;
719 if (jtag_srst) {
720 LOG_DEBUG("SRST line asserted");
721 if (adapter_nsrst_assert_width)
722 jtag_add_sleep(adapter_nsrst_assert_width * 1000);
723 } else {
724 LOG_DEBUG("SRST line released");
725 if (adapter_nsrst_delay)
726 jtag_add_sleep(adapter_nsrst_delay * 1000);
727 }
728 }
729
730 /* Maybe enter the JTAG TAP_RESET state ...
731 * - using only TMS, TCK, and the JTAG state machine
732 * - or else more directly, using TRST
733 *
734 * TAP_RESET should be invisible to non-debug parts of the system.
735 */
736 if (trst_with_tlr) {
737 LOG_DEBUG("JTAG reset with TLR instead of TRST");
738 jtag_add_tlr();
739
740 } else if (jtag_trst != new_trst) {
741 jtag_trst = new_trst;
742 if (jtag_trst) {
743 LOG_DEBUG("TRST line asserted");
744 tap_set_state(TAP_RESET);
745 if (jtag_ntrst_assert_width)
746 jtag_add_sleep(jtag_ntrst_assert_width * 1000);
747 } else {
748 LOG_DEBUG("TRST line released");
749 if (jtag_ntrst_delay)
750 jtag_add_sleep(jtag_ntrst_delay * 1000);
751
752 /* We just asserted nTRST, so we're now in TAP_RESET.
753 * Inform possible listeners about this, now that
754 * JTAG instructions and data can be shifted. This
755 * sequence must match jtag_add_tlr().
756 */
757 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
758 jtag_notify_event(JTAG_TRST_ASSERTED);
759 }
760 }
761 }
762
763 void jtag_add_sleep(uint32_t us)
764 {
765 /** @todo Here, keep_alive() appears to be a layering violation!!! */
766 keep_alive();
767 jtag_set_error(interface_jtag_add_sleep(us));
768 }
769
770 static int jtag_check_value_inner(uint8_t *captured, uint8_t *in_check_value,
771 uint8_t *in_check_mask, int num_bits)
772 {
773 int retval = ERROR_OK;
774 int compare_failed;
775
776 if (in_check_mask)
777 compare_failed = buf_cmp_mask(captured, in_check_value, in_check_mask, num_bits);
778 else
779 compare_failed = buf_cmp(captured, in_check_value, num_bits);
780
781 if (compare_failed) {
782 char *captured_str, *in_check_value_str;
783 int bits = (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits;
784
785 /* NOTE: we've lost diagnostic context here -- 'which tap' */
786
787 captured_str = buf_to_str(captured, bits, 16);
788 in_check_value_str = buf_to_str(in_check_value, bits, 16);
789
790 LOG_WARNING("Bad value '%s' captured during DR or IR scan:",
791 captured_str);
792 LOG_WARNING(" check_value: 0x%s", in_check_value_str);
793
794 free(captured_str);
795 free(in_check_value_str);
796
797 if (in_check_mask) {
798 char *in_check_mask_str;
799
800 in_check_mask_str = buf_to_str(in_check_mask, bits, 16);
801 LOG_WARNING(" check_mask: 0x%s", in_check_mask_str);
802 free(in_check_mask_str);
803 }
804
805 retval = ERROR_JTAG_QUEUE_FAILED;
806 }
807 return retval;
808 }
809
810 void jtag_check_value_mask(struct scan_field *field, uint8_t *value, uint8_t *mask)
811 {
812 assert(field->in_value != NULL);
813
814 if (value == NULL) {
815 /* no checking to do */
816 return;
817 }
818
819 jtag_execute_queue_noclear();
820
821 int retval = jtag_check_value_inner(field->in_value, value, mask, field->num_bits);
822 jtag_set_error(retval);
823 }
824
825 int default_interface_jtag_execute_queue(void)
826 {
827 if (NULL == jtag) {
828 LOG_ERROR("No JTAG interface configured yet. "
829 "Issue 'init' command in startup scripts "
830 "before communicating with targets.");
831 return ERROR_FAIL;
832 }
833
834 return jtag->execute_queue();
835 }
836
837 void jtag_execute_queue_noclear(void)
838 {
839 jtag_flush_queue_count++;
840 jtag_set_error(interface_jtag_execute_queue());
841
842 if (jtag_flush_queue_sleep > 0) {
843 /* For debug purposes it can be useful to test performance
844 * or behavior when delaying after flushing the queue,
845 * e.g. to simulate long roundtrip times.
846 */
847 usleep(jtag_flush_queue_sleep * 1000);
848 }
849 }
850
851 int jtag_get_flush_queue_count(void)
852 {
853 return jtag_flush_queue_count;
854 }
855
856 int jtag_execute_queue(void)
857 {
858 jtag_execute_queue_noclear();
859 return jtag_error_clear();
860 }
861
862 static int jtag_reset_callback(enum jtag_event event, void *priv)
863 {
864 struct jtag_tap *tap = priv;
865
866 if (event == JTAG_TRST_ASSERTED) {
867 tap->enabled = !tap->disabled_after_reset;
868
869 /* current instruction is either BYPASS or IDCODE */
870 buf_set_ones(tap->cur_instr, tap->ir_length);
871 tap->bypass = 1;
872 }
873
874 return ERROR_OK;
875 }
876
877 /* sleep at least us microseconds. When we sleep more than 1000ms we
878 * do an alive sleep, i.e. keep GDB alive. Note that we could starve
879 * GDB if we slept for <1000ms many times.
880 */
881 void jtag_sleep(uint32_t us)
882 {
883 if (us < 1000)
884 usleep(us);
885 else
886 alive_sleep((us+999)/1000);
887 }
888
889 #define JTAG_MAX_AUTO_TAPS 20
890
891 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
892 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
893 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
894
895 /* A reserved manufacturer ID is used in END_OF_CHAIN_FLAG, so we
896 * know that no valid TAP will have it as an IDCODE value.
897 */
898 #define END_OF_CHAIN_FLAG 0xffffffff
899
900 /* a larger IR length than we ever expect to autoprobe */
901 #define JTAG_IRLEN_MAX 60
902
903 static int jtag_examine_chain_execute(uint8_t *idcode_buffer, unsigned num_idcode)
904 {
905 struct scan_field field = {
906 .num_bits = num_idcode * 32,
907 .out_value = idcode_buffer,
908 .in_value = idcode_buffer,
909 };
910
911 /* initialize to the end of chain ID value */
912 for (unsigned i = 0; i < num_idcode; i++)
913 buf_set_u32(idcode_buffer, i * 32, 32, END_OF_CHAIN_FLAG);
914
915 jtag_add_plain_dr_scan(field.num_bits, field.out_value, field.in_value, TAP_DRPAUSE);
916 jtag_add_tlr();
917 return jtag_execute_queue();
918 }
919
920 static bool jtag_examine_chain_check(uint8_t *idcodes, unsigned count)
921 {
922 uint8_t zero_check = 0x0;
923 uint8_t one_check = 0xff;
924
925 for (unsigned i = 0; i < count * 4; i++) {
926 zero_check |= idcodes[i];
927 one_check &= idcodes[i];
928 }
929
930 /* if there wasn't a single non-zero bit or if all bits were one,
931 * the scan is not valid. We wrote a mix of both values; either
932 *
933 * - There's a hardware issue (almost certainly):
934 * + all-zeroes can mean a target stuck in JTAG reset
935 * + all-ones tends to mean no target
936 * - The scan chain is WAY longer than we can handle, *AND* either
937 * + there are several hundreds of TAPs in bypass, or
938 * + at least a few dozen TAPs all have an all-ones IDCODE
939 */
940 if (zero_check == 0x00 || one_check == 0xff) {
941 LOG_ERROR("JTAG scan chain interrogation failed: all %s",
942 (zero_check == 0x00) ? "zeroes" : "ones");
943 LOG_ERROR("Check JTAG interface, timings, target power, etc.");
944 return false;
945 }
946 return true;
947 }
948
949 static void jtag_examine_chain_display(enum log_levels level, const char *msg,
950 const char *name, uint32_t idcode)
951 {
952 log_printf_lf(level, __FILE__, __LINE__, __func__,
953 "JTAG tap: %s %16.16s: 0x%08x "
954 "(mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
955 name, msg,
956 (unsigned int)idcode,
957 (unsigned int)EXTRACT_MFG(idcode),
958 (unsigned int)EXTRACT_PART(idcode),
959 (unsigned int)EXTRACT_VER(idcode));
960 }
961
962 static bool jtag_idcode_is_final(uint32_t idcode)
963 {
964 /*
965 * Some devices, such as AVR8, will output all 1's instead
966 * of TDI input value at end of chain. Allow those values
967 * instead of failing.
968 */
969 return idcode == END_OF_CHAIN_FLAG;
970 }
971
972 /**
973 * This helper checks that remaining bits in the examined chain data are
974 * all as expected, but a single JTAG device requires only 64 bits to be
975 * read back correctly. This can help identify and diagnose problems
976 * with the JTAG chain earlier, gives more helpful/explicit error messages.
977 * Returns TRUE iff garbage was found.
978 */
979 static bool jtag_examine_chain_end(uint8_t *idcodes, unsigned count, unsigned max)
980 {
981 bool triggered = false;
982 for (; count < max - 31; count += 32) {
983 uint32_t idcode = buf_get_u32(idcodes, count, 32);
984
985 /* do not trigger the warning if the data looks good */
986 if (jtag_idcode_is_final(idcode))
987 continue;
988 LOG_WARNING("Unexpected idcode after end of chain: %d 0x%08x",
989 count, (unsigned int)idcode);
990 triggered = true;
991 }
992 return triggered;
993 }
994
995 static bool jtag_examine_chain_match_tap(const struct jtag_tap *tap)
996 {
997
998 if (tap->expected_ids_cnt == 0 || !tap->hasidcode)
999 return true;
1000
1001 /* optionally ignore the JTAG version field - bits 28-31 of IDCODE */
1002 uint32_t mask = tap->ignore_version ? ~(0xf << 28) : ~0;
1003 uint32_t idcode = tap->idcode & mask;
1004
1005 /* Loop over the expected identification codes and test for a match */
1006 for (unsigned ii = 0; ii < tap->expected_ids_cnt; ii++) {
1007 uint32_t expected = tap->expected_ids[ii] & mask;
1008
1009 if (idcode == expected)
1010 return true;
1011
1012 /* treat "-expected-id 0" as a "don't-warn" wildcard */
1013 if (0 == tap->expected_ids[ii])
1014 return true;
1015 }
1016
1017 /* If none of the expected ids matched, warn */
1018 jtag_examine_chain_display(LOG_LVL_WARNING, "UNEXPECTED",
1019 tap->dotted_name, tap->idcode);
1020 for (unsigned ii = 0; ii < tap->expected_ids_cnt; ii++) {
1021 char msg[32];
1022
1023 snprintf(msg, sizeof(msg), "expected %u of %u", ii + 1, tap->expected_ids_cnt);
1024 jtag_examine_chain_display(LOG_LVL_ERROR, msg,
1025 tap->dotted_name, tap->expected_ids[ii]);
1026 }
1027 return false;
1028 }
1029
1030 /* Try to examine chain layout according to IEEE 1149.1 §12
1031 * This is called a "blind interrogation" of the scan chain.
1032 */
1033 static int jtag_examine_chain(void)
1034 {
1035 int retval;
1036 unsigned max_taps = jtag_tap_count();
1037
1038 /* Autoprobe up to this many. */
1039 if (max_taps < JTAG_MAX_AUTO_TAPS)
1040 max_taps = JTAG_MAX_AUTO_TAPS;
1041
1042 /* Add room for end-of-chain marker. */
1043 max_taps++;
1044
1045 uint8_t *idcode_buffer = malloc(max_taps * 4);
1046 if (idcode_buffer == NULL)
1047 return ERROR_JTAG_INIT_FAILED;
1048
1049 /* DR scan to collect BYPASS or IDCODE register contents.
1050 * Then make sure the scan data has both ones and zeroes.
1051 */
1052 LOG_DEBUG("DR scan interrogation for IDCODE/BYPASS");
1053 retval = jtag_examine_chain_execute(idcode_buffer, max_taps);
1054 if (retval != ERROR_OK)
1055 goto out;
1056 if (!jtag_examine_chain_check(idcode_buffer, max_taps)) {
1057 retval = ERROR_JTAG_INIT_FAILED;
1058 goto out;
1059 }
1060
1061 /* Point at the 1st predefined tap, if any */
1062 struct jtag_tap *tap = jtag_tap_next_enabled(NULL);
1063
1064 unsigned bit_count = 0;
1065 unsigned autocount = 0;
1066 for (unsigned i = 0; i < max_taps; i++) {
1067 assert(bit_count < max_taps * 32);
1068 uint32_t idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1069
1070 /* No predefined TAP? Auto-probe. */
1071 if (tap == NULL) {
1072 /* Is there another TAP? */
1073 if (jtag_idcode_is_final(idcode))
1074 break;
1075
1076 /* Default everything in this TAP except IR length.
1077 *
1078 * REVISIT create a jtag_alloc(chip, tap) routine, and
1079 * share it with jim_newtap_cmd().
1080 */
1081 tap = calloc(1, sizeof *tap);
1082 if (!tap) {
1083 retval = ERROR_FAIL;
1084 goto out;
1085 }
1086
1087 tap->chip = alloc_printf("auto%u", autocount++);
1088 tap->tapname = strdup("tap");
1089 tap->dotted_name = alloc_printf("%s.%s", tap->chip, tap->tapname);
1090
1091 tap->ir_length = 0; /* ... signifying irlen autoprobe */
1092 tap->ir_capture_mask = 0x03;
1093 tap->ir_capture_value = 0x01;
1094
1095 tap->enabled = true;
1096
1097 jtag_tap_init(tap);
1098 }
1099
1100 if ((idcode & 1) == 0) {
1101 /* Zero for LSB indicates a device in bypass */
1102 LOG_INFO("TAP %s does not have IDCODE", tap->dotted_name);
1103 tap->hasidcode = false;
1104 tap->idcode = 0;
1105
1106 bit_count += 1;
1107 } else {
1108 /* Friendly devices support IDCODE */
1109 tap->hasidcode = true;
1110 tap->idcode = idcode;
1111 jtag_examine_chain_display(LOG_LVL_INFO, "tap/device found", tap->dotted_name, idcode);
1112
1113 bit_count += 32;
1114 }
1115
1116 /* ensure the TAP ID matches what was expected */
1117 if (!jtag_examine_chain_match_tap(tap))
1118 retval = ERROR_JTAG_INIT_SOFT_FAIL;
1119
1120 tap = jtag_tap_next_enabled(tap);
1121 }
1122
1123 /* After those IDCODE or BYPASS register values should be
1124 * only the data we fed into the scan chain.
1125 */
1126 if (jtag_examine_chain_end(idcode_buffer, bit_count, max_taps * 32)) {
1127 LOG_ERROR("double-check your JTAG setup (interface, speed, ...)");
1128 retval = ERROR_JTAG_INIT_FAILED;
1129 goto out;
1130 }
1131
1132 /* Return success or, for backwards compatibility if only
1133 * some IDCODE values mismatched, a soft/continuable fault.
1134 */
1135 out:
1136 free(idcode_buffer);
1137 return retval;
1138 }
1139
1140 /*
1141 * Validate the date loaded by entry to the Capture-IR state, to help
1142 * find errors related to scan chain configuration (wrong IR lengths)
1143 * or communication.
1144 *
1145 * Entry state can be anything. On non-error exit, all TAPs are in
1146 * bypass mode. On error exits, the scan chain is reset.
1147 */
1148 static int jtag_validate_ircapture(void)
1149 {
1150 struct jtag_tap *tap;
1151 int total_ir_length = 0;
1152 uint8_t *ir_test = NULL;
1153 struct scan_field field;
1154 uint64_t val;
1155 int chain_pos = 0;
1156 int retval;
1157
1158 /* when autoprobing, accomodate huge IR lengths */
1159 for (tap = NULL, total_ir_length = 0;
1160 (tap = jtag_tap_next_enabled(tap)) != NULL;
1161 total_ir_length += tap->ir_length) {
1162 if (tap->ir_length == 0)
1163 total_ir_length += JTAG_IRLEN_MAX;
1164 }
1165
1166 /* increase length to add 2 bit sentinel after scan */
1167 total_ir_length += 2;
1168
1169 ir_test = malloc(DIV_ROUND_UP(total_ir_length, 8));
1170 if (ir_test == NULL)
1171 return ERROR_FAIL;
1172
1173 /* after this scan, all TAPs will capture BYPASS instructions */
1174 buf_set_ones(ir_test, total_ir_length);
1175
1176 field.num_bits = total_ir_length;
1177 field.out_value = ir_test;
1178 field.in_value = ir_test;
1179
1180 jtag_add_plain_ir_scan(field.num_bits, field.out_value, field.in_value, TAP_IDLE);
1181
1182 LOG_DEBUG("IR capture validation scan");
1183 retval = jtag_execute_queue();
1184 if (retval != ERROR_OK)
1185 goto done;
1186
1187 tap = NULL;
1188 chain_pos = 0;
1189
1190 for (;; ) {
1191 tap = jtag_tap_next_enabled(tap);
1192 if (tap == NULL)
1193 break;
1194
1195 /* If we're autoprobing, guess IR lengths. They must be at
1196 * least two bits. Guessing will fail if (a) any TAP does
1197 * not conform to the JTAG spec; or (b) when the upper bits
1198 * captured from some conforming TAP are nonzero. Or if
1199 * (c) an IR length is longer than JTAG_IRLEN_MAX bits,
1200 * an implementation limit, which could someday be raised.
1201 *
1202 * REVISIT optimization: if there's a *single* TAP we can
1203 * lift restrictions (a) and (b) by scanning a recognizable
1204 * pattern before the all-ones BYPASS. Check for where the
1205 * pattern starts in the result, instead of an 0...01 value.
1206 *
1207 * REVISIT alternative approach: escape to some tcl code
1208 * which could provide more knowledge, based on IDCODE; and
1209 * only guess when that has no success.
1210 */
1211 if (tap->ir_length == 0) {
1212 tap->ir_length = 2;
1213 while ((val = buf_get_u64(ir_test, chain_pos, tap->ir_length + 1)) == 1
1214 && tap->ir_length < JTAG_IRLEN_MAX) {
1215 tap->ir_length++;
1216 }
1217 LOG_WARNING("AUTO %s - use \"jtag newtap " "%s %s -irlen %d "
1218 "-expected-id 0x%08" PRIx32 "\"",
1219 tap->dotted_name, tap->chip, tap->tapname, tap->ir_length, tap->idcode);
1220 }
1221
1222 /* Validate the two LSBs, which must be 01 per JTAG spec.
1223 *
1224 * Or ... more bits could be provided by TAP declaration.
1225 * Plus, some taps (notably in i.MX series chips) violate
1226 * this part of the JTAG spec, so their capture mask/value
1227 * attributes might disable this test.
1228 */
1229 val = buf_get_u64(ir_test, chain_pos, tap->ir_length);
1230 if ((val & tap->ir_capture_mask) != tap->ir_capture_value) {
1231 LOG_ERROR("%s: IR capture error; saw 0x%0*" PRIx64 " not 0x%0*" PRIx32,
1232 jtag_tap_name(tap),
1233 (tap->ir_length + 7) / tap->ir_length, val,
1234 (tap->ir_length + 7) / tap->ir_length, tap->ir_capture_value);
1235
1236 retval = ERROR_JTAG_INIT_FAILED;
1237 goto done;
1238 }
1239 LOG_DEBUG("%s: IR capture 0x%0*" PRIx64, jtag_tap_name(tap),
1240 (tap->ir_length + 7) / tap->ir_length, val);
1241 chain_pos += tap->ir_length;
1242 }
1243
1244 /* verify the '11' sentinel we wrote is returned at the end */
1245 val = buf_get_u64(ir_test, chain_pos, 2);
1246 if (val != 0x3) {
1247 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1248
1249 LOG_ERROR("IR capture error at bit %d, saw 0x%s not 0x...3",
1250 chain_pos, cbuf);
1251 free(cbuf);
1252 retval = ERROR_JTAG_INIT_FAILED;
1253 }
1254
1255 done:
1256 free(ir_test);
1257 if (retval != ERROR_OK) {
1258 jtag_add_tlr();
1259 jtag_execute_queue();
1260 }
1261 return retval;
1262 }
1263
1264 void jtag_tap_init(struct jtag_tap *tap)
1265 {
1266 unsigned ir_len_bits;
1267 unsigned ir_len_bytes;
1268
1269 /* if we're autoprobing, cope with potentially huge ir_length */
1270 ir_len_bits = tap->ir_length ? : JTAG_IRLEN_MAX;
1271 ir_len_bytes = DIV_ROUND_UP(ir_len_bits, 8);
1272
1273 tap->expected = calloc(1, ir_len_bytes);
1274 tap->expected_mask = calloc(1, ir_len_bytes);
1275 tap->cur_instr = malloc(ir_len_bytes);
1276
1277 /** @todo cope better with ir_length bigger than 32 bits */
1278 if (ir_len_bits > 32)
1279 ir_len_bits = 32;
1280
1281 buf_set_u32(tap->expected, 0, ir_len_bits, tap->ir_capture_value);
1282 buf_set_u32(tap->expected_mask, 0, ir_len_bits, tap->ir_capture_mask);
1283
1284 /* TAP will be in bypass mode after jtag_validate_ircapture() */
1285 tap->bypass = 1;
1286 buf_set_ones(tap->cur_instr, tap->ir_length);
1287
1288 /* register the reset callback for the TAP */
1289 jtag_register_event_callback(&jtag_reset_callback, tap);
1290 jtag_tap_add(tap);
1291
1292 LOG_DEBUG("Created Tap: %s @ abs position %d, "
1293 "irlen %d, capture: 0x%x mask: 0x%x", tap->dotted_name,
1294 tap->abs_chain_position, tap->ir_length,
1295 (unsigned) tap->ir_capture_value,
1296 (unsigned) tap->ir_capture_mask);
1297 }
1298
1299 void jtag_tap_free(struct jtag_tap *tap)
1300 {
1301 jtag_unregister_event_callback(&jtag_reset_callback, tap);
1302
1303 free(tap->expected);
1304 free(tap->expected_mask);
1305 free(tap->expected_ids);
1306 free(tap->cur_instr);
1307 free(tap->chip);
1308 free(tap->tapname);
1309 free(tap->dotted_name);
1310 free(tap);
1311 }
1312
1313 /**
1314 * Do low-level setup like initializing registers, output signals,
1315 * and clocking.
1316 */
1317 int adapter_init(struct command_context *cmd_ctx)
1318 {
1319 if (jtag)
1320 return ERROR_OK;
1321
1322 if (!jtag_interface) {
1323 /* nothing was previously specified by "interface" command */
1324 LOG_ERROR("Debug Adapter has to be specified, "
1325 "see \"interface\" command");
1326 return ERROR_JTAG_INVALID_INTERFACE;
1327 }
1328
1329 int retval;
1330 retval = jtag_interface->init();
1331 if (retval != ERROR_OK)
1332 return retval;
1333 jtag = jtag_interface;
1334
1335 /* LEGACY SUPPORT ... adapter drivers must declare what
1336 * transports they allow. Until they all do so, assume
1337 * the legacy drivers are JTAG-only
1338 */
1339 if (!transports_are_declared()) {
1340 LOG_ERROR("Adapter driver '%s' did not declare "
1341 "which transports it allows; assuming "
1342 "JTAG-only", jtag->name);
1343 retval = allow_transports(cmd_ctx, jtag_only);
1344 if (retval != ERROR_OK)
1345 return retval;
1346 }
1347
1348 if (jtag->speed == NULL) {
1349 LOG_INFO("This adapter doesn't support configurable speed");
1350 return ERROR_OK;
1351 }
1352
1353 if (CLOCK_MODE_UNSELECTED == clock_mode) {
1354 LOG_ERROR("An adapter speed is not selected in the init script."
1355 " Insert a call to adapter_khz or jtag_rclk to proceed.");
1356 return ERROR_JTAG_INIT_FAILED;
1357 }
1358
1359 int requested_khz = jtag_get_speed_khz();
1360 int actual_khz = requested_khz;
1361 int jtag_speed_var = 0;
1362 retval = jtag_get_speed(&jtag_speed_var);
1363 if (retval != ERROR_OK)
1364 return retval;
1365 retval = jtag->speed(jtag_speed_var);
1366 if (retval != ERROR_OK)
1367 return retval;
1368 retval = jtag_get_speed_readable(&actual_khz);
1369 if (ERROR_OK != retval)
1370 LOG_INFO("adapter-specific clock speed value %d", jtag_speed_var);
1371 else if (actual_khz) {
1372 /* Adaptive clocking -- JTAG-specific */
1373 if ((CLOCK_MODE_RCLK == clock_mode)
1374 || ((CLOCK_MODE_KHZ == clock_mode) && !requested_khz)) {
1375 LOG_INFO("RCLK (adaptive clock speed) not supported - fallback to %d kHz"
1376 , actual_khz);
1377 } else
1378 LOG_INFO("clock speed %d kHz", actual_khz);
1379 } else
1380 LOG_INFO("RCLK (adaptive clock speed)");
1381
1382 return ERROR_OK;
1383 }
1384
1385 int jtag_init_inner(struct command_context *cmd_ctx)
1386 {
1387 struct jtag_tap *tap;
1388 int retval;
1389 bool issue_setup = true;
1390
1391 LOG_DEBUG("Init JTAG chain");
1392
1393 tap = jtag_tap_next_enabled(NULL);
1394 if (tap == NULL) {
1395 /* Once JTAG itself is properly set up, and the scan chain
1396 * isn't absurdly large, IDCODE autoprobe should work fine.
1397 *
1398 * But ... IRLEN autoprobe can fail even on systems which
1399 * are fully conformant to JTAG. Also, JTAG setup can be
1400 * quite finicky on some systems.
1401 *
1402 * REVISIT: if TAP autoprobe works OK, then in many cases
1403 * we could escape to tcl code and set up targets based on
1404 * the TAP's IDCODE values.
1405 */
1406 LOG_WARNING("There are no enabled taps. "
1407 "AUTO PROBING MIGHT NOT WORK!!");
1408
1409 /* REVISIT default clock will often be too fast ... */
1410 }
1411
1412 jtag_add_tlr();
1413 retval = jtag_execute_queue();
1414 if (retval != ERROR_OK)
1415 return retval;
1416
1417 /* Examine DR values first. This discovers problems which will
1418 * prevent communication ... hardware issues like TDO stuck, or
1419 * configuring the wrong number of (enabled) TAPs.
1420 */
1421 retval = jtag_examine_chain();
1422 switch (retval) {
1423 case ERROR_OK:
1424 /* complete success */
1425 break;
1426 default:
1427 /* For backward compatibility reasons, try coping with
1428 * configuration errors involving only ID mismatches.
1429 * We might be able to talk to the devices.
1430 *
1431 * Also the device might be powered down during startup.
1432 *
1433 * After OpenOCD starts, we can try to power on the device
1434 * and run a reset.
1435 */
1436 LOG_ERROR("Trying to use configured scan chain anyway...");
1437 issue_setup = false;
1438 break;
1439 }
1440
1441 /* Now look at IR values. Problems here will prevent real
1442 * communication. They mostly mean that the IR length is
1443 * wrong ... or that the IR capture value is wrong. (The
1444 * latter is uncommon, but easily worked around: provide
1445 * ircapture/irmask values during TAP setup.)
1446 */
1447 retval = jtag_validate_ircapture();
1448 if (retval != ERROR_OK) {
1449 /* The target might be powered down. The user
1450 * can power it up and reset it after firing
1451 * up OpenOCD.
1452 */
1453 issue_setup = false;
1454 }
1455
1456 if (issue_setup)
1457 jtag_notify_event(JTAG_TAP_EVENT_SETUP);
1458 else
1459 LOG_WARNING("Bypassing JTAG setup events due to errors");
1460
1461
1462 return ERROR_OK;
1463 }
1464
1465 int adapter_quit(void)
1466 {
1467 if (!jtag || !jtag->quit)
1468 return ERROR_OK;
1469
1470 /* close the JTAG interface */
1471 int result = jtag->quit();
1472 if (ERROR_OK != result)
1473 LOG_ERROR("failed: %d", result);
1474
1475 return ERROR_OK;
1476 }
1477
1478 int swd_init_reset(struct command_context *cmd_ctx)
1479 {
1480 int retval = adapter_init(cmd_ctx);
1481 if (retval != ERROR_OK)
1482 return retval;
1483
1484 LOG_DEBUG("Initializing with hard SRST reset");
1485
1486 if (jtag_reset_config & RESET_HAS_SRST)
1487 swd_add_reset(1);
1488 swd_add_reset(0);
1489 retval = jtag_execute_queue();
1490 return retval;
1491 }
1492
1493 int jtag_init_reset(struct command_context *cmd_ctx)
1494 {
1495 int retval = adapter_init(cmd_ctx);
1496 if (retval != ERROR_OK)
1497 return retval;
1498
1499 LOG_DEBUG("Initializing with hard TRST+SRST reset");
1500
1501 /*
1502 * This procedure is used by default when OpenOCD triggers a reset.
1503 * It's now done through an overridable Tcl "init_reset" wrapper.
1504 *
1505 * This started out as a more powerful "get JTAG working" reset than
1506 * jtag_init_inner(), applying TRST because some chips won't activate
1507 * JTAG without a TRST cycle (presumed to be async, though some of
1508 * those chips synchronize JTAG activation using TCK).
1509 *
1510 * But some chips only activate JTAG as part of an SRST cycle; SRST
1511 * got mixed in. So it became a hard reset routine, which got used
1512 * in more places, and which coped with JTAG reset being forced as
1513 * part of SRST (srst_pulls_trst).
1514 *
1515 * And even more corner cases started to surface: TRST and/or SRST
1516 * assertion timings matter; some chips need other JTAG operations;
1517 * TRST/SRST sequences can need to be different from these, etc.
1518 *
1519 * Systems should override that wrapper to support system-specific
1520 * requirements that this not-fully-generic code doesn't handle.
1521 *
1522 * REVISIT once Tcl code can read the reset_config modes, this won't
1523 * need to be a C routine at all...
1524 */
1525 if (jtag_reset_config & RESET_HAS_SRST) {
1526 jtag_add_reset(1, 1);
1527 if ((jtag_reset_config & RESET_SRST_PULLS_TRST) == 0)
1528 jtag_add_reset(0, 1);
1529 } else {
1530 jtag_add_reset(1, 0); /* TAP_RESET, using TMS+TCK or TRST */
1531 }
1532
1533 /* some targets enable us to connect with srst asserted */
1534 if (jtag_reset_config & RESET_CNCT_UNDER_SRST) {
1535 if (jtag_reset_config & RESET_SRST_NO_GATING)
1536 jtag_add_reset(0, 1);
1537 else {
1538 LOG_WARNING("\'srst_nogate\' reset_config option is required");
1539 jtag_add_reset(0, 0);
1540 }
1541 } else
1542 jtag_add_reset(0, 0);
1543 retval = jtag_execute_queue();
1544 if (retval != ERROR_OK)
1545 return retval;
1546
1547 /* Check that we can communication on the JTAG chain + eventually we want to
1548 * be able to perform enumeration only after OpenOCD has started
1549 * telnet and GDB server
1550 *
1551 * That would allow users to more easily perform any magic they need to before
1552 * reset happens.
1553 */
1554 return jtag_init_inner(cmd_ctx);
1555 }
1556
1557 int jtag_init(struct command_context *cmd_ctx)
1558 {
1559 int retval = adapter_init(cmd_ctx);
1560 if (retval != ERROR_OK)
1561 return retval;
1562
1563 /* guard against oddball hardware: force resets to be inactive */
1564 jtag_add_reset(0, 0);
1565
1566 /* some targets enable us to connect with srst asserted */
1567 if (jtag_reset_config & RESET_CNCT_UNDER_SRST) {
1568 if (jtag_reset_config & RESET_SRST_NO_GATING)
1569 jtag_add_reset(0, 1);
1570 else
1571 LOG_WARNING("\'srst_nogate\' reset_config option is required");
1572 }
1573 retval = jtag_execute_queue();
1574 if (retval != ERROR_OK)
1575 return retval;
1576
1577 if (Jim_Eval_Named(cmd_ctx->interp, "jtag_init", __FILE__, __LINE__) != JIM_OK)
1578 return ERROR_FAIL;
1579
1580 return ERROR_OK;
1581 }
1582
1583 unsigned jtag_get_speed_khz(void)
1584 {
1585 return speed_khz;
1586 }
1587
1588 static int adapter_khz_to_speed(unsigned khz, int *speed)
1589 {
1590 LOG_DEBUG("convert khz to interface specific speed value");
1591 speed_khz = khz;
1592 if (jtag != NULL) {
1593 LOG_DEBUG("have interface set up");
1594 int speed_div1;
1595 int retval = jtag->khz(jtag_get_speed_khz(), &speed_div1);
1596 if (ERROR_OK != retval)
1597 return retval;
1598 *speed = speed_div1;
1599 }
1600 return ERROR_OK;
1601 }
1602
1603 static int jtag_rclk_to_speed(unsigned fallback_speed_khz, int *speed)
1604 {
1605 int retval = adapter_khz_to_speed(0, speed);
1606 if ((ERROR_OK != retval) && fallback_speed_khz) {
1607 LOG_DEBUG("trying fallback speed...");
1608 retval = adapter_khz_to_speed(fallback_speed_khz, speed);
1609 }
1610 return retval;
1611 }
1612
1613 static int jtag_set_speed(int speed)
1614 {
1615 jtag_speed = speed;
1616 /* this command can be called during CONFIG,
1617 * in which case jtag isn't initialized */
1618 return jtag ? jtag->speed(speed) : ERROR_OK;
1619 }
1620
1621 int jtag_config_khz(unsigned khz)
1622 {
1623 LOG_DEBUG("handle jtag khz");
1624 clock_mode = CLOCK_MODE_KHZ;
1625 int speed = 0;
1626 int retval = adapter_khz_to_speed(khz, &speed);
1627 return (ERROR_OK != retval) ? retval : jtag_set_speed(speed);
1628 }
1629
1630 int jtag_config_rclk(unsigned fallback_speed_khz)
1631 {
1632 LOG_DEBUG("handle jtag rclk");
1633 clock_mode = CLOCK_MODE_RCLK;
1634 rclk_fallback_speed_khz = fallback_speed_khz;
1635 int speed = 0;
1636 int retval = jtag_rclk_to_speed(fallback_speed_khz, &speed);
1637 return (ERROR_OK != retval) ? retval : jtag_set_speed(speed);
1638 }
1639
1640 int jtag_get_speed(int *speed)
1641 {
1642 switch (clock_mode) {
1643 case CLOCK_MODE_KHZ:
1644 adapter_khz_to_speed(jtag_get_speed_khz(), speed);
1645 break;
1646 case CLOCK_MODE_RCLK:
1647 jtag_rclk_to_speed(rclk_fallback_speed_khz, speed);
1648 break;
1649 default:
1650 LOG_ERROR("BUG: unknown jtag clock mode");
1651 return ERROR_FAIL;
1652 }
1653 return ERROR_OK;
1654 }
1655
1656 int jtag_get_speed_readable(int *khz)
1657 {
1658 int jtag_speed_var = 0;
1659 int retval = jtag_get_speed(&jtag_speed_var);
1660 if (retval != ERROR_OK)
1661 return retval;
1662 return jtag ? jtag->speed_div(jtag_speed_var, khz) : ERROR_OK;
1663 }
1664
1665 void jtag_set_verify(bool enable)
1666 {
1667 jtag_verify = enable;
1668 }
1669
1670 bool jtag_will_verify()
1671 {
1672 return jtag_verify;
1673 }
1674
1675 void jtag_set_verify_capture_ir(bool enable)
1676 {
1677 jtag_verify_capture_ir = enable;
1678 }
1679
1680 bool jtag_will_verify_capture_ir()
1681 {
1682 return jtag_verify_capture_ir;
1683 }
1684
1685 int jtag_power_dropout(int *dropout)
1686 {
1687 if (jtag == NULL) {
1688 /* TODO: as the jtag interface is not valid all
1689 * we can do at the moment is exit OpenOCD */
1690 LOG_ERROR("No Valid JTAG Interface Configured.");
1691 exit(-1);
1692 }
1693 return jtag->power_dropout(dropout);
1694 }
1695
1696 int jtag_srst_asserted(int *srst_asserted)
1697 {
1698 return jtag->srst_asserted(srst_asserted);
1699 }
1700
1701 enum reset_types jtag_get_reset_config(void)
1702 {
1703 return jtag_reset_config;
1704 }
1705 void jtag_set_reset_config(enum reset_types type)
1706 {
1707 jtag_reset_config = type;
1708 }
1709
1710 int jtag_get_trst(void)
1711 {
1712 return jtag_trst;
1713 }
1714 int jtag_get_srst(void)
1715 {
1716 return jtag_srst;
1717 }
1718
1719 void jtag_set_nsrst_delay(unsigned delay)
1720 {
1721 adapter_nsrst_delay = delay;
1722 }
1723 unsigned jtag_get_nsrst_delay(void)
1724 {
1725 return adapter_nsrst_delay;
1726 }
1727 void jtag_set_ntrst_delay(unsigned delay)
1728 {
1729 jtag_ntrst_delay = delay;
1730 }
1731 unsigned jtag_get_ntrst_delay(void)
1732 {
1733 return jtag_ntrst_delay;
1734 }
1735
1736
1737 void jtag_set_nsrst_assert_width(unsigned delay)
1738 {
1739 adapter_nsrst_assert_width = delay;
1740 }
1741 unsigned jtag_get_nsrst_assert_width(void)
1742 {
1743 return adapter_nsrst_assert_width;
1744 }
1745 void jtag_set_ntrst_assert_width(unsigned delay)
1746 {
1747 jtag_ntrst_assert_width = delay;
1748 }
1749 unsigned jtag_get_ntrst_assert_width(void)
1750 {
1751 return jtag_ntrst_assert_width;
1752 }
1753
1754 static int jtag_select(struct command_context *ctx)
1755 {
1756 int retval;
1757
1758 /* NOTE: interface init must already have been done.
1759 * That works with only C code ... no Tcl glue required.
1760 */
1761
1762 retval = jtag_register_commands(ctx);
1763
1764 if (retval != ERROR_OK)
1765 return retval;
1766
1767 retval = svf_register_commands(ctx);
1768
1769 if (retval != ERROR_OK)
1770 return retval;
1771
1772 return xsvf_register_commands(ctx);
1773 }
1774
1775 static struct transport jtag_transport = {
1776 .name = "jtag",
1777 .select = jtag_select,
1778 .init = jtag_init,
1779 };
1780
1781 static void jtag_constructor(void) __attribute__((constructor));
1782 static void jtag_constructor(void)
1783 {
1784 transport_register(&jtag_transport);
1785 }
1786
1787 /** Returns true if the current debug session
1788 * is using JTAG as its transport.
1789 */
1790 bool transport_is_jtag(void)
1791 {
1792 return get_current_transport() == &jtag_transport;
1793 }
1794
1795 void adapter_assert_reset(void)
1796 {
1797 if (transport_is_jtag()) {
1798 if (jtag_reset_config & RESET_SRST_PULLS_TRST)
1799 jtag_add_reset(1, 1);
1800 else
1801 jtag_add_reset(0, 1);
1802 } else if (transport_is_swd())
1803 swd_add_reset(1);
1804 else if (transport_is_cmsis_dap())
1805 swd_add_reset(1); /* FIXME */
1806 else if (get_current_transport() != NULL)
1807 LOG_ERROR("reset is not supported on %s",
1808 get_current_transport()->name);
1809 else
1810 LOG_ERROR("transport is not selected");
1811 }
1812
1813 void adapter_deassert_reset(void)
1814 {
1815 if (transport_is_jtag())
1816 jtag_add_reset(0, 0);
1817 else if (transport_is_swd())
1818 swd_add_reset(0);
1819 else if (transport_is_cmsis_dap())
1820 swd_add_reset(0); /* FIXME */
1821 else if (get_current_transport() != NULL)
1822 LOG_ERROR("reset is not supported on %s",
1823 get_current_transport()->name);
1824 else
1825 LOG_ERROR("transport is not selected");
1826 }
1827
1828 int adapter_config_trace(bool enabled, enum tpio_pin_protocol pin_protocol,
1829 uint32_t port_size, unsigned int *trace_freq)
1830 {
1831 if (jtag->config_trace)
1832 return jtag->config_trace(enabled, pin_protocol, port_size,
1833 trace_freq);
1834 else if (enabled) {
1835 LOG_ERROR("The selected interface does not support tracing");
1836 return ERROR_FAIL;
1837 }
1838
1839 return ERROR_OK;
1840 }
1841
1842 int adapter_poll_trace(uint8_t *buf, size_t *size)
1843 {
1844 if (jtag->poll_trace)
1845 return jtag->poll_trace(buf, size);
1846
1847 return ERROR_FAIL;
1848 }