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