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