Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Simplify and fix bug in jtag_tap_by_string:
[openocd.git] / src / jtag / jtag.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2009 SoftPLC Corporation *
9 * http://softplc.com *
10 * dick@softplc.com *
11 * *
12 * This program is free software; you can redistribute it and/or modify *
13 * it under the terms of the GNU General Public License as published by *
14 * the Free Software Foundation; either version 2 of the License, or *
15 * (at your option) any later version. *
16 * *
17 * This program is distributed in the hope that it will be useful, *
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
20 * GNU General Public License for more details. *
21 * *
22 * You should have received a copy of the GNU General Public License *
23 * along with this program; if not, write to the *
24 * Free Software Foundation, Inc., *
25 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
26 ***************************************************************************/
27 #ifdef HAVE_CONFIG_H
28 #include "config.h"
29 #endif
30
31 #include "jtag.h"
32 #include "minidriver.h"
33 #include "interface.h"
34
35 #ifdef HAVE_STRINGS_H
36 #include <strings.h>
37 #endif
38
39
40 /// The number of JTAG queue flushes (for profiling and debugging purposes).
41 static int jtag_flush_queue_count;
42
43 static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state),
44 int in_num_fields, scan_field_t *in_fields, tap_state_t state);
45
46 /* note that this is not marked as static as it must be available from outside jtag.c for those
47 that implement the jtag_xxx() minidriver layer
48 */
49 int jtag_error=ERROR_OK;
50
51 char* jtag_event_strings[] =
52 {
53 "JTAG controller reset (RESET or TRST)"
54 };
55
56 const Jim_Nvp nvp_jtag_tap_event[] = {
57 { .value = JTAG_TAP_EVENT_ENABLE, .name = "tap-enable" },
58 { .value = JTAG_TAP_EVENT_DISABLE, .name = "tap-disable" },
59
60 { .name = NULL, .value = -1 }
61 };
62
63 int jtag_trst = 0;
64 int jtag_srst = 0;
65
66 /**
67 * List all TAPs that have been created.
68 */
69 static jtag_tap_t *__jtag_all_taps = NULL;
70 /**
71 * The number of TAPs in the __jtag_all_taps list, used to track the
72 * assigned chain position to new TAPs
73 */
74 static int jtag_num_taps = 0;
75
76 enum reset_types jtag_reset_config = RESET_NONE;
77 tap_state_t cmd_queue_end_state = TAP_RESET;
78 tap_state_t cmd_queue_cur_state = TAP_RESET;
79
80 int jtag_verify_capture_ir = 1;
81 int jtag_verify = 1;
82
83 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
84 static int jtag_nsrst_delay = 0; /* default to no nSRST delay */
85 static int jtag_ntrst_delay = 0; /* default to no nTRST delay */
86
87 /* callbacks to inform high-level handlers about JTAG state changes */
88 jtag_event_callback_t *jtag_event_callbacks;
89
90 /* speed in kHz*/
91 static int speed_khz = 0;
92 /* flag if the kHz speed was defined */
93 static bool hasKHz = false;
94
95 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
96 */
97
98 #if BUILD_ECOSBOARD == 1
99 extern jtag_interface_t zy1000_interface;
100 #elif defined(BUILD_MINIDRIVER_DUMMY)
101 extern jtag_interface_t minidummy_interface;
102 #else // standard drivers
103 #if BUILD_PARPORT == 1
104 extern jtag_interface_t parport_interface;
105 #endif
106
107 #if BUILD_DUMMY == 1
108 extern jtag_interface_t dummy_interface;
109 #endif
110
111 #if BUILD_FT2232_FTD2XX == 1
112 extern jtag_interface_t ft2232_interface;
113 #endif
114
115 #if BUILD_FT2232_LIBFTDI == 1
116 extern jtag_interface_t ft2232_interface;
117 #endif
118
119 #if BUILD_AMTJTAGACCEL == 1
120 extern jtag_interface_t amt_jtagaccel_interface;
121 #endif
122
123 #if BUILD_EP93XX == 1
124 extern jtag_interface_t ep93xx_interface;
125 #endif
126
127 #if BUILD_AT91RM9200 == 1
128 extern jtag_interface_t at91rm9200_interface;
129 #endif
130
131 #if BUILD_GW16012 == 1
132 extern jtag_interface_t gw16012_interface;
133 #endif
134
135 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
136 extern jtag_interface_t presto_interface;
137 #endif
138
139 #if BUILD_USBPROG == 1
140 extern jtag_interface_t usbprog_interface;
141 #endif
142
143 #if BUILD_JLINK == 1
144 extern jtag_interface_t jlink_interface;
145 #endif
146
147 #if BUILD_VSLLINK == 1
148 extern jtag_interface_t vsllink_interface;
149 #endif
150
151 #if BUILD_RLINK == 1
152 extern jtag_interface_t rlink_interface;
153 #endif
154
155 #if BUILD_ARMJTAGEW == 1
156 extern jtag_interface_t armjtagew_interface;
157 #endif
158 #endif // standard drivers
159
160 /**
161 * The list of built-in JTAG interfaces, containing entries for those
162 * drivers that were enabled by the @c configure script.
163 *
164 * The list should be defined to contain either one minidriver interface
165 * or some number of standard driver interfaces, never both.
166 */
167 jtag_interface_t *jtag_interfaces[] = {
168 #if BUILD_ECOSBOARD == 1
169 &zy1000_interface,
170 #elif defined(BUILD_MINIDRIVER_DUMMY)
171 &minidummy_interface,
172 #else // standard drivers
173 #if BUILD_PARPORT == 1
174 &parport_interface,
175 #endif
176 #if BUILD_DUMMY == 1
177 &dummy_interface,
178 #endif
179 #if BUILD_FT2232_FTD2XX == 1
180 &ft2232_interface,
181 #endif
182 #if BUILD_FT2232_LIBFTDI == 1
183 &ft2232_interface,
184 #endif
185 #if BUILD_AMTJTAGACCEL == 1
186 &amt_jtagaccel_interface,
187 #endif
188 #if BUILD_EP93XX == 1
189 &ep93xx_interface,
190 #endif
191 #if BUILD_AT91RM9200 == 1
192 &at91rm9200_interface,
193 #endif
194 #if BUILD_GW16012 == 1
195 &gw16012_interface,
196 #endif
197 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
198 &presto_interface,
199 #endif
200 #if BUILD_USBPROG == 1
201 &usbprog_interface,
202 #endif
203 #if BUILD_JLINK == 1
204 &jlink_interface,
205 #endif
206 #if BUILD_VSLLINK == 1
207 &vsllink_interface,
208 #endif
209 #if BUILD_RLINK == 1
210 &rlink_interface,
211 #endif
212 #if BUILD_ARMJTAGEW == 1
213 &armjtagew_interface,
214 #endif
215 #endif // standard drivers
216 NULL,
217 };
218
219 struct jtag_interface_s *jtag = NULL;
220
221 /* configuration */
222 static jtag_interface_t *jtag_interface = NULL;
223 int jtag_speed = 0;
224
225 /* jtag commands */
226 static int handle_interface_list_command(struct command_context_s *cmd_ctx,
227 char *cmd, char **args, int argc);
228 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
229 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
230 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
231 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
232 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
233 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
234 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
235
236 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
237
238 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
239 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
240 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
241 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
242 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args);
243
244 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
245 static int handle_verify_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
246 static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
247
248 jtag_tap_t *jtag_all_taps(void)
249 {
250 return __jtag_all_taps;
251 };
252
253 int jtag_tap_count(void)
254 {
255 return jtag_num_taps;
256 }
257
258 unsigned jtag_tap_count_enabled(void)
259 {
260 jtag_tap_t *t = jtag_all_taps();
261 unsigned n = 0;
262 while(t)
263 {
264 if (t->enabled)
265 n++;
266 t = t->next_tap;
267 }
268 return n;
269 }
270
271 /// Append a new TAP to the chain of all taps.
272 void jtag_tap_add(struct jtag_tap_s *t)
273 {
274 t->abs_chain_position = jtag_num_taps++;
275
276 jtag_tap_t **tap = &__jtag_all_taps;
277 while(*tap != NULL)
278 tap = &(*tap)->next_tap;
279 *tap = t;
280 }
281
282 jtag_tap_t *jtag_tap_by_string(const char *s)
283 {
284 /* try by name first */
285 jtag_tap_t *t = jtag_all_taps();
286 while (t)
287 {
288 if (0 == strcmp(t->dotted_name, s))
289 return t;
290 t = t->next_tap;
291 }
292
293 /* no tap found by name, so try to parse the name as a number */
294 char *cp;
295 unsigned n = strtoul(s, &cp, 0);
296 if ((s == cp) || (*cp != 0))
297 return NULL;
298
299 return jtag_tap_by_abs_position(n);
300 }
301
302 jtag_tap_t * jtag_tap_by_jim_obj( Jim_Interp *interp, Jim_Obj *o )
303 {
304 jtag_tap_t *t;
305 const char *cp;
306
307 cp = Jim_GetString( o, NULL );
308 if(cp == NULL){
309 cp = "(unknown)";
310 t = NULL;
311 } else {
312 t = jtag_tap_by_string( cp );
313 }
314 if( t == NULL ){
315 Jim_SetResult_sprintf(interp,"Tap: %s is unknown", cp );
316 }
317 return t;
318 }
319
320 /* returns a pointer to the n-th device in the scan chain */
321 jtag_tap_t * jtag_tap_by_abs_position( int n )
322 {
323 int orig_n;
324 jtag_tap_t *t;
325
326 orig_n = n;
327 t = jtag_all_taps();
328
329 while( t && (n > 0)) {
330 n--;
331 t = t->next_tap;
332 }
333 return t;
334 }
335
336 const char *jtag_tap_name(const jtag_tap_t *tap)
337 {
338 return (tap == NULL) ? "(unknown)" : tap->dotted_name;
339 }
340
341
342 int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
343 {
344 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
345
346 if (callback == NULL)
347 {
348 return ERROR_INVALID_ARGUMENTS;
349 }
350
351 if (*callbacks_p)
352 {
353 while ((*callbacks_p)->next)
354 callbacks_p = &((*callbacks_p)->next);
355 callbacks_p = &((*callbacks_p)->next);
356 }
357
358 (*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
359 (*callbacks_p)->callback = callback;
360 (*callbacks_p)->priv = priv;
361 (*callbacks_p)->next = NULL;
362
363 return ERROR_OK;
364 }
365
366 int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
367 {
368 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
369
370 if (callback == NULL)
371 {
372 return ERROR_INVALID_ARGUMENTS;
373 }
374
375 while (*callbacks_p)
376 {
377 jtag_event_callback_t **next = &((*callbacks_p)->next);
378 if ((*callbacks_p)->callback == callback)
379 {
380 free(*callbacks_p);
381 *callbacks_p = *next;
382 }
383 callbacks_p = next;
384 }
385
386 return ERROR_OK;
387 }
388
389 int jtag_call_event_callbacks(enum jtag_event event)
390 {
391 jtag_event_callback_t *callback = jtag_event_callbacks;
392
393 LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
394
395 while (callback)
396 {
397 callback->callback(event, callback->priv);
398 callback = callback->next;
399 }
400
401 return ERROR_OK;
402 }
403
404 static void jtag_checks(void)
405 {
406 assert(jtag_trst == 0);
407 }
408
409 static void jtag_prelude(tap_state_t state)
410 {
411 jtag_checks();
412
413 assert(state!=TAP_INVALID);
414
415 cmd_queue_cur_state = state;
416 }
417
418 void jtag_alloc_in_value32(scan_field_t *field)
419 {
420 interface_jtag_alloc_in_value32(field);
421 }
422
423 void jtag_add_ir_scan_noverify(int in_count, const scan_field_t *in_fields,
424 tap_state_t state)
425 {
426 jtag_prelude(state);
427
428 int retval = interface_jtag_add_ir_scan(in_count, in_fields, state);
429 jtag_set_error(retval);
430 }
431
432
433 /**
434 * Generate an IR SCAN with a list of scan fields with one entry for each enabled TAP.
435 *
436 * If the input field list contains an instruction value for a TAP then that is used
437 * otherwise the TAP is set to bypass.
438 *
439 * TAPs for which no fields are passed are marked as bypassed for subsequent DR SCANs.
440 *
441 */
442 void jtag_add_ir_scan(int in_num_fields, scan_field_t *in_fields, tap_state_t state)
443 {
444 if (jtag_verify&&jtag_verify_capture_ir)
445 {
446 /* 8 x 32 bit id's is enough for all invocations */
447
448 for (int j = 0; j < in_num_fields; j++)
449 {
450 /* if we are to run a verification of the ir scan, we need to get the input back.
451 * We may have to allocate space if the caller didn't ask for the input back.
452 */
453 in_fields[j].check_value=in_fields[j].tap->expected;
454 in_fields[j].check_mask=in_fields[j].tap->expected_mask;
455 }
456 jtag_add_scan_check(jtag_add_ir_scan_noverify, in_num_fields, in_fields, state);
457 } else
458 {
459 jtag_add_ir_scan_noverify(in_num_fields, in_fields, state);
460 }
461 }
462
463 /**
464 * Duplicate the scan fields passed into the function into an IR SCAN command
465 *
466 * This function assumes that the caller handles extra fields for bypassed TAPs
467 *
468 */
469 void jtag_add_plain_ir_scan(int in_num_fields, const scan_field_t *in_fields,
470 tap_state_t state)
471 {
472 jtag_prelude(state);
473
474 int retval = interface_jtag_add_plain_ir_scan(
475 in_num_fields, in_fields, state);
476 jtag_set_error(retval);
477 }
478
479 void jtag_add_callback(jtag_callback1_t f, u8 *in)
480 {
481 interface_jtag_add_callback(f, in);
482 }
483
484 void jtag_add_callback4(jtag_callback_t f, u8 *in,
485 jtag_callback_data_t data1, jtag_callback_data_t data2,
486 jtag_callback_data_t data3)
487 {
488 interface_jtag_add_callback4(f, in, data1, data2, data3);
489 }
490
491 int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, int num_bits);
492
493 static int jtag_check_value_mask_callback(u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3)
494 {
495 return jtag_check_value_inner(in, (u8 *)data1, (u8 *)data2, (int)data3);
496 }
497
498 static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state),
499 int in_num_fields, scan_field_t *in_fields, tap_state_t state)
500 {
501 for (int i = 0; i < in_num_fields; i++)
502 {
503 struct scan_field_s *field = &in_fields[i];
504 field->allocated = 0;
505 field->modified = 0;
506 if (field->check_value || field->in_value)
507 continue;
508 interface_jtag_add_scan_check_alloc(field);
509 field->modified = 1;
510 }
511
512 jtag_add_scan(in_num_fields, in_fields, state);
513
514 for (int i = 0; i < in_num_fields; i++)
515 {
516 if ((in_fields[i].check_value != NULL) && (in_fields[i].in_value != NULL))
517 {
518 /* this is synchronous for a minidriver */
519 jtag_add_callback4(jtag_check_value_mask_callback, in_fields[i].in_value,
520 (jtag_callback_data_t)in_fields[i].check_value,
521 (jtag_callback_data_t)in_fields[i].check_mask,
522 (jtag_callback_data_t)in_fields[i].num_bits);
523 }
524 if (in_fields[i].allocated)
525 {
526 free(in_fields[i].in_value);
527 }
528 if (in_fields[i].modified)
529 {
530 in_fields[i].in_value = NULL;
531 }
532 }
533 }
534
535 void jtag_add_dr_scan_check(int in_num_fields, scan_field_t *in_fields, tap_state_t state)
536 {
537 if (jtag_verify)
538 {
539 jtag_add_scan_check(jtag_add_dr_scan, in_num_fields, in_fields, state);
540 } else
541 {
542 jtag_add_dr_scan(in_num_fields, in_fields, state);
543 }
544 }
545
546
547 /**
548 * Generate a DR SCAN using the fields passed to the function.
549 * For connected TAPs, the function checks in_fields and uses fields
550 * specified there. For bypassed TAPs, the function generates a dummy
551 * 1-bit field. The bypass status of TAPs is set by jtag_add_ir_scan().
552 */
553 void jtag_add_dr_scan(int in_num_fields, const scan_field_t *in_fields,
554 tap_state_t state)
555 {
556 jtag_prelude(state);
557
558 int retval;
559 retval = interface_jtag_add_dr_scan(in_num_fields, in_fields, state);
560 jtag_set_error(retval);
561 }
562
563 /**
564 * Duplicate the scan fields passed into the function into a DR SCAN
565 * command. Unlike jtag_add_dr_scan(), this function assumes that the
566 * caller handles extra fields for bypassed TAPs.
567 */
568 void jtag_add_plain_dr_scan(int in_num_fields, const scan_field_t *in_fields,
569 tap_state_t state)
570 {
571 jtag_prelude(state);
572
573 int retval;
574 retval = interface_jtag_add_plain_dr_scan(in_num_fields, in_fields, state);
575 jtag_set_error(retval);
576 }
577
578 void jtag_add_dr_out(jtag_tap_t* tap,
579 int num_fields, const int* num_bits, const u32* value,
580 tap_state_t end_state)
581 {
582 assert(end_state != TAP_INVALID);
583
584 cmd_queue_cur_state = end_state;
585
586 interface_jtag_add_dr_out(tap,
587 num_fields, num_bits, value,
588 end_state);
589 }
590
591 void jtag_add_tlr(void)
592 {
593 jtag_prelude(TAP_RESET);
594 jtag_set_error(interface_jtag_add_tlr());
595 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
596 }
597
598 void jtag_add_pathmove(int num_states, const tap_state_t *path)
599 {
600 tap_state_t cur_state = cmd_queue_cur_state;
601
602 /* the last state has to be a stable state */
603 if (!tap_is_state_stable(path[num_states - 1]))
604 {
605 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
606 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE);
607 return;
608 }
609
610 for (int i = 0; i < num_states; i++)
611 {
612 if (path[i] == TAP_RESET)
613 {
614 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
615 jtag_set_error(ERROR_JTAG_STATE_INVALID);
616 return;
617 }
618
619 if ( tap_state_transition(cur_state, true) != path[i]
620 && tap_state_transition(cur_state, false) != path[i])
621 {
622 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
623 tap_state_name(cur_state), tap_state_name(path[i]));
624 jtag_set_error(ERROR_JTAG_TRANSITION_INVALID);
625 return;
626 }
627 cur_state = path[i];
628 }
629
630 jtag_checks();
631
632 jtag_set_error(interface_jtag_add_pathmove(num_states, path));
633 cmd_queue_cur_state = path[num_states - 1];
634 }
635
636 void jtag_add_runtest(int num_cycles, tap_state_t state)
637 {
638 jtag_prelude(state);
639 jtag_set_error(interface_jtag_add_runtest(num_cycles, state));
640 }
641
642
643 void jtag_add_clocks(int num_cycles)
644 {
645 if (!tap_is_state_stable(cmd_queue_cur_state))
646 {
647 LOG_ERROR("jtag_add_clocks() called with TAP in unstable state \"%s\"",
648 tap_state_name(cmd_queue_cur_state));
649 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE);
650 return;
651 }
652
653 if (num_cycles > 0)
654 {
655 jtag_checks();
656 jtag_set_error(interface_jtag_add_clocks(num_cycles));
657 }
658 }
659
660 void jtag_add_reset(int req_tlr_or_trst, int req_srst)
661 {
662 int trst_with_tlr = 0;
663
664 /* FIX!!! there are *many* different cases here. A better
665 * approach is needed for legal combinations of transitions...
666 */
667 if ((jtag_reset_config & RESET_HAS_SRST)&&
668 (jtag_reset_config & RESET_HAS_TRST)&&
669 ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0))
670 {
671 if (((req_tlr_or_trst&&!jtag_trst)||
672 (!req_tlr_or_trst&&jtag_trst))&&
673 ((req_srst&&!jtag_srst)||
674 (!req_srst&&jtag_srst)))
675 {
676 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
677 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
678 }
679 }
680
681 /* Make sure that jtag_reset_config allows the requested reset */
682 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
683 if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst))
684 {
685 LOG_ERROR("BUG: requested reset would assert trst");
686 jtag_set_error(ERROR_FAIL);
687 return;
688 }
689
690 /* if TRST pulls SRST, we reset with TAP T-L-R */
691 if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0))
692 {
693 trst_with_tlr = 1;
694 }
695
696 if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
697 {
698 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
699 jtag_set_error(ERROR_FAIL);
700 return;
701 }
702
703 if (req_tlr_or_trst)
704 {
705 if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST))
706 {
707 jtag_trst = 1;
708 } else
709 {
710 trst_with_tlr = 1;
711 }
712 } else
713 {
714 jtag_trst = 0;
715 }
716
717 jtag_srst = req_srst;
718
719 int retval = interface_jtag_add_reset(jtag_trst, jtag_srst);
720 if (retval != ERROR_OK)
721 {
722 jtag_set_error(retval);
723 return;
724 }
725 jtag_execute_queue();
726
727 if (jtag_srst)
728 {
729 LOG_DEBUG("SRST line asserted");
730 }
731 else
732 {
733 LOG_DEBUG("SRST line released");
734 if (jtag_nsrst_delay)
735 jtag_add_sleep(jtag_nsrst_delay * 1000);
736 }
737
738 if (trst_with_tlr)
739 {
740 LOG_DEBUG("JTAG reset with RESET instead of TRST");
741 jtag_set_end_state(TAP_RESET);
742 jtag_add_tlr();
743 return;
744 }
745
746 if (jtag_trst)
747 {
748 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
749 * and inform possible listeners about this
750 */
751 LOG_DEBUG("TRST line asserted");
752 tap_set_state(TAP_RESET);
753 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
754 }
755 else
756 {
757 if (jtag_ntrst_delay)
758 jtag_add_sleep(jtag_ntrst_delay * 1000);
759 }
760 }
761
762 tap_state_t jtag_set_end_state(tap_state_t state)
763 {
764 if ((state == TAP_DRSHIFT)||(state == TAP_IRSHIFT))
765 {
766 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
767 }
768
769 if (state!=TAP_INVALID)
770 cmd_queue_end_state = state;
771 return cmd_queue_end_state;
772 }
773
774 tap_state_t jtag_get_end_state(void)
775 {
776 return cmd_queue_end_state;
777 }
778
779 void jtag_add_sleep(u32 us)
780 {
781 /// @todo Here, keep_alive() appears to be a layering violation!!!
782 keep_alive();
783 jtag_set_error(interface_jtag_add_sleep(us));
784 }
785
786 int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, int num_bits)
787 {
788 int retval = ERROR_OK;
789
790 int compare_failed = 0;
791
792 if (in_check_mask)
793 compare_failed = buf_cmp_mask(captured, in_check_value, in_check_mask, num_bits);
794 else
795 compare_failed = buf_cmp(captured, in_check_value, num_bits);
796
797 if (compare_failed){
798 /* An error handler could have caught the failing check
799 * only report a problem when there wasn't a handler, or if the handler
800 * acknowledged the error
801 */
802 /*
803 LOG_WARNING("TAP %s:",
804 jtag_tap_name(field->tap));
805 */
806 if (compare_failed)
807 {
808 char *captured_char = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
809 char *in_check_value_char = buf_to_str(in_check_value, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
810
811 if (in_check_mask)
812 {
813 char *in_check_mask_char;
814 in_check_mask_char = buf_to_str(in_check_mask, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
815 LOG_WARNING("value captured during scan didn't pass the requested check:");
816 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
817 captured_char, in_check_value_char, in_check_mask_char);
818 free(in_check_mask_char);
819 }
820 else
821 {
822 LOG_WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s", captured_char, in_check_value_char);
823 }
824
825 free(captured_char);
826 free(in_check_value_char);
827
828 retval = ERROR_JTAG_QUEUE_FAILED;
829 }
830
831 }
832 return retval;
833 }
834
835 void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask)
836 {
837 assert(field->in_value != NULL);
838
839 if (value==NULL)
840 {
841 /* no checking to do */
842 return;
843 }
844
845 jtag_execute_queue_noclear();
846
847 int retval=jtag_check_value_inner(field->in_value, value, mask, field->num_bits);
848 jtag_set_error(retval);
849 }
850
851
852
853 int default_interface_jtag_execute_queue(void)
854 {
855 if (NULL == jtag)
856 {
857 LOG_ERROR("No JTAG interface configured yet. "
858 "Issue 'init' command in startup scripts "
859 "before communicating with targets.");
860 return ERROR_FAIL;
861 }
862
863 return jtag->execute_queue();
864 }
865
866 void jtag_execute_queue_noclear(void)
867 {
868 jtag_flush_queue_count++;
869 jtag_set_error(interface_jtag_execute_queue());
870 }
871
872 int jtag_get_flush_queue_count(void)
873 {
874 return jtag_flush_queue_count;
875 }
876
877 int jtag_execute_queue(void)
878 {
879 jtag_execute_queue_noclear();
880 return jtag_error_clear();
881 }
882
883 static int jtag_reset_callback(enum jtag_event event, void *priv)
884 {
885 jtag_tap_t *tap = priv;
886
887 LOG_DEBUG("-");
888
889 if (event == JTAG_TRST_ASSERTED)
890 {
891 buf_set_ones(tap->cur_instr, tap->ir_length);
892 tap->bypass = 1;
893 }
894
895 return ERROR_OK;
896 }
897
898 void jtag_sleep(u32 us)
899 {
900 alive_sleep(us/1000);
901 }
902
903 /// maximum number of JTAG devices expected in the chain
904 #define JTAG_MAX_CHAIN_SIZE 20
905
906 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
907 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
908 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
909
910 static int jtag_examine_chain_execute(u8 *idcode_buffer, unsigned num_idcode)
911 {
912 scan_field_t field = {
913 .tap = NULL,
914 .num_bits = num_idcode * 32,
915 .out_value = idcode_buffer,
916 .in_value = idcode_buffer,
917 };
918
919 // initialize to the end of chain ID value
920 for (unsigned i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
921 buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
922
923 jtag_add_plain_dr_scan(1, &field, TAP_RESET);
924 return jtag_execute_queue();
925 }
926
927 static bool jtag_examine_chain_check(u8 *idcodes, unsigned count)
928 {
929 u8 zero_check = 0x0;
930 u8 one_check = 0xff;
931
932 for (unsigned i = 0; i < count * 4; i++)
933 {
934 zero_check |= idcodes[i];
935 one_check &= idcodes[i];
936 }
937
938 /* if there wasn't a single non-zero bit or if all bits were one,
939 * the scan is not valid */
940 if (zero_check == 0x00 || one_check == 0xff)
941 {
942 LOG_ERROR("JTAG communication failure: check connection, "
943 "JTAG interface, 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, u32 idcode)
951 {
952 log_printf_lf(level, __FILE__, __LINE__, __FUNCTION__,
953 "JTAG tap: %s %16.16s: 0x%08x "
954 "(mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
955 name, msg, idcode,
956 EXTRACT_MFG(idcode), EXTRACT_PART(idcode), EXTRACT_VER(idcode) );
957 }
958
959 static bool jtag_idcode_is_final(u32 idcode)
960 {
961 return idcode == 0x000000FF || idcode == 0xFFFFFFFF;
962 }
963
964 /**
965 * This helper checks that remaining bits in the examined chain data are
966 * all as expected, but a single JTAG device requires only 64 bits to be
967 * read back correctly. This can help identify and diagnose problems
968 * with the JTAG chain earlier, gives more helpful/explicit error messages.
969 */
970 static void jtag_examine_chain_end(u8 *idcodes, unsigned count, unsigned max)
971 {
972 bool triggered = false;
973 for ( ; count < max - 31; count += 32)
974 {
975 u32 idcode = buf_get_u32(idcodes, count, 32);
976 // do not trigger the warning if the data looks good
977 if (!triggered && jtag_idcode_is_final(idcode))
978 continue;
979 LOG_WARNING("Unexpected idcode after end of chain: %d 0x%08x",
980 count, idcode);
981 triggered = true;
982 }
983 }
984
985 static bool jtag_examine_chain_match_tap(const struct jtag_tap_s *tap)
986 {
987 if (0 == tap->expected_ids_cnt)
988 {
989 /// @todo Enable LOG_INFO to ask for reports about unknown TAP IDs.
990 #if 0
991 LOG_INFO("Uknown JTAG TAP ID: 0x%08x", tap->idcode)
992 LOG_INFO("Please report the chip name and reported ID code to the openocd project");
993 #endif
994 return true;
995 }
996
997 /* Loop over the expected identification codes and test for a match */
998 u8 ii;
999 for (ii = 0; ii < tap->expected_ids_cnt; ii++)
1000 {
1001 if (tap->idcode == tap->expected_ids[ii])
1002 break;
1003 }
1004
1005 /* If none of the expected ids matched, log an error */
1006 if (ii != tap->expected_ids_cnt)
1007 {
1008 LOG_INFO("JTAG Tap/device matched");
1009 return true;
1010 }
1011 jtag_examine_chain_display(LOG_LVL_ERROR, "got",
1012 tap->dotted_name, tap->idcode);
1013 for (ii = 0; ii < tap->expected_ids_cnt; ii++)
1014 {
1015 char msg[32];
1016 snprintf(msg, sizeof(msg), "expected %hhu of %hhu",
1017 ii + 1, tap->expected_ids_cnt);
1018 jtag_examine_chain_display(LOG_LVL_ERROR, msg,
1019 tap->dotted_name, tap->expected_ids[ii]);
1020 }
1021 return false;
1022 }
1023
1024 /* Try to examine chain layout according to IEEE 1149.1 §12
1025 */
1026 static int jtag_examine_chain(void)
1027 {
1028 u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1029 unsigned device_count = 0;
1030
1031 jtag_examine_chain_execute(idcode_buffer, JTAG_MAX_CHAIN_SIZE);
1032
1033 if (!jtag_examine_chain_check(idcode_buffer, JTAG_MAX_CHAIN_SIZE))
1034 return ERROR_JTAG_INIT_FAILED;
1035
1036 /* point at the 1st tap */
1037 jtag_tap_t *tap = jtag_tap_next_enabled(NULL);
1038 if (tap == NULL)
1039 {
1040 LOG_ERROR("JTAG: No taps enabled?");
1041 return ERROR_JTAG_INIT_FAILED;
1042 }
1043
1044 for (unsigned bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
1045 {
1046 u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1047 if ((idcode & 1) == 0)
1048 {
1049 /* LSB must not be 0, this indicates a device in bypass */
1050 LOG_WARNING("Tap/Device does not have IDCODE");
1051 idcode = 0;
1052
1053 bit_count += 1;
1054 }
1055 else
1056 {
1057 /*
1058 * End of chain (invalid manufacturer ID) some devices, such
1059 * as AVR will output all 1's instead of TDI input value at
1060 * end of chain.
1061 */
1062 if (jtag_idcode_is_final(idcode))
1063 {
1064 jtag_examine_chain_end(idcode_buffer,
1065 bit_count + 32, JTAG_MAX_CHAIN_SIZE * 32);
1066 break;
1067 }
1068
1069 jtag_examine_chain_display(LOG_LVL_INFO, "tap/device found",
1070 tap ? tap->dotted_name : "(not-named)",
1071 idcode);
1072
1073 bit_count += 32;
1074 }
1075 device_count++;
1076 if (!tap)
1077 continue;
1078
1079 tap->idcode = idcode;
1080
1081 // ensure the TAP ID does matches what was expected
1082 if (!jtag_examine_chain_match_tap(tap))
1083 return ERROR_JTAG_INIT_FAILED;
1084
1085 tap = jtag_tap_next_enabled(tap);
1086 }
1087
1088 /* see if number of discovered devices matches configuration */
1089 if (device_count != jtag_tap_count_enabled())
1090 {
1091 LOG_ERROR("number of discovered devices in JTAG chain (%i) "
1092 "does not match (enabled) configuration (%i), total taps: %d",
1093 device_count, jtag_tap_count_enabled(), jtag_tap_count());
1094 LOG_ERROR("check the config file and ensure proper JTAG communication"
1095 " (connections, speed, ...)");
1096 return ERROR_JTAG_INIT_FAILED;
1097 }
1098
1099 return ERROR_OK;
1100 }
1101
1102 static int jtag_validate_chain(void)
1103 {
1104 jtag_tap_t *tap;
1105 int total_ir_length = 0;
1106 u8 *ir_test = NULL;
1107 scan_field_t field;
1108 int chain_pos = 0;
1109
1110 tap = NULL;
1111 total_ir_length = 0;
1112 for(;;){
1113 tap = jtag_tap_next_enabled(tap);
1114 if( tap == NULL ){
1115 break;
1116 }
1117 total_ir_length += tap->ir_length;
1118 }
1119
1120 total_ir_length += 2;
1121 ir_test = malloc(CEIL(total_ir_length, 8));
1122 buf_set_ones(ir_test, total_ir_length);
1123
1124 field.tap = NULL;
1125 field.num_bits = total_ir_length;
1126 field.out_value = ir_test;
1127 field.in_value = ir_test;
1128
1129
1130 jtag_add_plain_ir_scan(1, &field, TAP_RESET);
1131 jtag_execute_queue();
1132
1133 tap = NULL;
1134 chain_pos = 0;
1135 int val;
1136 for(;;){
1137 tap = jtag_tap_next_enabled(tap);
1138 if( tap == NULL ){
1139 break;
1140 }
1141
1142 val = buf_get_u32(ir_test, chain_pos, 2);
1143 if (val != 0x1)
1144 {
1145 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1146 LOG_ERROR("Could not validate JTAG scan chain, IR mismatch, scan returned 0x%s. tap=%s pos=%d expected 0x1 got %0x", cbuf, jtag_tap_name(tap), chain_pos, val);
1147 free(cbuf);
1148 free(ir_test);
1149 return ERROR_JTAG_INIT_FAILED;
1150 }
1151 chain_pos += tap->ir_length;
1152 }
1153
1154 val = buf_get_u32(ir_test, chain_pos, 2);
1155 if (val != 0x3)
1156 {
1157 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1158 LOG_ERROR("Could not validate end of JTAG scan chain, IR mismatch, scan returned 0x%s. pos=%d expected 0x3 got %0x", cbuf, chain_pos, val);
1159 free(cbuf);
1160 free(ir_test);
1161 return ERROR_JTAG_INIT_FAILED;
1162 }
1163
1164 free(ir_test);
1165
1166 return ERROR_OK;
1167 }
1168
1169 enum jtag_tap_cfg_param {
1170 JCFG_EVENT
1171 };
1172
1173 static Jim_Nvp nvp_config_opts[] = {
1174 { .name = "-event", .value = JCFG_EVENT },
1175
1176 { .name = NULL, .value = -1 }
1177 };
1178
1179 static int jtag_tap_configure_cmd( Jim_GetOptInfo *goi, jtag_tap_t * tap)
1180 {
1181 Jim_Nvp *n;
1182 Jim_Obj *o;
1183 int e;
1184
1185 /* parse config or cget options */
1186 while (goi->argc > 0) {
1187 Jim_SetEmptyResult (goi->interp);
1188
1189 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
1190 if (e != JIM_OK) {
1191 Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
1192 return e;
1193 }
1194
1195 switch (n->value) {
1196 case JCFG_EVENT:
1197 if (goi->argc == 0) {
1198 Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ..." );
1199 return JIM_ERR;
1200 }
1201
1202 e = Jim_GetOpt_Nvp( goi, nvp_jtag_tap_event, &n );
1203 if (e != JIM_OK) {
1204 Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
1205 return e;
1206 }
1207
1208 if (goi->isconfigure) {
1209 if (goi->argc != 1) {
1210 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
1211 return JIM_ERR;
1212 }
1213 } else {
1214 if (goi->argc != 0) {
1215 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
1216 return JIM_ERR;
1217 }
1218 }
1219
1220 {
1221 jtag_tap_event_action_t *jteap;
1222
1223 jteap = tap->event_action;
1224 /* replace existing? */
1225 while (jteap) {
1226 if (jteap->event == (enum jtag_tap_event)n->value) {
1227 break;
1228 }
1229 jteap = jteap->next;
1230 }
1231
1232 if (goi->isconfigure) {
1233 if (jteap == NULL) {
1234 /* create new */
1235 jteap = calloc(1, sizeof (*jteap));
1236 }
1237 jteap->event = n->value;
1238 Jim_GetOpt_Obj( goi, &o);
1239 if (jteap->body) {
1240 Jim_DecrRefCount(interp, jteap->body);
1241 }
1242 jteap->body = Jim_DuplicateObj(goi->interp, o);
1243 Jim_IncrRefCount(jteap->body);
1244
1245 /* add to head of event list */
1246 jteap->next = tap->event_action;
1247 tap->event_action = jteap;
1248 Jim_SetEmptyResult(goi->interp);
1249 } else {
1250 /* get */
1251 if (jteap == NULL) {
1252 Jim_SetEmptyResult(goi->interp);
1253 } else {
1254 Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, jteap->body));
1255 }
1256 }
1257 }
1258 /* loop for more */
1259 break;
1260 }
1261 } /* while (goi->argc) */
1262
1263 return JIM_OK;
1264 }
1265
1266
1267 static void jtag_tap_init(jtag_tap_t *tap)
1268 {
1269 assert(0 != tap->ir_length);
1270
1271 tap->expected = malloc(tap->ir_length);
1272 tap->expected_mask = malloc(tap->ir_length);
1273 tap->cur_instr = malloc(tap->ir_length);
1274
1275 buf_set_u32(tap->expected, 0, tap->ir_length, tap->ir_capture_value);
1276 buf_set_u32(tap->expected_mask, 0, tap->ir_length, tap->ir_capture_mask);
1277 buf_set_ones(tap->cur_instr, tap->ir_length);
1278
1279 // place TAP in bypass mode
1280 tap->bypass = 1;
1281 // register the reset callback for the TAP
1282 jtag_register_event_callback(&jtag_reset_callback, tap);
1283
1284 LOG_DEBUG("Created Tap: %s @ abs position %d, "
1285 "irlen %d, capture: 0x%x mask: 0x%x", tap->dotted_name,
1286 tap->abs_chain_position, tap->ir_length,
1287 tap->ir_capture_value, tap->ir_capture_mask);
1288 jtag_tap_add(tap);
1289 }
1290
1291 static void jtag_tap_free(jtag_tap_t *tap)
1292 {
1293 /// @todo is anything missing? no memory leaks please
1294 free((void *)tap->expected_ids);
1295 free((void *)tap->chip);
1296 free((void *)tap->tapname);
1297 free((void *)tap->dotted_name);
1298 free(tap);
1299 }
1300
1301 static int jim_newtap_cmd( Jim_GetOptInfo *goi )
1302 {
1303 jtag_tap_t *pTap;
1304 jim_wide w;
1305 int x;
1306 int e;
1307 int reqbits;
1308 Jim_Nvp *n;
1309 char *cp;
1310 const Jim_Nvp opts[] = {
1311 #define NTAP_OPT_IRLEN 0
1312 { .name = "-irlen" , .value = NTAP_OPT_IRLEN },
1313 #define NTAP_OPT_IRMASK 1
1314 { .name = "-irmask" , .value = NTAP_OPT_IRMASK },
1315 #define NTAP_OPT_IRCAPTURE 2
1316 { .name = "-ircapture" , .value = NTAP_OPT_IRCAPTURE },
1317 #define NTAP_OPT_ENABLED 3
1318 { .name = "-enable" , .value = NTAP_OPT_ENABLED },
1319 #define NTAP_OPT_DISABLED 4
1320 { .name = "-disable" , .value = NTAP_OPT_DISABLED },
1321 #define NTAP_OPT_EXPECTED_ID 5
1322 { .name = "-expected-id" , .value = NTAP_OPT_EXPECTED_ID },
1323 { .name = NULL , .value = -1 },
1324 };
1325
1326 pTap = malloc( sizeof(jtag_tap_t) );
1327 memset( pTap, 0, sizeof(*pTap) );
1328 if( !pTap ){
1329 Jim_SetResult_sprintf( goi->interp, "no memory");
1330 return JIM_ERR;
1331 }
1332 /*
1333 * we expect CHIP + TAP + OPTIONS
1334 * */
1335 if( goi->argc < 3 ){
1336 Jim_SetResult_sprintf(goi->interp, "Missing CHIP TAP OPTIONS ....");
1337 return JIM_ERR;
1338 }
1339 Jim_GetOpt_String( goi, &cp, NULL );
1340 pTap->chip = strdup(cp);
1341
1342 Jim_GetOpt_String( goi, &cp, NULL );
1343 pTap->tapname = strdup(cp);
1344
1345 /* name + dot + name + null */
1346 x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
1347 cp = malloc( x );
1348 sprintf( cp, "%s.%s", pTap->chip, pTap->tapname );
1349 pTap->dotted_name = cp;
1350
1351 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
1352 pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
1353
1354 /* default is enabled */
1355 pTap->enabled = 1;
1356
1357 /* deal with options */
1358 #define NTREQ_IRLEN 1
1359 #define NTREQ_IRCAPTURE 2
1360 #define NTREQ_IRMASK 4
1361
1362 /* clear them as we find them */
1363 reqbits = (NTREQ_IRLEN | NTREQ_IRCAPTURE | NTREQ_IRMASK);
1364
1365 while( goi->argc ){
1366 e = Jim_GetOpt_Nvp( goi, opts, &n );
1367 if( e != JIM_OK ){
1368 Jim_GetOpt_NvpUnknown( goi, opts, 0 );
1369 return e;
1370 }
1371 LOG_DEBUG("Processing option: %s", n->name );
1372 switch( n->value ){
1373 case NTAP_OPT_ENABLED:
1374 pTap->enabled = 1;
1375 break;
1376 case NTAP_OPT_DISABLED:
1377 pTap->enabled = 0;
1378 break;
1379 case NTAP_OPT_EXPECTED_ID:
1380 {
1381 u32 *new_expected_ids;
1382
1383 e = Jim_GetOpt_Wide( goi, &w );
1384 if( e != JIM_OK) {
1385 Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
1386 return e;
1387 }
1388
1389 new_expected_ids = malloc(sizeof(u32) * (pTap->expected_ids_cnt + 1));
1390 if (new_expected_ids == NULL) {
1391 Jim_SetResult_sprintf( goi->interp, "no memory");
1392 return JIM_ERR;
1393 }
1394
1395 memcpy(new_expected_ids, pTap->expected_ids, sizeof(u32) * pTap->expected_ids_cnt);
1396
1397 new_expected_ids[pTap->expected_ids_cnt] = w;
1398
1399 free(pTap->expected_ids);
1400 pTap->expected_ids = new_expected_ids;
1401 pTap->expected_ids_cnt++;
1402 break;
1403 }
1404 case NTAP_OPT_IRLEN:
1405 case NTAP_OPT_IRMASK:
1406 case NTAP_OPT_IRCAPTURE:
1407 e = Jim_GetOpt_Wide( goi, &w );
1408 if( e != JIM_OK ){
1409 Jim_SetResult_sprintf( goi->interp, "option: %s bad parameter", n->name );
1410 return e;
1411 }
1412 if( (w < 0) || (w > 0xffff) ){
1413 /* wacky value */
1414 Jim_SetResult_sprintf( goi->interp, "option: %s - wacky value: %d (0x%x)",
1415 n->name, (int)(w), (int)(w));
1416 return JIM_ERR;
1417 }
1418 switch(n->value){
1419 case NTAP_OPT_IRLEN:
1420 pTap->ir_length = w;
1421 reqbits &= (~(NTREQ_IRLEN));
1422 break;
1423 case NTAP_OPT_IRMASK:
1424 pTap->ir_capture_mask = w;
1425 reqbits &= (~(NTREQ_IRMASK));
1426 break;
1427 case NTAP_OPT_IRCAPTURE:
1428 pTap->ir_capture_value = w;
1429 reqbits &= (~(NTREQ_IRCAPTURE));
1430 break;
1431 }
1432 } /* switch(n->value) */
1433 } /* while( goi->argc ) */
1434
1435 /* Did all the required option bits get cleared? */
1436 if (0 == reqbits)
1437 {
1438 jtag_tap_init(pTap);
1439 return ERROR_OK;
1440 }
1441
1442 Jim_SetResult_sprintf(goi->interp,
1443 "newtap: %s missing required parameters",
1444 pTap->dotted_name);
1445 jtag_tap_free(pTap);
1446 return JIM_ERR;
1447 }
1448
1449 static int jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
1450 {
1451 Jim_GetOptInfo goi;
1452 int e;
1453 Jim_Nvp *n;
1454 Jim_Obj *o;
1455 struct command_context_s *context;
1456
1457 enum {
1458 JTAG_CMD_INTERFACE,
1459 JTAG_CMD_INIT_RESET,
1460 JTAG_CMD_NEWTAP,
1461 JTAG_CMD_TAPENABLE,
1462 JTAG_CMD_TAPDISABLE,
1463 JTAG_CMD_TAPISENABLED,
1464 JTAG_CMD_CONFIGURE,
1465 JTAG_CMD_CGET
1466 };
1467
1468 const Jim_Nvp jtag_cmds[] = {
1469 { .name = "interface" , .value = JTAG_CMD_INTERFACE },
1470 { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET },
1471 { .name = "newtap" , .value = JTAG_CMD_NEWTAP },
1472 { .name = "tapisenabled" , .value = JTAG_CMD_TAPISENABLED },
1473 { .name = "tapenable" , .value = JTAG_CMD_TAPENABLE },
1474 { .name = "tapdisable" , .value = JTAG_CMD_TAPDISABLE },
1475 { .name = "configure" , .value = JTAG_CMD_CONFIGURE },
1476 { .name = "cget" , .value = JTAG_CMD_CGET },
1477
1478 { .name = NULL, .value = -1 },
1479 };
1480
1481 context = Jim_GetAssocData(interp, "context");
1482 /* go past the command */
1483 Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
1484
1485 e = Jim_GetOpt_Nvp( &goi, jtag_cmds, &n );
1486 if( e != JIM_OK ){
1487 Jim_GetOpt_NvpUnknown( &goi, jtag_cmds, 0 );
1488 return e;
1489 }
1490 Jim_SetEmptyResult( goi.interp );
1491 switch( n->value ){
1492 case JTAG_CMD_INTERFACE:
1493 /* return the name of the interface */
1494 /* TCL code might need to know the exact type... */
1495 /* FUTURE: we allow this as a means to "set" the interface. */
1496 if( goi.argc != 0 ){
1497 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
1498 return JIM_ERR;
1499 }
1500 Jim_SetResultString( goi.interp, jtag_interface->name, -1 );
1501 return JIM_OK;
1502 case JTAG_CMD_INIT_RESET:
1503 if( goi.argc != 0 ){
1504 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
1505 return JIM_ERR;
1506 }
1507 e = jtag_init_reset(context);
1508 if( e != ERROR_OK ){
1509 Jim_SetResult_sprintf( goi.interp, "error: %d", e);
1510 return JIM_ERR;
1511 }
1512 return JIM_OK;
1513 case JTAG_CMD_NEWTAP:
1514 return jim_newtap_cmd( &goi );
1515 break;
1516 case JTAG_CMD_TAPISENABLED:
1517 case JTAG_CMD_TAPENABLE:
1518 case JTAG_CMD_TAPDISABLE:
1519 if( goi.argc != 1 ){
1520 Jim_SetResultString( goi.interp, "Too many parameters",-1 );
1521 return JIM_ERR;
1522 }
1523
1524 {
1525 jtag_tap_t *t;
1526 t = jtag_tap_by_jim_obj( goi.interp, goi.argv[0] );
1527 if( t == NULL ){
1528 return JIM_ERR;
1529 }
1530 switch( n->value ){
1531 case JTAG_CMD_TAPISENABLED:
1532 e = t->enabled;
1533 break;
1534 case JTAG_CMD_TAPENABLE:
1535 jtag_tap_handle_event( t, JTAG_TAP_EVENT_ENABLE);
1536 e = 1;
1537 t->enabled = e;
1538 break;
1539 case JTAG_CMD_TAPDISABLE:
1540 jtag_tap_handle_event( t, JTAG_TAP_EVENT_DISABLE);
1541 e = 0;
1542 t->enabled = e;
1543 break;
1544 }
1545 Jim_SetResult( goi.interp, Jim_NewIntObj( goi.interp, e ) );
1546 return JIM_OK;
1547 }
1548 break;
1549
1550 case JTAG_CMD_CGET:
1551 if( goi.argc < 2 ){
1552 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ...");
1553 return JIM_ERR;
1554 }
1555
1556 {
1557 jtag_tap_t *t;
1558
1559 Jim_GetOpt_Obj(&goi, &o);
1560 t = jtag_tap_by_jim_obj( goi.interp, o );
1561 if( t == NULL ){
1562 return JIM_ERR;
1563 }
1564
1565 goi.isconfigure = 0;
1566 return jtag_tap_configure_cmd( &goi, t);
1567 }
1568 break;
1569
1570 case JTAG_CMD_CONFIGURE:
1571 if( goi.argc < 3 ){
1572 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ?VALUE? ...");
1573 return JIM_ERR;
1574 }
1575
1576 {
1577 jtag_tap_t *t;
1578
1579 Jim_GetOpt_Obj(&goi, &o);
1580 t = jtag_tap_by_jim_obj( goi.interp, o );
1581 if( t == NULL ){
1582 return JIM_ERR;
1583 }
1584
1585 goi.isconfigure = 1;
1586 return jtag_tap_configure_cmd( &goi, t);
1587 }
1588 }
1589
1590 return JIM_ERR;
1591 }
1592
1593 int jtag_register_commands(struct command_context_s *cmd_ctx)
1594 {
1595 register_jim( cmd_ctx, "jtag", jim_jtag_command, "perform jtag tap actions");
1596
1597 register_command(cmd_ctx, NULL, "interface", handle_interface_command,
1598 COMMAND_CONFIG, "try to configure interface");
1599 register_command(cmd_ctx, NULL,
1600 "interface_list", &handle_interface_list_command,
1601 COMMAND_ANY, "list all built-in interfaces");
1602 register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
1603 COMMAND_ANY, "(DEPRECATED) set jtag speed (if supported)");
1604 register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
1605 COMMAND_ANY, "set maximum jtag speed (if supported); "
1606 "parameter is maximum khz, or 0 for adaptive clocking (RTCK).");
1607 register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
1608 COMMAND_CONFIG, "(DEPRECATED) jtag_device <ir_length> <ir_expected> <ir_mask>");
1609 register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
1610 COMMAND_ANY,
1611 "[none/trst_only/srst_only/trst_and_srst] [srst_pulls_trst/trst_pulls_srst] [combined/separate] [trst_push_pull/trst_open_drain] [srst_push_pull/srst_open_drain]");
1612 register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
1613 COMMAND_ANY, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
1614 register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
1615 COMMAND_ANY, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
1616
1617 register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
1618 COMMAND_EXEC, "print current scan chain configuration");
1619
1620 register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
1621 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
1622 register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
1623 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
1624 register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
1625 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1626 register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
1627 register_jim(cmd_ctx, "flush_count", Jim_Command_flush_count, "returns number of times the JTAG queue has been flushed");
1628
1629 register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
1630 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
1631 register_command(cmd_ctx, NULL, "verify_jtag", handle_verify_jtag_command,
1632 COMMAND_ANY, "verify value capture <enable|disable>");
1633 register_command(cmd_ctx, NULL, "tms_sequence", handle_tms_sequence_command,
1634 COMMAND_ANY, "choose short(default) or long tms_sequence <short|long>");
1635 return ERROR_OK;
1636 }
1637
1638 int jtag_interface_init(struct command_context_s *cmd_ctx)
1639 {
1640 if (jtag)
1641 return ERROR_OK;
1642
1643 if (!jtag_interface)
1644 {
1645 /* nothing was previously specified by "interface" command */
1646 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1647 return ERROR_JTAG_INVALID_INTERFACE;
1648 }
1649 if(hasKHz)
1650 {
1651 jtag_interface->khz(jtag_get_speed_khz(), &jtag_speed);
1652 hasKHz = false;
1653 }
1654
1655 if (jtag_interface->init() != ERROR_OK)
1656 return ERROR_JTAG_INIT_FAILED;
1657
1658 jtag = jtag_interface;
1659 return ERROR_OK;
1660 }
1661
1662 static int jtag_init_inner(struct command_context_s *cmd_ctx)
1663 {
1664 jtag_tap_t *tap;
1665 int retval;
1666
1667 LOG_DEBUG("Init JTAG chain");
1668
1669 tap = jtag_tap_next_enabled(NULL);
1670 if( tap == NULL ){
1671 LOG_ERROR("There are no enabled taps?");
1672 return ERROR_JTAG_INIT_FAILED;
1673 }
1674
1675 jtag_add_tlr();
1676 if ((retval=jtag_execute_queue())!=ERROR_OK)
1677 return retval;
1678
1679 /* examine chain first, as this could discover the real chain layout */
1680 if (jtag_examine_chain() != ERROR_OK)
1681 {
1682 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1683 }
1684
1685 if (jtag_validate_chain() != ERROR_OK)
1686 {
1687 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
1688 }
1689
1690 return ERROR_OK;
1691 }
1692
1693 int jtag_interface_quit(void)
1694 {
1695 if (!jtag || !jtag->quit)
1696 return ERROR_OK;
1697
1698 // close the JTAG interface
1699 int result = jtag->quit();
1700 if (ERROR_OK != result)
1701 LOG_ERROR("failed: %d", result);
1702
1703 return ERROR_OK;
1704 }
1705
1706
1707 int jtag_init_reset(struct command_context_s *cmd_ctx)
1708 {
1709 int retval;
1710
1711 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
1712 return retval;
1713
1714 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
1715
1716 /* Reset can happen after a power cycle.
1717 *
1718 * Ideally we would only assert TRST or run RESET before the target reset.
1719 *
1720 * However w/srst_pulls_trst, trst is asserted together with the target
1721 * reset whether we want it or not.
1722 *
1723 * NB! Some targets have JTAG circuitry disabled until a
1724 * trst & srst has been asserted.
1725 *
1726 * NB! here we assume nsrst/ntrst delay are sufficient!
1727 *
1728 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1729 *
1730 */
1731 jtag_add_reset(1, 0); /* RESET or TRST */
1732 if (jtag_reset_config & RESET_HAS_SRST)
1733 {
1734 jtag_add_reset(1, 1);
1735 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
1736 jtag_add_reset(0, 1);
1737 }
1738 jtag_add_reset(0, 0);
1739 if ((retval = jtag_execute_queue()) != ERROR_OK)
1740 return retval;
1741
1742 /* Check that we can communication on the JTAG chain + eventually we want to
1743 * be able to perform enumeration only after OpenOCD has started
1744 * telnet and GDB server
1745 *
1746 * That would allow users to more easily perform any magic they need to before
1747 * reset happens.
1748 */
1749 return jtag_init_inner(cmd_ctx);
1750 }
1751
1752 int jtag_init(struct command_context_s *cmd_ctx)
1753 {
1754 int retval;
1755 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
1756 return retval;
1757 if (jtag_init_inner(cmd_ctx)==ERROR_OK)
1758 {
1759 return ERROR_OK;
1760 }
1761 return jtag_init_reset(cmd_ctx);
1762 }
1763
1764 void jtag_set_speed_khz(unsigned khz)
1765 {
1766 speed_khz = khz;
1767 }
1768 unsigned jtag_get_speed_khz(void)
1769 {
1770 return speed_khz;
1771 }
1772
1773 static int default_khz(int khz, int *jtag_speed)
1774 {
1775 LOG_ERROR("Translation from khz to jtag_speed not implemented");
1776 return ERROR_FAIL;
1777 }
1778
1779 static int default_speed_div(int speed, int *khz)
1780 {
1781 LOG_ERROR("Translation from jtag_speed to khz not implemented");
1782 return ERROR_FAIL;
1783 }
1784
1785 static int default_power_dropout(int *dropout)
1786 {
1787 *dropout=0; /* by default we can't detect power dropout */
1788 return ERROR_OK;
1789 }
1790
1791 static int default_srst_asserted(int *srst_asserted)
1792 {
1793 *srst_asserted=0; /* by default we can't detect srst asserted */
1794 return ERROR_OK;
1795 }
1796
1797 static int handle_interface_command(struct command_context_s *cmd_ctx,
1798 char *cmd, char **args, int argc)
1799 {
1800 /* check whether the interface is already configured */
1801 if (jtag_interface)
1802 {
1803 LOG_WARNING("Interface already configured, ignoring");
1804 return ERROR_OK;
1805 }
1806
1807 /* interface name is a mandatory argument */
1808 if (argc != 1 || args[0][0] == '\0')
1809 return ERROR_COMMAND_SYNTAX_ERROR;
1810
1811 for (unsigned i = 0; NULL != jtag_interfaces[i]; i++)
1812 {
1813 if (strcmp(args[0], jtag_interfaces[i]->name) != 0)
1814 continue;
1815
1816 int retval = jtag_interfaces[i]->register_commands(cmd_ctx);
1817 if (ERROR_OK != retval)
1818 return retval;
1819
1820 jtag_interface = jtag_interfaces[i];
1821
1822 if (jtag_interface->khz == NULL)
1823 jtag_interface->khz = default_khz;
1824 if (jtag_interface->speed_div == NULL)
1825 jtag_interface->speed_div = default_speed_div;
1826 if (jtag_interface->power_dropout == NULL)
1827 jtag_interface->power_dropout = default_power_dropout;
1828 if (jtag_interface->srst_asserted == NULL)
1829 jtag_interface->srst_asserted = default_srst_asserted;
1830
1831 return ERROR_OK;
1832 }
1833
1834 /* no valid interface was found (i.e. the configuration option,
1835 * didn't match one of the compiled-in interfaces
1836 */
1837 LOG_ERROR("The specified JTAG interface was not found (%s)", args[0]);
1838 handle_interface_list_command(cmd_ctx, cmd, args, argc);
1839 return ERROR_JTAG_INVALID_INTERFACE;
1840 }
1841
1842 static int handle_interface_list_command(struct command_context_s *cmd_ctx,
1843 char *cmd, char **args, int argc)
1844 {
1845 if (strcmp(cmd, "interface_list") == 0 && argc > 0)
1846 return ERROR_COMMAND_SYNTAX_ERROR;
1847
1848 command_print(cmd_ctx, "The following JTAG interfaces are available:");
1849 for (unsigned i = 0; NULL != jtag_interfaces[i]; i++)
1850 {
1851 const char *name = jtag_interfaces[i]->name;
1852 command_print(cmd_ctx, "%u: %s", i + 1, name);
1853 }
1854
1855 return ERROR_OK;
1856 }
1857
1858 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1859 {
1860 int e;
1861 char buf[1024];
1862 Jim_Obj *newargs[ 10 ];
1863 /*
1864 * CONVERT SYNTAX
1865 * argv[-1] = command
1866 * argv[ 0] = ir length
1867 * argv[ 1] = ir capture
1868 * argv[ 2] = ir mask
1869 * argv[ 3] = not actually used by anything but in the docs
1870 */
1871
1872 if( argc < 4 ){
1873 command_print( cmd_ctx, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
1874 return ERROR_OK;
1875 }
1876 command_print( cmd_ctx, "OLD SYNTAX: DEPRECATED - translating to new syntax");
1877 command_print( cmd_ctx, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
1878 args[0],
1879 args[1],
1880 args[2] );
1881 command_print( cmd_ctx, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
1882 command_print( cmd_ctx, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
1883 command_print( cmd_ctx, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
1884 command_print( cmd_ctx, "And then refer to the taps by the dotted name.");
1885
1886 newargs[0] = Jim_NewStringObj( interp, "jtag", -1 );
1887 newargs[1] = Jim_NewStringObj( interp, "newtap", -1 );
1888 sprintf( buf, "chip%d", jtag_tap_count() );
1889 newargs[2] = Jim_NewStringObj( interp, buf, -1 );
1890 sprintf( buf, "tap%d", jtag_tap_count() );
1891 newargs[3] = Jim_NewStringObj( interp, buf, -1 );
1892 newargs[4] = Jim_NewStringObj( interp, "-irlen", -1 );
1893 newargs[5] = Jim_NewStringObj( interp, args[0], -1 );
1894 newargs[6] = Jim_NewStringObj( interp, "-ircapture", -1 );
1895 newargs[7] = Jim_NewStringObj( interp, args[1], -1 );
1896 newargs[8] = Jim_NewStringObj( interp, "-irmask", -1 );
1897 newargs[9] = Jim_NewStringObj( interp, args[2], -1 );
1898
1899 command_print( cmd_ctx, "NEW COMMAND:");
1900 sprintf( buf, "%s %s %s %s %s %s %s %s %s %s",
1901 Jim_GetString( newargs[0], NULL ),
1902 Jim_GetString( newargs[1], NULL ),
1903 Jim_GetString( newargs[2], NULL ),
1904 Jim_GetString( newargs[3], NULL ),
1905 Jim_GetString( newargs[4], NULL ),
1906 Jim_GetString( newargs[5], NULL ),
1907 Jim_GetString( newargs[6], NULL ),
1908 Jim_GetString( newargs[7], NULL ),
1909 Jim_GetString( newargs[8], NULL ),
1910 Jim_GetString( newargs[9], NULL ) );
1911
1912 e = jim_jtag_command( interp, 10, newargs );
1913 if( e != JIM_OK ){
1914 command_print( cmd_ctx, "%s", Jim_GetString( Jim_GetResult(interp), NULL ) );
1915 }
1916 return e;
1917 }
1918
1919 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1920 {
1921 jtag_tap_t *tap;
1922
1923 tap = jtag_all_taps();
1924 command_print(cmd_ctx, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
1925 command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------");
1926
1927 while( tap ){
1928 u32 expected, expected_mask, cur_instr, ii;
1929 expected = buf_get_u32(tap->expected, 0, tap->ir_length);
1930 expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
1931 cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
1932
1933 command_print(cmd_ctx,
1934 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
1935 tap->abs_chain_position,
1936 tap->dotted_name,
1937 tap->enabled ? 'Y' : 'n',
1938 tap->idcode,
1939 (tap->expected_ids_cnt > 0 ? tap->expected_ids[0] : 0),
1940 tap->ir_length,
1941 expected,
1942 expected_mask,
1943 cur_instr);
1944
1945 for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
1946 command_print(cmd_ctx, " | | | | 0x%08x | | | | ",
1947 tap->expected_ids[ii]);
1948 }
1949
1950 tap = tap->next_tap;
1951 }
1952
1953 return ERROR_OK;
1954 }
1955
1956 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1957 {
1958 int new_cfg = 0;
1959 int mask = 0;
1960
1961 if (argc < 1)
1962 return ERROR_COMMAND_SYNTAX_ERROR;
1963
1964 /* Original versions cared about the order of these tokens:
1965 * reset_config signals [combination [trst_type [srst_type]]]
1966 * They also clobbered the previous configuration even on error.
1967 *
1968 * Here we don't care about the order, and only change values
1969 * which have been explicitly specified.
1970 */
1971 for (; argc; argc--, args++) {
1972 int tmp = 0;
1973 int m;
1974
1975 /* signals */
1976 m = RESET_HAS_TRST | RESET_HAS_SRST;
1977 if (strcmp(*args, "none") == 0)
1978 tmp = RESET_NONE;
1979 else if (strcmp(*args, "trst_only") == 0)
1980 tmp = RESET_HAS_TRST;
1981 else if (strcmp(*args, "srst_only") == 0)
1982 tmp = RESET_HAS_SRST;
1983 else if (strcmp(*args, "trst_and_srst") == 0)
1984 tmp = RESET_HAS_TRST | RESET_HAS_SRST;
1985 else
1986 m = 0;
1987 if (mask & m) {
1988 LOG_ERROR("extra reset_config %s spec (%s)",
1989 "signal", *args);
1990 return ERROR_INVALID_ARGUMENTS;
1991 }
1992 if (m)
1993 goto next;
1994
1995 /* combination (options for broken wiring) */
1996 m = RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
1997 if (strcmp(*args, "separate") == 0)
1998 /* separate reset lines - default */;
1999 else if (strcmp(*args, "srst_pulls_trst") == 0)
2000 tmp |= RESET_SRST_PULLS_TRST;
2001 else if (strcmp(*args, "trst_pulls_srst") == 0)
2002 tmp |= RESET_TRST_PULLS_SRST;
2003 else if (strcmp(*args, "combined") == 0)
2004 tmp |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
2005 else
2006 m = 0;
2007 if (mask & m) {
2008 LOG_ERROR("extra reset_config %s spec (%s)",
2009 "combination", *args);
2010 return ERROR_INVALID_ARGUMENTS;
2011 }
2012 if (m)
2013 goto next;
2014
2015 /* trst_type (NOP without HAS_TRST) */
2016 m = RESET_TRST_OPEN_DRAIN;
2017 if (strcmp(*args, "trst_open_drain") == 0)
2018 tmp |= RESET_TRST_OPEN_DRAIN;
2019 else if (strcmp(*args, "trst_push_pull") == 0)
2020 /* push/pull from adapter - default */;
2021 else
2022 m = 0;
2023 if (mask & m) {
2024 LOG_ERROR("extra reset_config %s spec (%s)",
2025 "trst_type", *args);
2026 return ERROR_INVALID_ARGUMENTS;
2027 }
2028 if (m)
2029 goto next;
2030
2031 /* srst_type (NOP without HAS_SRST) */
2032 m |= RESET_SRST_PUSH_PULL;
2033 if (strcmp(*args, "srst_push_pull") == 0)
2034 tmp |= RESET_SRST_PUSH_PULL;
2035 else if (strcmp(*args, "srst_open_drain") == 0)
2036 /* open drain from adapter - default */;
2037 else
2038 m = 0;
2039 if (mask & m) {
2040 LOG_ERROR("extra reset_config %s spec (%s)",
2041 "srst_type", *args);
2042 return ERROR_INVALID_ARGUMENTS;
2043 }
2044 if (m)
2045 goto next;
2046
2047 /* caller provided nonsense; fail */
2048 LOG_ERROR("unknown reset_config flag (%s)", *args);
2049 return ERROR_INVALID_ARGUMENTS;
2050
2051 next:
2052 /* Remember the bits which were specified (mask)
2053 * and their new values (new_cfg).
2054 */
2055 mask |= m;
2056 new_cfg |= tmp;
2057 }
2058
2059 /* clear previous values of those bits, save new values */
2060 jtag_reset_config &= ~mask;
2061 jtag_reset_config |= new_cfg;
2062
2063 return ERROR_OK;
2064 }
2065
2066 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx,
2067 char *cmd, char **args, int argc)
2068 {
2069 if (argc > 1)
2070 return ERROR_COMMAND_SYNTAX_ERROR;
2071 if (argc == 1)
2072 jtag_set_nsrst_delay(strtoul(args[0], NULL, 0));
2073 command_print(cmd_ctx, "jtag_nsrst_delay: %u", jtag_get_nsrst_delay());
2074 return ERROR_OK;
2075 }
2076
2077 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx,
2078 char *cmd, char **args, int argc)
2079 {
2080 if (argc > 1)
2081 return ERROR_COMMAND_SYNTAX_ERROR;
2082 if (argc == 1)
2083 jtag_set_ntrst_delay(strtoul(args[0], NULL, 0));
2084 command_print(cmd_ctx, "jtag_ntrst_delay: %u", jtag_get_ntrst_delay());
2085 return ERROR_OK;
2086 }
2087
2088 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2089 {
2090 int retval = ERROR_OK;
2091
2092 if (argc > 1)
2093 return ERROR_COMMAND_SYNTAX_ERROR;
2094 if (argc == 1)
2095 {
2096 LOG_DEBUG("handle jtag speed");
2097
2098 int cur_speed = 0;
2099 cur_speed = jtag_speed = strtoul(args[0], NULL, 0);
2100
2101 /* this command can be called during CONFIG,
2102 * in which case jtag isn't initialized */
2103 if (jtag)
2104 retval = jtag->speed(cur_speed);
2105 }
2106 command_print(cmd_ctx, "jtag_speed: %d", jtag_speed);
2107
2108 return retval;
2109 }
2110
2111 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2112 {
2113 if (argc > 1)
2114 return ERROR_COMMAND_SYNTAX_ERROR;
2115
2116 int retval = ERROR_OK;
2117 int cur_speed = 0;
2118 if (argc == 1)
2119 {
2120 LOG_DEBUG("handle jtag khz");
2121
2122 jtag_set_speed_khz(strtoul(args[0], NULL, 0));
2123 if (jtag != NULL)
2124 {
2125 LOG_DEBUG("have interface set up");
2126 int speed_div1;
2127 retval = jtag->khz(jtag_get_speed_khz(), &speed_div1);
2128 if (ERROR_OK != retval)
2129 {
2130 jtag_set_speed_khz(0);
2131 return retval;
2132 }
2133 cur_speed = jtag_speed = speed_div1;
2134
2135 retval = jtag->speed(cur_speed);
2136 }
2137 else
2138 hasKHz = true;
2139 }
2140
2141 cur_speed = jtag_get_speed_khz();
2142 if (jtag != NULL)
2143 {
2144 retval = jtag->speed_div(jtag_speed, &cur_speed);
2145 if (ERROR_OK != retval)
2146 return retval;
2147 }
2148
2149 if (cur_speed)
2150 command_print(cmd_ctx, "%d kHz", cur_speed);
2151 else
2152 command_print(cmd_ctx, "RCLK - adaptive");
2153 return retval;
2154
2155 }
2156
2157 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx,
2158 char *cmd, char **args, int argc)
2159 {
2160 if (argc != 2)
2161 return ERROR_COMMAND_SYNTAX_ERROR;
2162
2163 int trst = -1;
2164 if (args[0][0] == '1')
2165 trst = 1;
2166 else if (args[0][0] == '0')
2167 trst = 0;
2168 else
2169 return ERROR_COMMAND_SYNTAX_ERROR;
2170
2171 int srst = -1;
2172 if (args[1][0] == '1')
2173 srst = 1;
2174 else if (args[1][0] == '0')
2175 srst = 0;
2176 else
2177 return ERROR_COMMAND_SYNTAX_ERROR;
2178
2179 if (jtag_interface_init(cmd_ctx) != ERROR_OK)
2180 return ERROR_JTAG_INIT_FAILED;
2181
2182 jtag_add_reset(trst, srst);
2183 jtag_execute_queue();
2184
2185 return ERROR_OK;
2186 }
2187
2188 static int handle_runtest_command(struct command_context_s *cmd_ctx,
2189 char *cmd, char **args, int argc)
2190 {
2191 if (argc != 1)
2192 return ERROR_COMMAND_SYNTAX_ERROR;
2193
2194 jtag_add_runtest(strtol(args[0], NULL, 0), jtag_get_end_state());
2195 jtag_execute_queue();
2196
2197 return ERROR_OK;
2198 }
2199
2200 /*
2201 * For "irscan" or "drscan" commands, the "end" (really, "next") state
2202 * should be stable ... and *NOT* a shift state, otherwise free-running
2203 * jtag clocks could change the values latched by the update state.
2204 */
2205 static bool scan_is_safe(tap_state_t state)
2206 {
2207 switch (state)
2208 {
2209 case TAP_RESET:
2210 case TAP_IDLE:
2211 case TAP_DRPAUSE:
2212 case TAP_IRPAUSE:
2213 return true;
2214 default:
2215 return false;
2216 }
2217 }
2218
2219
2220 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2221 {
2222 int i;
2223 scan_field_t *fields;
2224 jtag_tap_t *tap;
2225 tap_state_t endstate;
2226
2227 if ((argc < 2) || (argc % 2))
2228 {
2229 return ERROR_COMMAND_SYNTAX_ERROR;
2230 }
2231
2232 /* optional "-endstate" "statename" at the end of the arguments,
2233 * so that e.g. IRPAUSE can let us load the data register before
2234 * entering RUN/IDLE to execute the instruction we load here.
2235 */
2236 endstate = TAP_IDLE;
2237
2238 if( argc >= 4 ){
2239 /* have at least one pair of numbers. */
2240 /* is last pair the magic text? */
2241 if( 0 == strcmp( "-endstate", args[ argc - 2 ] ) ){
2242 const char *cpA;
2243 const char *cpS;
2244 cpA = args[ argc-1 ];
2245 for( endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++ ){
2246 cpS = tap_state_name( endstate );
2247 if( 0 == strcmp( cpA, cpS ) ){
2248 break;
2249 }
2250 }
2251 if( endstate >= TAP_NUM_STATES ){
2252 return ERROR_COMMAND_SYNTAX_ERROR;
2253 } else {
2254 if (!scan_is_safe(endstate))
2255 LOG_WARNING("irscan with unsafe "
2256 "endstate \"%s\"", cpA);
2257 /* found - remove the last 2 args */
2258 argc -= 2;
2259 }
2260 }
2261 }
2262
2263 int num_fields = argc / 2;
2264
2265 fields = malloc(sizeof(scan_field_t) * num_fields);
2266
2267 for (i = 0; i < num_fields; i++)
2268 {
2269 tap = jtag_tap_by_string( args[i*2] );
2270 if (tap==NULL)
2271 {
2272 command_print( cmd_ctx, "Tap: %s unknown", args[i*2] );
2273 return ERROR_FAIL;
2274 }
2275 int field_size = tap->ir_length;
2276 fields[i].tap = tap;
2277 fields[i].num_bits = field_size;
2278 fields[i].out_value = malloc(CEIL(field_size, 8));
2279 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
2280 fields[i].in_value = NULL;
2281 }
2282
2283 /* did we have an endstate? */
2284 jtag_add_ir_scan(num_fields, fields, endstate);
2285
2286 int retval=jtag_execute_queue();
2287
2288 for (i = 0; i < num_fields; i++)
2289 free(fields[i].out_value);
2290
2291 free (fields);
2292
2293 return retval;
2294 }
2295
2296 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2297 {
2298 int retval;
2299 scan_field_t *fields;
2300 int num_fields;
2301 int field_count = 0;
2302 int i, e;
2303 jtag_tap_t *tap;
2304 tap_state_t endstate;
2305
2306 /* args[1] = device
2307 * args[2] = num_bits
2308 * args[3] = hex string
2309 * ... repeat num bits and hex string ...
2310 *
2311 * .. optionally:
2312 * args[N-2] = "-endstate"
2313 * args[N-1] = statename
2314 */
2315 if ((argc < 4) || ((argc % 2)!=0))
2316 {
2317 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
2318 return JIM_ERR;
2319 }
2320
2321 endstate = TAP_IDLE;
2322
2323 /* validate arguments as numbers */
2324 e = JIM_OK;
2325 for (i = 2; i < argc; i+=2)
2326 {
2327 long bits;
2328 const char *cp;
2329
2330 e = Jim_GetLong(interp, args[i], &bits);
2331 /* If valid - try next arg */
2332 if( e == JIM_OK ){
2333 continue;
2334 }
2335
2336 /* Not valid.. are we at the end? */
2337 if ( ((i+2) != argc) ){
2338 /* nope, then error */
2339 return e;
2340 }
2341
2342 /* it could be: "-endstate FOO"
2343 * e.g. DRPAUSE so we can issue more instructions
2344 * before entering RUN/IDLE and executing them.
2345 */
2346
2347 /* get arg as a string. */
2348 cp = Jim_GetString( args[i], NULL );
2349 /* is it the magic? */
2350 if( 0 == strcmp( "-endstate", cp ) ){
2351 /* is the statename valid? */
2352 cp = Jim_GetString( args[i+1], NULL );
2353
2354 /* see if it is a valid state name */
2355 endstate = tap_state_by_name(cp);
2356 if( endstate < 0 ){
2357 /* update the error message */
2358 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp );
2359 } else {
2360 if (!scan_is_safe(endstate))
2361 LOG_WARNING("drscan with unsafe "
2362 "endstate \"%s\"", cp);
2363
2364 /* valid - so clear the error */
2365 e = JIM_OK;
2366 /* and remove the last 2 args */
2367 argc -= 2;
2368 }
2369 }
2370
2371 /* Still an error? */
2372 if( e != JIM_OK ){
2373 return e; /* too bad */
2374 }
2375 } /* validate args */
2376
2377 tap = jtag_tap_by_jim_obj( interp, args[1] );
2378 if( tap == NULL ){
2379 return JIM_ERR;
2380 }
2381
2382 num_fields=(argc-2)/2;
2383 fields = malloc(sizeof(scan_field_t) * num_fields);
2384 for (i = 2; i < argc; i+=2)
2385 {
2386 long bits;
2387 int len;
2388 const char *str;
2389
2390 Jim_GetLong(interp, args[i], &bits);
2391 str = Jim_GetString(args[i+1], &len);
2392
2393 fields[field_count].tap = tap;
2394 fields[field_count].num_bits = bits;
2395 fields[field_count].out_value = malloc(CEIL(bits, 8));
2396 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
2397 fields[field_count].in_value = fields[field_count].out_value;
2398 field_count++;
2399 }
2400
2401 jtag_add_dr_scan(num_fields, fields, endstate);
2402
2403 retval = jtag_execute_queue();
2404 if (retval != ERROR_OK)
2405 {
2406 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
2407 return JIM_ERR;
2408 }
2409
2410 field_count=0;
2411 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
2412 for (i = 2; i < argc; i+=2)
2413 {
2414 long bits;
2415 char *str;
2416
2417 Jim_GetLong(interp, args[i], &bits);
2418 str = buf_to_str(fields[field_count].in_value, bits, 16);
2419 free(fields[field_count].out_value);
2420
2421 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
2422 free(str);
2423 field_count++;
2424 }
2425
2426 Jim_SetResult(interp, list);
2427
2428 free(fields);
2429
2430 return JIM_OK;
2431 }
2432
2433
2434 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2435 {
2436 Jim_SetResult(interp, Jim_NewIntObj(interp, jtag_get_flush_queue_count()));
2437
2438 return JIM_OK;
2439 }
2440
2441
2442 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2443 {
2444 if (argc == 1)
2445 {
2446 if (strcmp(args[0], "enable") == 0)
2447 {
2448 jtag_verify_capture_ir = 1;
2449 }
2450 else if (strcmp(args[0], "disable") == 0)
2451 {
2452 jtag_verify_capture_ir = 0;
2453 } else
2454 {
2455 return ERROR_COMMAND_SYNTAX_ERROR;
2456 }
2457 } else if (argc != 0)
2458 {
2459 return ERROR_COMMAND_SYNTAX_ERROR;
2460 }
2461
2462 command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
2463
2464 return ERROR_OK;
2465 }
2466
2467 void jtag_set_verify(bool enable)
2468 {
2469 jtag_verify = enable;
2470 }
2471
2472 bool jtag_will_verify()
2473 {
2474 return jtag_verify;
2475 }
2476
2477 static int handle_verify_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2478 {
2479 if (argc > 1)
2480 return ERROR_COMMAND_SYNTAX_ERROR;
2481
2482 if (argc == 1)
2483 {
2484 if (strcmp(args[0], "enable") == 0)
2485 jtag_set_verify(true);
2486 else if (strcmp(args[0], "disable") == 0)
2487 jtag_set_verify(false);
2488 else
2489 return ERROR_COMMAND_SYNTAX_ERROR;
2490 }
2491
2492 const char *status = jtag_will_verify() ? "enabled": "disabled";
2493 command_print(cmd_ctx, "verify jtag capture is %s", status);
2494
2495 return ERROR_OK;
2496 }
2497
2498
2499 int jtag_power_dropout(int *dropout)
2500 {
2501 return jtag->power_dropout(dropout);
2502 }
2503
2504 int jtag_srst_asserted(int *srst_asserted)
2505 {
2506 return jtag->srst_asserted(srst_asserted);
2507 }
2508
2509 void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e)
2510 {
2511 jtag_tap_event_action_t * jteap;
2512 int done;
2513
2514 jteap = tap->event_action;
2515
2516 done = 0;
2517 while (jteap) {
2518 if (jteap->event == e) {
2519 done = 1;
2520 LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
2521 tap->dotted_name,
2522 e,
2523 Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e)->name,
2524 Jim_GetString(jteap->body, NULL) );
2525 if (Jim_EvalObj(interp, jteap->body) != JIM_OK) {
2526 Jim_PrintErrorMessage(interp);
2527 }
2528 }
2529
2530 jteap = jteap->next;
2531 }
2532
2533 if (!done) {
2534 LOG_DEBUG( "event %d %s - no action",
2535 e,
2536 Jim_Nvp_value2name_simple( nvp_jtag_tap_event, e)->name);
2537 }
2538 }
2539
2540 static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2541 {
2542 if (argc > 1)
2543 return ERROR_COMMAND_SYNTAX_ERROR;
2544
2545 if (argc == 1)
2546 {
2547 bool use_new_table;
2548 if (strcmp(args[0], "short") == 0)
2549 use_new_table = true;
2550 else if (strcmp(args[0], "long") == 0)
2551 use_new_table = false;
2552 else
2553 return ERROR_COMMAND_SYNTAX_ERROR;
2554
2555 tap_use_new_tms_table(use_new_table);
2556 }
2557
2558 command_print(cmd_ctx, "tms sequence is %s",
2559 tap_uses_new_tms_table() ? "short": "long");
2560
2561 return ERROR_OK;
2562 }
2563
2564 /**
2565 * Moves from the current state to the goal \a state. This needs
2566 * to be handled according to the xsvf spec, see the XSTATE command
2567 * description.
2568 *
2569 * From the XSVF spec, pertaining to XSTATE:
2570 *
2571 * For special states known as stable states (Test-Logic-Reset,
2572 * Run-Test/Idle, Pause-DR, Pause- IR), an XSVF interpreter follows
2573 * predefined TAP state paths when the starting state is a stable state
2574 * and when the XSTATE specifies a new stable state. See the STATE
2575 * command in the [Ref 5] for the TAP state paths between stable
2576 * states.
2577 *
2578 * For non-stable states, XSTATE should specify a state that is only one
2579 * TAP state transition distance from the current TAP state to avoid
2580 * undefined TAP state paths. A sequence of multiple XSTATE commands can
2581 * be issued to transition the TAP through a specific state path.
2582 *
2583 * @note Unless @a tms_bits holds a path that agrees with [Ref 5] in *
2584 * above spec, then this code is not fully conformant to the xsvf spec.
2585 * This puts a burden on tap_get_tms_path() function from the xsvf spec.
2586 * If in doubt, you should confirm that that burden is being met.
2587 *
2588 * Otherwise, state must be immediately reachable in one clock cycle,
2589 * and does not need to be a stable state.
2590 */
2591 int jtag_add_statemove(tap_state_t goal_state)
2592 {
2593 tap_state_t cur_state = cmd_queue_cur_state;
2594
2595 LOG_DEBUG( "cur_state=%s goal_state=%s",
2596 tap_state_name(cur_state),
2597 tap_state_name(goal_state) );
2598
2599
2600 if (goal_state==cur_state )
2601 ; /* nothing to do */
2602 else if( goal_state==TAP_RESET )
2603 {
2604 jtag_add_tlr();
2605 }
2606 else if( tap_is_state_stable(cur_state) && tap_is_state_stable(goal_state) )
2607 {
2608 unsigned tms_bits = tap_get_tms_path(cur_state, goal_state);
2609 unsigned tms_count = tap_get_tms_path_len(cur_state, goal_state);
2610 tap_state_t moves[8];
2611 assert(tms_count < DIM(moves));
2612
2613 for (unsigned i = 0; i < tms_count; i++, tms_bits >>= 1)
2614 {
2615 bool bit = tms_bits & 1;
2616
2617 cur_state = tap_state_transition(cur_state, bit);
2618 moves[i] = cur_state;
2619 }
2620
2621 jtag_add_pathmove(tms_count, moves);
2622 }
2623 else if( tap_state_transition(cur_state, true) == goal_state
2624 || tap_state_transition(cur_state, false) == goal_state )
2625 {
2626 jtag_add_pathmove(1, &goal_state);
2627 }
2628
2629 else
2630 return ERROR_FAIL;
2631
2632 return ERROR_OK;
2633 }
2634
2635 void jtag_set_nsrst_delay(unsigned delay)
2636 {
2637 jtag_nsrst_delay = delay;
2638 }
2639 unsigned jtag_get_nsrst_delay(void)
2640 {
2641 return jtag_nsrst_delay;
2642 }
2643 void jtag_set_ntrst_delay(unsigned delay)
2644 {
2645 jtag_ntrst_delay = delay;
2646 }
2647 unsigned jtag_get_ntrst_delay(void)
2648 {
2649 return jtag_ntrst_delay;
2650 }
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)