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