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