Code Review / openocd.git / blob
? search:


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