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