Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
fix (old?) bug in jtag_add_ir_scan()
[openocd.git] / src / jtag / jtag.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2009 SoftPLC Corporation *
9 * http://softplc.com *
10 * dick@softplc.com *
11 * *
12 * This program is free software; you can redistribute it and/or modify *
13 * it under the terms of the GNU General Public License as published by *
14 * the Free Software Foundation; either version 2 of the License, or *
15 * (at your option) any later version. *
16 * *
17 * This program is distributed in the hope that it will be useful, *
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
20 * GNU General Public License for more details. *
21 * *
22 * You should have received a copy of the GNU General Public License *
23 * along with this program; if not, write to the *
24 * Free Software Foundation, Inc., *
25 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
26 ***************************************************************************/
27 #ifdef HAVE_CONFIG_H
28 #include "config.h"
29 #endif
30
31 #include "replacements.h"
32
33 #include "jtag.h"
34
35 #include "command.h"
36 #include "log.h"
37
38 #include <stdlib.h>
39 #include <string.h>
40 #include <unistd.h>
41 #ifdef HAVE_STRINGS_H
42 #include <strings.h>
43 #endif
44 #include <assert.h>
45
46
47
48 /* note that this is not marked as static as it must be available from outside jtag.c for those
49 that implement the jtag_xxx() minidriver layer
50 */
51 int jtag_error=ERROR_OK;
52
53 typedef struct cmd_queue_page_s
54 {
55 void *address;
56 size_t used;
57 struct cmd_queue_page_s *next;
58 } cmd_queue_page_t;
59
60 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
61 static cmd_queue_page_t *cmd_queue_pages = NULL;
62
63 char* jtag_event_strings[] =
64 {
65 "JTAG controller reset (RESET or TRST)"
66 };
67
68 const Jim_Nvp nvp_jtag_tap_event[] = {
69 { .value = JTAG_TAP_EVENT_ENABLE, .name = "tap-enable" },
70 { .value = JTAG_TAP_EVENT_DISABLE, .name = "tap-disable" },
71
72 { .name = NULL, .value = -1 }
73 };
74
75 int jtag_trst = 0;
76 int jtag_srst = 0;
77
78 jtag_command_t *jtag_command_queue = NULL;
79 jtag_command_t **last_comand_pointer = &jtag_command_queue;
80 static jtag_tap_t *jtag_all_taps = NULL;
81
82 enum reset_types jtag_reset_config = RESET_NONE;
83 tap_state_t cmd_queue_end_state = TAP_RESET;
84 tap_state_t cmd_queue_cur_state = TAP_RESET;
85
86 int jtag_verify_capture_ir = 1;
87
88 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
89 static int jtag_nsrst_delay = 0; /* default to no nSRST delay */
90 static int jtag_ntrst_delay = 0; /* default to no nTRST delay */
91
92 /* maximum number of JTAG devices expected in the chain
93 */
94 #define JTAG_MAX_CHAIN_SIZE 20
95
96 /* callbacks to inform high-level handlers about JTAG state changes */
97 jtag_event_callback_t *jtag_event_callbacks;
98
99 /* speed in kHz*/
100 static int speed_khz = 0;
101 /* flag if the kHz speed was defined */
102 static int hasKHz = 0;
103
104 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
105 */
106
107 #if BUILD_ECOSBOARD == 1
108 extern jtag_interface_t zy1000_interface;
109 #endif
110
111 #if BUILD_PARPORT == 1
112 extern jtag_interface_t parport_interface;
113 #endif
114
115 #if BUILD_DUMMY == 1
116 extern jtag_interface_t dummy_interface;
117 #endif
118
119 #if BUILD_FT2232_FTD2XX == 1
120 extern jtag_interface_t ft2232_interface;
121 #endif
122
123 #if BUILD_FT2232_LIBFTDI == 1
124 extern jtag_interface_t ft2232_interface;
125 #endif
126
127 #if BUILD_AMTJTAGACCEL == 1
128 extern jtag_interface_t amt_jtagaccel_interface;
129 #endif
130
131 #if BUILD_EP93XX == 1
132 extern jtag_interface_t ep93xx_interface;
133 #endif
134
135 #if BUILD_AT91RM9200 == 1
136 extern jtag_interface_t at91rm9200_interface;
137 #endif
138
139 #if BUILD_GW16012 == 1
140 extern jtag_interface_t gw16012_interface;
141 #endif
142
143 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
144 extern jtag_interface_t presto_interface;
145 #endif
146
147 #if BUILD_USBPROG == 1
148 extern jtag_interface_t usbprog_interface;
149 #endif
150
151 #if BUILD_JLINK == 1
152 extern jtag_interface_t jlink_interface;
153 #endif
154
155 #if BUILD_VSLLINK == 1
156 extern jtag_interface_t vsllink_interface;
157 #endif
158
159 #if BUILD_RLINK == 1
160 extern jtag_interface_t rlink_interface;
161 #endif
162
163 #if BUILD_ARMJTAGEW == 1
164 extern jtag_interface_t armjtagew_interface;
165 #endif
166
167 jtag_interface_t *jtag_interfaces[] = {
168 #if BUILD_ECOSBOARD == 1
169 &zy1000_interface,
170 #endif
171 #if BUILD_PARPORT == 1
172 &parport_interface,
173 #endif
174 #if BUILD_DUMMY == 1
175 &dummy_interface,
176 #endif
177 #if BUILD_FT2232_FTD2XX == 1
178 &ft2232_interface,
179 #endif
180 #if BUILD_FT2232_LIBFTDI == 1
181 &ft2232_interface,
182 #endif
183 #if BUILD_AMTJTAGACCEL == 1
184 &amt_jtagaccel_interface,
185 #endif
186 #if BUILD_EP93XX == 1
187 &ep93xx_interface,
188 #endif
189 #if BUILD_AT91RM9200 == 1
190 &at91rm9200_interface,
191 #endif
192 #if BUILD_GW16012 == 1
193 &gw16012_interface,
194 #endif
195 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
196 &presto_interface,
197 #endif
198 #if BUILD_USBPROG == 1
199 &usbprog_interface,
200 #endif
201 #if BUILD_JLINK == 1
202 &jlink_interface,
203 #endif
204 #if BUILD_VSLLINK == 1
205 &vsllink_interface,
206 #endif
207 #if BUILD_RLINK == 1
208 &rlink_interface,
209 #endif
210 #if BUILD_ARMJTAGEW == 1
211 &armjtagew_interface,
212 #endif
213 NULL,
214 };
215
216 jtag_interface_t *jtag = NULL;
217
218 /* configuration */
219 static jtag_interface_t *jtag_interface = NULL;
220 int jtag_speed = 0;
221
222 /* forward declarations */
223 //void jtag_add_pathmove(int num_states, tap_state_t *path);
224 //void jtag_add_runtest(int num_cycles, tap_state_t endstate);
225 //void jtag_add_end_state(tap_state_t endstate);
226 //void jtag_add_sleep(u32 us);
227 //int jtag_execute_queue(void);
228 static tap_state_t tap_state_by_name(const char *name);
229
230 /* jtag commands */
231 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
232 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
233 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
234 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
235 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
236 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
237 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
238
239 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
240
241 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
242 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
243 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
244 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
245 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
246
247 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
248
249 jtag_tap_t *jtag_AllTaps(void)
250 {
251 return jtag_all_taps;
252 };
253
254 int jtag_NumTotalTaps(void)
255 {
256 jtag_tap_t *t;
257 int n;
258
259 n = 0;
260 t = jtag_AllTaps();
261 while(t){
262 n++;
263 t = t->next_tap;
264 }
265 return n;
266 }
267
268 int jtag_NumEnabledTaps(void)
269 {
270 jtag_tap_t *t;
271 int n;
272
273 n = 0;
274 t = jtag_AllTaps();
275 while(t){
276 if( t->enabled ){
277 n++;
278 }
279 t = t->next_tap;
280 }
281 return n;
282 }
283
284 jtag_tap_t *jtag_TapByString( const char *s )
285 {
286 jtag_tap_t *t;
287 char *cp;
288
289 t = jtag_AllTaps();
290 /* try name first */
291 while(t){
292 if( 0 == strcmp( t->dotted_name, s ) ){
293 break;
294 } else {
295 t = t->next_tap;
296 }
297 }
298 /* backup plan is by number */
299 if( t == NULL ){
300 /* ok - is "s" a number? */
301 int n;
302 n = strtol( s, &cp, 0 );
303 if( (s != cp) && (*cp == 0) ){
304 /* Then it is... */
305 t = jtag_TapByAbsPosition(n);
306 }
307 }
308 return t;
309 }
310
311 jtag_tap_t * jtag_TapByJimObj( Jim_Interp *interp, Jim_Obj *o )
312 {
313 jtag_tap_t *t;
314 const char *cp;
315
316 cp = Jim_GetString( o, NULL );
317 if(cp == NULL){
318 cp = "(unknown)";
319 t = NULL;
320 } else {
321 t = jtag_TapByString( cp );
322 }
323 if( t == NULL ){
324 Jim_SetResult_sprintf(interp,"Tap: %s is unknown", cp );
325 }
326 return t;
327 }
328
329 /* returns a pointer to the n-th device in the scan chain */
330 jtag_tap_t * jtag_TapByAbsPosition( int n )
331 {
332 int orig_n;
333 jtag_tap_t *t;
334
335 orig_n = n;
336 t = jtag_AllTaps();
337
338 while( t && (n > 0)) {
339 n--;
340 t = t->next_tap;
341 }
342 return t;
343 }
344
345 int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
346 {
347 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
348
349 if (callback == NULL)
350 {
351 return ERROR_INVALID_ARGUMENTS;
352 }
353
354 if (*callbacks_p)
355 {
356 while ((*callbacks_p)->next)
357 callbacks_p = &((*callbacks_p)->next);
358 callbacks_p = &((*callbacks_p)->next);
359 }
360
361 (*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
362 (*callbacks_p)->callback = callback;
363 (*callbacks_p)->priv = priv;
364 (*callbacks_p)->next = NULL;
365
366 return ERROR_OK;
367 }
368
369 int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
370 {
371 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
372
373 if (callback == NULL)
374 {
375 return ERROR_INVALID_ARGUMENTS;
376 }
377
378 while (*callbacks_p)
379 {
380 jtag_event_callback_t **next = &((*callbacks_p)->next);
381 if ((*callbacks_p)->callback == callback)
382 {
383 free(*callbacks_p);
384 *callbacks_p = *next;
385 }
386 callbacks_p = next;
387 }
388
389 return ERROR_OK;
390 }
391
392 int jtag_call_event_callbacks(enum jtag_event event)
393 {
394 jtag_event_callback_t *callback = jtag_event_callbacks;
395
396 LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
397
398 while (callback)
399 {
400 callback->callback(event, callback->priv);
401 callback = callback->next;
402 }
403
404 return ERROR_OK;
405 }
406
407 /* returns a pointer to the pointer of the last command in queue
408 * this may be a pointer to the root pointer (jtag_command_queue)
409 * or to the next member of the last but one command
410 */
411 jtag_command_t** jtag_get_last_command_p(void)
412 {
413 /* jtag_command_t *cmd = jtag_command_queue;
414
415 if (cmd)
416 while (cmd->next)
417 cmd = cmd->next;
418 else
419 return &jtag_command_queue;
420
421 return &cmd->next;*/
422
423 return last_comand_pointer;
424 }
425
426 void* cmd_queue_alloc(size_t size)
427 {
428 cmd_queue_page_t **p_page = &cmd_queue_pages;
429 int offset;
430 u8 *t;
431
432 /*
433 * WARNING:
434 * We align/round the *SIZE* per below
435 * so that all pointers returned by
436 * this function are reasonably well
437 * aligned.
438 *
439 * If we did not, then an "odd-length" request would cause the
440 * *next* allocation to be at an *odd* address, and because
441 * this function has the same type of api as malloc() - we
442 * must also return pointers that have the same type of
443 * alignment.
444 *
445 * What I do not/have is a reasonable portable means
446 * to align by...
447 *
448 * The solution here, is based on these suggestions.
449 * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html
450 *
451 */
452 union worse_case_align {
453 int i;
454 long l;
455 float f;
456 void *v;
457 };
458 #define ALIGN_SIZE (sizeof(union worse_case_align))
459
460 /* The alignment process. */
461 size = (size + ALIGN_SIZE -1) & (~(ALIGN_SIZE-1));
462 /* Done... */
463
464 if (*p_page)
465 {
466 while ((*p_page)->next)
467 p_page = &((*p_page)->next);
468 if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size)
469 p_page = &((*p_page)->next);
470 }
471
472 if (!*p_page)
473 {
474 *p_page = malloc(sizeof(cmd_queue_page_t));
475 (*p_page)->used = 0;
476 (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE);
477 (*p_page)->next = NULL;
478 }
479
480 offset = (*p_page)->used;
481 (*p_page)->used += size;
482
483 t=(u8 *)((*p_page)->address);
484 return t + offset;
485 }
486
487 void cmd_queue_free(void)
488 {
489 cmd_queue_page_t *page = cmd_queue_pages;
490
491 while (page)
492 {
493 cmd_queue_page_t *last = page;
494 free(page->address);
495 page = page->next;
496 free(last);
497 }
498
499 cmd_queue_pages = NULL;
500 }
501
502 static void jtag_prelude1(void)
503 {
504 if (jtag_trst == 1)
505 {
506 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
507 jtag_error=ERROR_JTAG_TRST_ASSERTED;
508 return;
509 }
510
511 if (cmd_queue_end_state == TAP_RESET)
512 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
513 }
514
515 static void jtag_prelude(tap_state_t state)
516 {
517 jtag_prelude1();
518
519 if (state != TAP_INVALID)
520 jtag_add_end_state(state);
521
522 cmd_queue_cur_state = cmd_queue_end_state;
523 }
524
525 void jtag_add_ir_scan_noverify(int num_fields, scan_field_t *fields, tap_state_t state)
526 {
527 int retval;
528 jtag_prelude(state);
529
530 retval=interface_jtag_add_ir_scan(num_fields, fields, cmd_queue_end_state);
531 if (retval!=ERROR_OK)
532 jtag_error=retval;
533
534 }
535
536
537 void jtag_add_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state)
538 {
539 /* 8 x 32 bit id's is enough for all invoations */
540 u32 id[8];
541 int modified[8];
542
543
544 /* if we are to run a verification of the ir scan, we need to get the input back.
545 * We may have to allocate space if the caller didn't ask for the input back.
546 *
547 */
548 if (jtag_verify_capture_ir)
549 {
550 int j;
551 for (j = 0; j < num_fields; j++)
552 {
553 modified[j]=0;
554 if ((fields[j].in_value==NULL)&&(fields[j].num_bits<=32))
555 {
556 if (j<8)
557 {
558 modified[j]=1;
559 fields[j].in_value=(u8 *)(id+j);
560 } else
561 {
562 LOG_DEBUG("caller must provide in_value space for verify_capture_ir to work");
563 }
564 }
565 }
566 }
567
568 jtag_add_ir_scan_noverify(num_fields, fields, state);
569
570 if (jtag_verify_capture_ir)
571 {
572 int j;
573 for (j = 0; j < num_fields; j++)
574 {
575 jtag_tap_t *tap=fields[j].tap;
576 jtag_check_value_mask(fields+j, tap->expected, tap->expected_mask);
577
578 if (modified[j])
579 {
580 fields[j].in_value=NULL;
581 }
582 }
583 }
584
585 }
586
587 int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
588 {
589 jtag_command_t **last_cmd;
590 jtag_tap_t *tap;
591 int j;
592 int x;
593 int nth_tap;
594 int scan_size = 0;
595
596 last_cmd = jtag_get_last_command_p();
597
598 /* allocate memory for a new list member */
599 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
600 (*last_cmd)->next = NULL;
601 last_comand_pointer = &((*last_cmd)->next);
602 (*last_cmd)->type = JTAG_SCAN;
603
604 /* allocate memory for ir scan command */
605 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
606 (*last_cmd)->cmd.scan->ir_scan = 1;
607 x = jtag_NumEnabledTaps();
608 (*last_cmd)->cmd.scan->num_fields = x; /* one field per device */
609 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(x * sizeof(scan_field_t));
610 (*last_cmd)->cmd.scan->end_state = state;
611
612 nth_tap = -1;
613 tap = NULL;
614 for(;;){
615 int found = 0;
616
617 /* do this here so it is not forgotten */
618 tap = jtag_NextEnabledTap(tap);
619 if( tap == NULL ){
620 break;
621 }
622 nth_tap++;
623 scan_size = tap->ir_length;
624 (*last_cmd)->cmd.scan->fields[nth_tap].tap = tap;
625 (*last_cmd)->cmd.scan->fields[nth_tap].num_bits = scan_size;
626 (*last_cmd)->cmd.scan->fields[nth_tap].in_value = fields[nth_tap].in_value;
627
628 /* search the list */
629 for (j = 0; j < num_fields; j++)
630 {
631 if (tap == fields[j].tap)
632 {
633 found = 1;
634 (*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
635
636 tap->bypass = 0;
637 break;
638 }
639 }
640
641 if (!found)
642 {
643 /* if a tap isn't listed, set it to BYPASS */
644 (*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_set_ones(cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
645 tap->bypass = 1;
646 }
647
648 /* update device information */
649 buf_cpy((*last_cmd)->cmd.scan->fields[nth_tap].out_value, tap->cur_instr, scan_size);
650 }
651
652 return ERROR_OK;
653 }
654
655 void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state)
656 {
657 int retval;
658
659 jtag_prelude(state);
660
661 retval=interface_jtag_add_plain_ir_scan(num_fields, fields, cmd_queue_end_state);
662 if (retval!=ERROR_OK)
663 jtag_error=retval;
664 }
665
666 int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
667 {
668 int i;
669 jtag_command_t **last_cmd;
670
671 last_cmd = jtag_get_last_command_p();
672
673 /* allocate memory for a new list member */
674 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
675 (*last_cmd)->next = NULL;
676 last_comand_pointer = &((*last_cmd)->next);
677 (*last_cmd)->type = JTAG_SCAN;
678
679 /* allocate memory for ir scan command */
680 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
681 (*last_cmd)->cmd.scan->ir_scan = 1;
682 (*last_cmd)->cmd.scan->num_fields = num_fields;
683 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
684 (*last_cmd)->cmd.scan->end_state = state;
685
686 for( i = 0 ; i < num_fields ; i++ ){
687 int num_bits = fields[i].num_bits;
688 int num_bytes = CEIL(fields[i].num_bits, 8);
689 (*last_cmd)->cmd.scan->fields[i].tap = fields[i].tap;
690 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
691 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
692 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
693 }
694 return ERROR_OK;
695 }
696
697 void jtag_add_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state)
698 {
699 int retval;
700
701 jtag_prelude(state);
702
703 retval=interface_jtag_add_dr_scan(num_fields, fields, cmd_queue_end_state);
704 if (retval!=ERROR_OK)
705 jtag_error=retval;
706 }
707
708 void jtag_add_dr_scan_now(int num_fields, scan_field_t *fields, tap_state_t state)
709 {
710 jtag_add_dr_scan(num_fields, fields, state);
711 jtag_execute_queue_noclear();
712 }
713
714 int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
715 {
716 int j;
717 int nth_tap;
718 int bypass_devices = 0;
719 int field_count = 0;
720 int scan_size;
721
722 jtag_command_t **last_cmd = jtag_get_last_command_p();
723 jtag_tap_t *tap;
724
725 /* count devices in bypass */
726 tap = NULL;
727 bypass_devices = 0;
728 for(;;){
729 tap = jtag_NextEnabledTap(tap);
730 if( tap == NULL ){
731 break;
732 }
733 if( tap->bypass ){
734 bypass_devices++;
735 }
736 }
737
738 /* allocate memory for a new list member */
739 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
740 last_comand_pointer = &((*last_cmd)->next);
741 (*last_cmd)->next = NULL;
742 (*last_cmd)->type = JTAG_SCAN;
743
744 /* allocate memory for dr scan command */
745 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
746 (*last_cmd)->cmd.scan->ir_scan = 0;
747 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
748 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
749 (*last_cmd)->cmd.scan->end_state = state;
750
751 tap = NULL;
752 nth_tap = -1;
753 for(;;){
754 nth_tap++;
755 tap = jtag_NextEnabledTap(tap);
756 if( tap == NULL ){
757 break;
758 }
759 int found = 0;
760 (*last_cmd)->cmd.scan->fields[field_count].tap = tap;
761
762 for (j = 0; j < num_fields; j++)
763 {
764 if (tap == fields[j].tap)
765 {
766 found = 1;
767 scan_size = fields[j].num_bits;
768 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
769 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
770 (*last_cmd)->cmd.scan->fields[field_count].in_value = fields[j].in_value;
771 field_count++;
772 }
773 }
774 if (!found)
775 {
776 #ifdef _DEBUG_JTAG_IO_
777 /* if a device isn't listed, the BYPASS register should be selected */
778 if (! tap->bypass)
779 {
780 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
781 exit(-1);
782 }
783 #endif
784 /* program the scan field to 1 bit length, and ignore it's value */
785 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
786 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
787 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
788 field_count++;
789 }
790 else
791 {
792 #ifdef _DEBUG_JTAG_IO_
793 /* if a device is listed, the BYPASS register must not be selected */
794 if (tap->bypass)
795 {
796 LOG_ERROR("BUG: scan data for a device in BYPASS");
797 exit(-1);
798 }
799 #endif
800 }
801 }
802 return ERROR_OK;
803 }
804
805 void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap,
806 int num_fields,
807 const int *num_bits,
808 const u32 *value,
809 tap_state_t end_state)
810 {
811 int nth_tap;
812 int field_count = 0;
813 int scan_size;
814 int bypass_devices = 0;
815
816 jtag_command_t **last_cmd = jtag_get_last_command_p();
817 jtag_tap_t *tap;
818
819 /* count devices in bypass */
820 tap = NULL;
821 bypass_devices = 0;
822 for(;;){
823 tap = jtag_NextEnabledTap(tap);
824 if( tap == NULL ){
825 break;
826 }
827 if( tap->bypass ){
828 bypass_devices++;
829 }
830 }
831
832 /* allocate memory for a new list member */
833 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
834 last_comand_pointer = &((*last_cmd)->next);
835 (*last_cmd)->next = NULL;
836 (*last_cmd)->type = JTAG_SCAN;
837
838 /* allocate memory for dr scan command */
839 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
840 (*last_cmd)->cmd.scan->ir_scan = 0;
841 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
842 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
843 (*last_cmd)->cmd.scan->end_state = end_state;
844
845 tap = NULL;
846 nth_tap = -1;
847 for(;;){
848 tap = jtag_NextEnabledTap(tap);
849 if( tap == NULL ){
850 break;
851 }
852 nth_tap++;
853 (*last_cmd)->cmd.scan->fields[field_count].tap = tap;
854
855 if (tap == target_tap)
856 {
857 int j;
858 #ifdef _DEBUG_JTAG_IO_
859 /* if a device is listed, the BYPASS register must not be selected */
860 if (tap->bypass)
861 {
862 LOG_ERROR("BUG: scan data for a device in BYPASS");
863 exit(-1);
864 }
865 #endif
866 for (j = 0; j < num_fields; j++)
867 {
868 u8 out_value[4];
869 scan_size = num_bits[j];
870 buf_set_u32(out_value, 0, scan_size, value[j]);
871 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
872 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
873 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
874 field_count++;
875 }
876 } else
877 {
878 #ifdef _DEBUG_JTAG_IO_
879 /* if a device isn't listed, the BYPASS register should be selected */
880 if (! tap->bypass)
881 {
882 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
883 exit(-1);
884 }
885 #endif
886 /* program the scan field to 1 bit length, and ignore it's value */
887 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
888 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
889 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
890 field_count++;
891 }
892 }
893 }
894
895 void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state)
896 {
897 int retval;
898
899 jtag_prelude(state);
900
901 retval=interface_jtag_add_plain_dr_scan(num_fields, fields, cmd_queue_end_state);
902 if (retval!=ERROR_OK)
903 jtag_error=retval;
904 }
905
906 int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
907 {
908 int i;
909 jtag_command_t **last_cmd = jtag_get_last_command_p();
910
911 /* allocate memory for a new list member */
912 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
913 last_comand_pointer = &((*last_cmd)->next);
914 (*last_cmd)->next = NULL;
915 (*last_cmd)->type = JTAG_SCAN;
916
917 /* allocate memory for scan command */
918 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
919 (*last_cmd)->cmd.scan->ir_scan = 0;
920 (*last_cmd)->cmd.scan->num_fields = num_fields;
921 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
922 (*last_cmd)->cmd.scan->end_state = state;
923
924 for (i = 0; i < num_fields; i++)
925 {
926 int num_bits = fields[i].num_bits;
927 int num_bytes = CEIL(fields[i].num_bits, 8);
928 (*last_cmd)->cmd.scan->fields[i].tap = fields[i].tap;
929 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
930 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
931 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
932 }
933
934 return ERROR_OK;
935 }
936
937 void jtag_add_tlr(void)
938 {
939 jtag_prelude(TAP_RESET);
940
941 int retval;
942 retval=interface_jtag_add_tlr();
943 if (retval!=ERROR_OK)
944 jtag_error=retval;
945 }
946
947 int MINIDRIVER(interface_jtag_add_tlr)(void)
948 {
949 tap_state_t state = TAP_RESET;
950 jtag_command_t **last_cmd = jtag_get_last_command_p();
951
952 /* allocate memory for a new list member */
953 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
954 last_comand_pointer = &((*last_cmd)->next);
955 (*last_cmd)->next = NULL;
956 (*last_cmd)->type = JTAG_STATEMOVE;
957
958 (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t));
959 (*last_cmd)->cmd.statemove->end_state = state;
960
961 return ERROR_OK;
962 }
963
964 void jtag_add_pathmove(int num_states, tap_state_t *path)
965 {
966 tap_state_t cur_state = cmd_queue_cur_state;
967 int i;
968 int retval;
969
970 /* the last state has to be a stable state */
971 if (!tap_is_state_stable(path[num_states - 1]))
972 {
973 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
974 exit(-1);
975 }
976
977 for (i=0; i<num_states; i++)
978 {
979 if (path[i] == TAP_RESET)
980 {
981 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
982 exit(-1);
983 }
984
985 if ( tap_state_transition(cur_state, true) != path[i]
986 && tap_state_transition(cur_state, false) != path[i])
987 {
988 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[i]));
989 exit(-1);
990 }
991 cur_state = path[i];
992 }
993
994 jtag_prelude1();
995
996 retval = interface_jtag_add_pathmove(num_states, path);
997 cmd_queue_cur_state = path[num_states - 1];
998 if (retval!=ERROR_OK)
999 jtag_error=retval;
1000 }
1001
1002 int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, tap_state_t *path)
1003 {
1004 jtag_command_t **last_cmd = jtag_get_last_command_p();
1005 int i;
1006
1007 /* allocate memory for a new list member */
1008 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1009 last_comand_pointer = &((*last_cmd)->next);
1010 (*last_cmd)->next = NULL;
1011 (*last_cmd)->type = JTAG_PATHMOVE;
1012
1013 (*last_cmd)->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t));
1014 (*last_cmd)->cmd.pathmove->num_states = num_states;
1015 (*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(tap_state_t) * num_states);
1016
1017 for (i = 0; i < num_states; i++)
1018 (*last_cmd)->cmd.pathmove->path[i] = path[i];
1019
1020 return ERROR_OK;
1021 }
1022
1023 int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, tap_state_t state)
1024 {
1025 jtag_command_t **last_cmd = jtag_get_last_command_p();
1026
1027 /* allocate memory for a new list member */
1028 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1029 (*last_cmd)->next = NULL;
1030 last_comand_pointer = &((*last_cmd)->next);
1031 (*last_cmd)->type = JTAG_RUNTEST;
1032
1033 (*last_cmd)->cmd.runtest = cmd_queue_alloc(sizeof(runtest_command_t));
1034 (*last_cmd)->cmd.runtest->num_cycles = num_cycles;
1035 (*last_cmd)->cmd.runtest->end_state = state;
1036
1037 return ERROR_OK;
1038 }
1039
1040 void jtag_add_runtest(int num_cycles, tap_state_t state)
1041 {
1042 int retval;
1043
1044 jtag_prelude(state);
1045
1046 /* executed by sw or hw fifo */
1047 retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state);
1048 if (retval!=ERROR_OK)
1049 jtag_error=retval;
1050 }
1051
1052
1053 int MINIDRIVER(interface_jtag_add_clocks)( int num_cycles )
1054 {
1055 jtag_command_t **last_cmd = jtag_get_last_command_p();
1056
1057 /* allocate memory for a new list member */
1058 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1059 (*last_cmd)->next = NULL;
1060 last_comand_pointer = &((*last_cmd)->next);
1061 (*last_cmd)->type = JTAG_STABLECLOCKS;
1062
1063 (*last_cmd)->cmd.stableclocks = cmd_queue_alloc(sizeof(stableclocks_command_t));
1064 (*last_cmd)->cmd.stableclocks->num_cycles = num_cycles;
1065 return ERROR_OK;
1066 }
1067
1068 void jtag_add_clocks( int num_cycles )
1069 {
1070 int retval;
1071
1072 if( !tap_is_state_stable(cmd_queue_cur_state) )
1073 {
1074 LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
1075 tap_state_name(cmd_queue_cur_state) );
1076 jtag_error = ERROR_JTAG_NOT_STABLE_STATE;
1077 return;
1078 }
1079
1080 if( num_cycles > 0 )
1081 {
1082 jtag_prelude1();
1083
1084 retval = interface_jtag_add_clocks(num_cycles);
1085 if (retval != ERROR_OK)
1086 jtag_error=retval;
1087 }
1088 }
1089
1090 void jtag_add_reset(int req_tlr_or_trst, int req_srst)
1091 {
1092 int trst_with_tlr = 0;
1093 int retval;
1094
1095 /* FIX!!! there are *many* different cases here. A better
1096 * approach is needed for legal combinations of transitions...
1097 */
1098 if ((jtag_reset_config & RESET_HAS_SRST)&&
1099 (jtag_reset_config & RESET_HAS_TRST)&&
1100 ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0))
1101 {
1102 if (((req_tlr_or_trst&&!jtag_trst)||
1103 (!req_tlr_or_trst&&jtag_trst))&&
1104 ((req_srst&&!jtag_srst)||
1105 (!req_srst&&jtag_srst)))
1106 {
1107 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
1108 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
1109 }
1110 }
1111
1112 /* Make sure that jtag_reset_config allows the requested reset */
1113 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
1114 if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst))
1115 {
1116 LOG_ERROR("BUG: requested reset would assert trst");
1117 jtag_error=ERROR_FAIL;
1118 return;
1119 }
1120
1121 /* if TRST pulls SRST, we reset with TAP T-L-R */
1122 if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0))
1123 {
1124 trst_with_tlr = 1;
1125 }
1126
1127 if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
1128 {
1129 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
1130 jtag_error=ERROR_FAIL;
1131 return;
1132 }
1133
1134 if (req_tlr_or_trst)
1135 {
1136 if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST))
1137 {
1138 jtag_trst = 1;
1139 } else
1140 {
1141 trst_with_tlr = 1;
1142 }
1143 } else
1144 {
1145 jtag_trst = 0;
1146 }
1147
1148 jtag_srst = req_srst;
1149
1150 retval = interface_jtag_add_reset(jtag_trst, jtag_srst);
1151 if (retval!=ERROR_OK)
1152 {
1153 jtag_error=retval;
1154 return;
1155 }
1156
1157 if (jtag_srst)
1158 {
1159 LOG_DEBUG("SRST line asserted");
1160 }
1161 else
1162 {
1163 LOG_DEBUG("SRST line released");
1164 if (jtag_nsrst_delay)
1165 jtag_add_sleep(jtag_nsrst_delay * 1000);
1166 }
1167
1168 if (trst_with_tlr)
1169 {
1170 LOG_DEBUG("JTAG reset with RESET instead of TRST");
1171 jtag_add_end_state(TAP_RESET);
1172 jtag_add_tlr();
1173 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1174 return;
1175 }
1176
1177 if (jtag_trst)
1178 {
1179 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1180 * and inform possible listeners about this
1181 */
1182 LOG_DEBUG("TRST line asserted");
1183 cmd_queue_cur_state = TAP_RESET;
1184 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1185 }
1186 else
1187 {
1188 if (jtag_ntrst_delay)
1189 jtag_add_sleep(jtag_ntrst_delay * 1000);
1190 }
1191 }
1192
1193 int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst)
1194 {
1195 jtag_command_t **last_cmd = jtag_get_last_command_p();
1196
1197 /* allocate memory for a new list member */
1198 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1199 (*last_cmd)->next = NULL;
1200 last_comand_pointer = &((*last_cmd)->next);
1201 (*last_cmd)->type = JTAG_RESET;
1202
1203 (*last_cmd)->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t));
1204 (*last_cmd)->cmd.reset->trst = req_trst;
1205 (*last_cmd)->cmd.reset->srst = req_srst;
1206
1207 return ERROR_OK;
1208 }
1209
1210 void jtag_add_end_state(tap_state_t state)
1211 {
1212 cmd_queue_end_state = state;
1213 if ((cmd_queue_end_state == TAP_DRSHIFT)||(cmd_queue_end_state == TAP_IRSHIFT))
1214 {
1215 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
1216 }
1217 }
1218
1219 int MINIDRIVER(interface_jtag_add_sleep)(u32 us)
1220 {
1221 jtag_command_t **last_cmd = jtag_get_last_command_p();
1222
1223 /* allocate memory for a new list member */
1224 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1225 (*last_cmd)->next = NULL;
1226 last_comand_pointer = &((*last_cmd)->next);
1227 (*last_cmd)->type = JTAG_SLEEP;
1228
1229 (*last_cmd)->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t));
1230 (*last_cmd)->cmd.sleep->us = us;
1231
1232 return ERROR_OK;
1233 }
1234
1235 void jtag_add_sleep(u32 us)
1236 {
1237 keep_alive(); /* we might be running on a very slow JTAG clk */
1238 int retval=interface_jtag_add_sleep(us);
1239 if (retval!=ERROR_OK)
1240 jtag_error=retval;
1241 return;
1242 }
1243
1244 int jtag_scan_size(scan_command_t *cmd)
1245 {
1246 int bit_count = 0;
1247 int i;
1248
1249 /* count bits in scan command */
1250 for (i = 0; i < cmd->num_fields; i++)
1251 {
1252 bit_count += cmd->fields[i].num_bits;
1253 }
1254
1255 return bit_count;
1256 }
1257
1258 int jtag_build_buffer(scan_command_t *cmd, u8 **buffer)
1259 {
1260 int bit_count = 0;
1261 int i;
1262
1263 bit_count = jtag_scan_size(cmd);
1264 *buffer = malloc(CEIL(bit_count, 8));
1265
1266 bit_count = 0;
1267
1268 #ifdef _DEBUG_JTAG_IO_
1269 LOG_DEBUG("%s num_fields: %i", cmd->ir_scan ? "IRSCAN" : "DRSCAN", cmd->num_fields);
1270 #endif
1271
1272 for (i = 0; i < cmd->num_fields; i++)
1273 {
1274 if (cmd->fields[i].out_value)
1275 {
1276 #ifdef _DEBUG_JTAG_IO_
1277 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);
1278 #endif
1279 buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
1280 #ifdef _DEBUG_JTAG_IO_
1281 LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i, cmd->fields[i].num_bits, char_buf);
1282 free(char_buf);
1283 #endif
1284 }
1285 else
1286 {
1287 #ifdef _DEBUG_JTAG_IO_
1288 LOG_DEBUG("fields[%i].out_value[%i]: NULL", i, cmd->fields[i].num_bits);
1289 #endif
1290 }
1291
1292 bit_count += cmd->fields[i].num_bits;
1293 }
1294
1295 #ifdef _DEBUG_JTAG_IO_
1296 //LOG_DEBUG("bit_count totalling: %i", bit_count );
1297 #endif
1298
1299 return bit_count;
1300 }
1301
1302 int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
1303 {
1304 int i;
1305 int bit_count = 0;
1306 int retval;
1307
1308 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1309 retval = ERROR_OK;
1310
1311 for (i = 0; i < cmd->num_fields; i++)
1312 {
1313 /* if neither in_value nor in_handler
1314 * are specified we don't have to examine this field
1315 */
1316 if (cmd->fields[i].in_value)
1317 {
1318 int num_bits = cmd->fields[i].num_bits;
1319 u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
1320
1321 #ifdef _DEBUG_JTAG_IO_
1322 char *char_buf = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1323 LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i, num_bits, char_buf);
1324 free(char_buf);
1325 #endif
1326
1327 if (cmd->fields[i].in_value)
1328 {
1329 buf_cpy(captured, cmd->fields[i].in_value, num_bits);
1330 }
1331
1332 free(captured);
1333 }
1334 bit_count += cmd->fields[i].num_bits;
1335 }
1336
1337 return retval;
1338 }
1339
1340 static const char *jtag_tap_name(jtag_tap_t *tap)
1341 {
1342 return (tap == NULL) ? "(unknown)" : tap->dotted_name;
1343 }
1344
1345 int jtag_check_value_inner(u8 *captured, scan_field_t *field, u8 *in_check_value, u8 *in_check_mask)
1346 {
1347 int retval = ERROR_OK;
1348 int num_bits = field->num_bits;
1349
1350 int compare_failed = 0;
1351
1352 if (in_check_mask)
1353 compare_failed = buf_cmp_mask(captured, in_check_value, in_check_mask, num_bits);
1354 else
1355 compare_failed = buf_cmp(captured, in_check_value, num_bits);
1356
1357 if (compare_failed){
1358 /* An error handler could have caught the failing check
1359 * only report a problem when there wasn't a handler, or if the handler
1360 * acknowledged the error
1361 */
1362 LOG_WARNING("TAP %s:",
1363 jtag_tap_name(field->tap));
1364 if (compare_failed)
1365 {
1366 char *captured_char = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1367 char *in_check_value_char = buf_to_str(in_check_value, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1368
1369 if (in_check_mask)
1370 {
1371 char *in_check_mask_char;
1372 in_check_mask_char = buf_to_str(in_check_mask, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1373 LOG_WARNING("value captured during scan didn't pass the requested check:");
1374 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
1375 captured_char, in_check_value_char, in_check_mask_char);
1376 free(in_check_mask_char);
1377 }
1378 else
1379 {
1380 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);
1381 }
1382
1383 free(captured_char);
1384 free(in_check_value_char);
1385
1386 retval = ERROR_JTAG_QUEUE_FAILED;
1387 }
1388
1389 }
1390 return retval;
1391 }
1392
1393 void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask)
1394 {
1395 assert(field->in_value != NULL);
1396
1397 if (value==NULL)
1398 {
1399 /* no checking to do */
1400 return;
1401 }
1402
1403 jtag_execute_queue_noclear();
1404
1405 int retval=jtag_check_value_inner(field->in_value, field, value, mask);
1406 jtag_set_error(retval);
1407 }
1408
1409
1410
1411 enum scan_type jtag_scan_type(scan_command_t *cmd)
1412 {
1413 int i;
1414 int type = 0;
1415
1416 for (i = 0; i < cmd->num_fields; i++)
1417 {
1418 if (cmd->fields[i].in_value)
1419 type |= SCAN_IN;
1420 if (cmd->fields[i].out_value)
1421 type |= SCAN_OUT;
1422 }
1423
1424 return type;
1425 }
1426
1427 int MINIDRIVER(interface_jtag_execute_queue)(void)
1428 {
1429 int retval;
1430
1431 if (jtag==NULL)
1432 {
1433 LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets.");
1434 return ERROR_FAIL;
1435 }
1436
1437 retval = jtag->execute_queue();
1438
1439 cmd_queue_free();
1440
1441 jtag_command_queue = NULL;
1442 last_comand_pointer = &jtag_command_queue;
1443
1444 return retval;
1445 }
1446
1447 void jtag_execute_queue_noclear(void)
1448 {
1449 int retval=interface_jtag_execute_queue();
1450 /* we keep the first error */
1451 if ((jtag_error==ERROR_OK)&&(retval!=ERROR_OK))
1452 {
1453 jtag_error=retval;
1454 }
1455 }
1456
1457 int jtag_execute_queue(void)
1458 {
1459 int retval;
1460 jtag_execute_queue_noclear();
1461 retval=jtag_error;
1462 jtag_error=ERROR_OK;
1463 return retval;
1464 }
1465
1466 int jtag_reset_callback(enum jtag_event event, void *priv)
1467 {
1468 jtag_tap_t *tap = priv;
1469
1470 LOG_DEBUG("-");
1471
1472 if (event == JTAG_TRST_ASSERTED)
1473 {
1474 buf_set_ones(tap->cur_instr, tap->ir_length);
1475 tap->bypass = 1;
1476 }
1477
1478 return ERROR_OK;
1479 }
1480
1481 void jtag_sleep(u32 us)
1482 {
1483 alive_sleep(us/1000);
1484 }
1485
1486 /* Try to examine chain layout according to IEEE 1149.1 §12
1487 */
1488 int jtag_examine_chain(void)
1489 {
1490 jtag_tap_t *tap;
1491 scan_field_t field;
1492 u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1493 int i;
1494 int bit_count;
1495 int device_count = 0;
1496 u8 zero_check = 0x0;
1497 u8 one_check = 0xff;
1498
1499 field.tap = NULL;
1500 field.num_bits = sizeof(idcode_buffer) * 8;
1501 field.out_value = idcode_buffer;
1502
1503 field.in_value = idcode_buffer;
1504
1505
1506
1507
1508 for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
1509 {
1510 buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
1511 }
1512
1513 jtag_add_plain_dr_scan(1, &field, TAP_RESET);
1514 jtag_execute_queue();
1515
1516 for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++)
1517 {
1518 zero_check |= idcode_buffer[i];
1519 one_check &= idcode_buffer[i];
1520 }
1521
1522 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1523 if ((zero_check == 0x00) || (one_check == 0xff))
1524 {
1525 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1526 return ERROR_JTAG_INIT_FAILED;
1527 }
1528
1529 /* point at the 1st tap */
1530 tap = jtag_NextEnabledTap(NULL);
1531 if( tap == NULL ){
1532 LOG_ERROR("JTAG: No taps enabled?");
1533 return ERROR_JTAG_INIT_FAILED;
1534 }
1535
1536 for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
1537 {
1538 u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1539 if ((idcode & 1) == 0)
1540 {
1541 /* LSB must not be 0, this indicates a device in bypass */
1542 LOG_WARNING("Tap/Device does not have IDCODE");
1543 idcode=0;
1544
1545 bit_count += 1;
1546 }
1547 else
1548 {
1549 u32 manufacturer;
1550 u32 part;
1551 u32 version;
1552
1553 /* some devices, such as AVR will output all 1's instead of TDI
1554 input value at end of chain. */
1555 if ((idcode == 0x000000FF)||(idcode == 0xFFFFFFFF))
1556 {
1557 int unexpected=0;
1558 /* End of chain (invalid manufacturer ID)
1559 *
1560 * The JTAG examine is the very first thing that happens
1561 *
1562 * A single JTAG device requires only 64 bits to be read back correctly.
1563 *
1564 * The code below adds a check that the rest of the data scanned (640 bits)
1565 * are all as expected. This helps diagnose/catch problems with the JTAG chain
1566 *
1567 * earlier and gives more helpful/explicit error messages.
1568 */
1569 for (bit_count += 32; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;bit_count += 32)
1570 {
1571 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1572 if (unexpected||((idcode != 0x000000FF)&&(idcode != 0xFFFFFFFF)))
1573 {
1574 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count, idcode);
1575 unexpected = 1;
1576 }
1577 }
1578
1579 break;
1580 }
1581
1582 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
1583 manufacturer = EXTRACT_MFG(idcode);
1584 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
1585 part = EXTRACT_PART(idcode);
1586 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
1587 version = EXTRACT_VER(idcode);
1588
1589 LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1590 ((tap != NULL) ? (tap->dotted_name) : "(not-named)"),
1591 idcode, manufacturer, part, version);
1592
1593 bit_count += 32;
1594 }
1595 if (tap)
1596 {
1597 tap->idcode = idcode;
1598
1599 if (tap->expected_ids_cnt > 0) {
1600 /* Loop over the expected identification codes and test for a match */
1601 u8 ii;
1602 for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1603 if( tap->idcode == tap->expected_ids[ii] ){
1604 break;
1605 }
1606 }
1607
1608 /* If none of the expected ids matched, log an error */
1609 if (ii == tap->expected_ids_cnt) {
1610 LOG_ERROR("JTAG tap: %s got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1611 tap->dotted_name,
1612 idcode,
1613 EXTRACT_MFG( tap->idcode ),
1614 EXTRACT_PART( tap->idcode ),
1615 EXTRACT_VER( tap->idcode ) );
1616 for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1617 LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1618 tap->dotted_name,
1619 ii + 1,
1620 tap->expected_ids_cnt,
1621 tap->expected_ids[ii],
1622 EXTRACT_MFG( tap->expected_ids[ii] ),
1623 EXTRACT_PART( tap->expected_ids[ii] ),
1624 EXTRACT_VER( tap->expected_ids[ii] ) );
1625 }
1626
1627 return ERROR_JTAG_INIT_FAILED;
1628 } else {
1629 LOG_INFO("JTAG Tap/device matched");
1630 }
1631 } else {
1632 #if 0
1633 LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project",
1634 tap->idcode);
1635 #endif
1636 }
1637 tap = jtag_NextEnabledTap(tap);
1638 }
1639 device_count++;
1640 }
1641
1642 /* see if number of discovered devices matches configuration */
1643 if (device_count != jtag_NumEnabledTaps())
1644 {
1645 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d",
1646 device_count, jtag_NumEnabledTaps(), jtag_NumTotalTaps());
1647 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1648 return ERROR_JTAG_INIT_FAILED;
1649 }
1650
1651 return ERROR_OK;
1652 }
1653
1654 int jtag_validate_chain(void)
1655 {
1656 jtag_tap_t *tap;
1657 int total_ir_length = 0;
1658 u8 *ir_test = NULL;
1659 scan_field_t field;
1660 int chain_pos = 0;
1661
1662 tap = NULL;
1663 total_ir_length = 0;
1664 for(;;){
1665 tap = jtag_NextEnabledTap(tap);
1666 if( tap == NULL ){
1667 break;
1668 }
1669 total_ir_length += tap->ir_length;
1670 }
1671
1672 total_ir_length += 2;
1673 ir_test = malloc(CEIL(total_ir_length, 8));
1674 buf_set_ones(ir_test, total_ir_length);
1675
1676 field.tap = NULL;
1677 field.num_bits = total_ir_length;
1678 field.out_value = ir_test;
1679 field.in_value = ir_test;
1680
1681
1682 jtag_add_plain_ir_scan(1, &field, TAP_RESET);
1683 jtag_execute_queue();
1684
1685 tap = NULL;
1686 chain_pos = 0;
1687 int val;
1688 for(;;){
1689 tap = jtag_NextEnabledTap(tap);
1690 if( tap == NULL ){
1691 break;
1692 }
1693
1694 val = buf_get_u32(ir_test, chain_pos, 2);
1695 if (val != 0x1)
1696 {
1697 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1698 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);
1699 free(cbuf);
1700 free(ir_test);
1701 return ERROR_JTAG_INIT_FAILED;
1702 }
1703 chain_pos += tap->ir_length;
1704 }
1705
1706 val = buf_get_u32(ir_test, chain_pos, 2);
1707 if (val != 0x3)
1708 {
1709 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1710 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);
1711 free(cbuf);
1712 free(ir_test);
1713 return ERROR_JTAG_INIT_FAILED;
1714 }
1715
1716 free(ir_test);
1717
1718 return ERROR_OK;
1719 }
1720
1721 enum jtag_tap_cfg_param {
1722 JCFG_EVENT
1723 };
1724
1725 static Jim_Nvp nvp_config_opts[] = {
1726 { .name = "-event", .value = JCFG_EVENT },
1727
1728 { .name = NULL, .value = -1 }
1729 };
1730
1731 static int jtag_tap_configure_cmd( Jim_GetOptInfo *goi, jtag_tap_t * tap)
1732 {
1733 Jim_Nvp *n;
1734 Jim_Obj *o;
1735 int e;
1736
1737 /* parse config or cget options */
1738 while (goi->argc > 0) {
1739 Jim_SetEmptyResult (goi->interp);
1740
1741 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
1742 if (e != JIM_OK) {
1743 Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
1744 return e;
1745 }
1746
1747 switch (n->value) {
1748 case JCFG_EVENT:
1749 if (goi->argc == 0) {
1750 Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ..." );
1751 return JIM_ERR;
1752 }
1753
1754 e = Jim_GetOpt_Nvp( goi, nvp_jtag_tap_event, &n );
1755 if (e != JIM_OK) {
1756 Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
1757 return e;
1758 }
1759
1760 if (goi->isconfigure) {
1761 if (goi->argc != 1) {
1762 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
1763 return JIM_ERR;
1764 }
1765 } else {
1766 if (goi->argc != 0) {
1767 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
1768 return JIM_ERR;
1769 }
1770 }
1771
1772 {
1773 jtag_tap_event_action_t *jteap;
1774
1775 jteap = tap->event_action;
1776 /* replace existing? */
1777 while (jteap) {
1778 if (jteap->event == (enum jtag_tap_event)n->value) {
1779 break;
1780 }
1781 jteap = jteap->next;
1782 }
1783
1784 if (goi->isconfigure) {
1785 if (jteap == NULL) {
1786 /* create new */
1787 jteap = calloc(1, sizeof (*jteap));
1788 }
1789 jteap->event = n->value;
1790 Jim_GetOpt_Obj( goi, &o);
1791 if (jteap->body) {
1792 Jim_DecrRefCount(interp, jteap->body);
1793 }
1794 jteap->body = Jim_DuplicateObj(goi->interp, o);
1795 Jim_IncrRefCount(jteap->body);
1796
1797 /* add to head of event list */
1798 jteap->next = tap->event_action;
1799 tap->event_action = jteap;
1800 Jim_SetEmptyResult(goi->interp);
1801 } else {
1802 /* get */
1803 if (jteap == NULL) {
1804 Jim_SetEmptyResult(goi->interp);
1805 } else {
1806 Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, jteap->body));
1807 }
1808 }
1809 }
1810 /* loop for more */
1811 break;
1812 }
1813 } /* while (goi->argc) */
1814
1815 return JIM_OK;
1816 }
1817
1818 static int jim_newtap_cmd( Jim_GetOptInfo *goi )
1819 {
1820 jtag_tap_t *pTap;
1821 jtag_tap_t **ppTap;
1822 jim_wide w;
1823 int x;
1824 int e;
1825 int reqbits;
1826 Jim_Nvp *n;
1827 char *cp;
1828 const Jim_Nvp opts[] = {
1829 #define NTAP_OPT_IRLEN 0
1830 { .name = "-irlen" , .value = NTAP_OPT_IRLEN },
1831 #define NTAP_OPT_IRMASK 1
1832 { .name = "-irmask" , .value = NTAP_OPT_IRMASK },
1833 #define NTAP_OPT_IRCAPTURE 2
1834 { .name = "-ircapture" , .value = NTAP_OPT_IRCAPTURE },
1835 #define NTAP_OPT_ENABLED 3
1836 { .name = "-enable" , .value = NTAP_OPT_ENABLED },
1837 #define NTAP_OPT_DISABLED 4
1838 { .name = "-disable" , .value = NTAP_OPT_DISABLED },
1839 #define NTAP_OPT_EXPECTED_ID 5
1840 { .name = "-expected-id" , .value = NTAP_OPT_EXPECTED_ID },
1841 { .name = NULL , .value = -1 },
1842 };
1843
1844 pTap = malloc( sizeof(jtag_tap_t) );
1845 memset( pTap, 0, sizeof(*pTap) );
1846 if( !pTap ){
1847 Jim_SetResult_sprintf( goi->interp, "no memory");
1848 return JIM_ERR;
1849 }
1850 /*
1851 * we expect CHIP + TAP + OPTIONS
1852 * */
1853 if( goi->argc < 3 ){
1854 Jim_SetResult_sprintf(goi->interp, "Missing CHIP TAP OPTIONS ....");
1855 return JIM_ERR;
1856 }
1857 Jim_GetOpt_String( goi, &cp, NULL );
1858 pTap->chip = strdup(cp);
1859
1860 Jim_GetOpt_String( goi, &cp, NULL );
1861 pTap->tapname = strdup(cp);
1862
1863 /* name + dot + name + null */
1864 x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
1865 cp = malloc( x );
1866 sprintf( cp, "%s.%s", pTap->chip, pTap->tapname );
1867 pTap->dotted_name = cp;
1868
1869 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
1870 pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
1871
1872 /* default is enabled */
1873 pTap->enabled = 1;
1874
1875 /* deal with options */
1876 #define NTREQ_IRLEN 1
1877 #define NTREQ_IRCAPTURE 2
1878 #define NTREQ_IRMASK 4
1879
1880 /* clear them as we find them */
1881 reqbits = (NTREQ_IRLEN | NTREQ_IRCAPTURE | NTREQ_IRMASK);
1882
1883 while( goi->argc ){
1884 e = Jim_GetOpt_Nvp( goi, opts, &n );
1885 if( e != JIM_OK ){
1886 Jim_GetOpt_NvpUnknown( goi, opts, 0 );
1887 return e;
1888 }
1889 LOG_DEBUG("Processing option: %s", n->name );
1890 switch( n->value ){
1891 case NTAP_OPT_ENABLED:
1892 pTap->enabled = 1;
1893 break;
1894 case NTAP_OPT_DISABLED:
1895 pTap->enabled = 0;
1896 break;
1897 case NTAP_OPT_EXPECTED_ID:
1898 {
1899 u32 *new_expected_ids;
1900
1901 e = Jim_GetOpt_Wide( goi, &w );
1902 if( e != JIM_OK) {
1903 Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
1904 return e;
1905 }
1906
1907 new_expected_ids = malloc(sizeof(u32) * (pTap->expected_ids_cnt + 1));
1908 if (new_expected_ids == NULL) {
1909 Jim_SetResult_sprintf( goi->interp, "no memory");
1910 return JIM_ERR;
1911 }
1912
1913 memcpy(new_expected_ids, pTap->expected_ids, sizeof(u32) * pTap->expected_ids_cnt);
1914
1915 new_expected_ids[pTap->expected_ids_cnt] = w;
1916
1917 free(pTap->expected_ids);
1918 pTap->expected_ids = new_expected_ids;
1919 pTap->expected_ids_cnt++;
1920 break;
1921 }
1922 case NTAP_OPT_IRLEN:
1923 case NTAP_OPT_IRMASK:
1924 case NTAP_OPT_IRCAPTURE:
1925 e = Jim_GetOpt_Wide( goi, &w );
1926 if( e != JIM_OK ){
1927 Jim_SetResult_sprintf( goi->interp, "option: %s bad parameter", n->name );
1928 return e;
1929 }
1930 if( (w < 0) || (w > 0xffff) ){
1931 /* wacky value */
1932 Jim_SetResult_sprintf( goi->interp, "option: %s - wacky value: %d (0x%x)",
1933 n->name, (int)(w), (int)(w));
1934 return JIM_ERR;
1935 }
1936 switch(n->value){
1937 case NTAP_OPT_IRLEN:
1938 pTap->ir_length = w;
1939 reqbits &= (~(NTREQ_IRLEN));
1940 break;
1941 case NTAP_OPT_IRMASK:
1942 pTap->ir_capture_mask = w;
1943 reqbits &= (~(NTREQ_IRMASK));
1944 break;
1945 case NTAP_OPT_IRCAPTURE:
1946 pTap->ir_capture_value = w;
1947 reqbits &= (~(NTREQ_IRCAPTURE));
1948 break;
1949 }
1950 } /* switch(n->value) */
1951 } /* while( goi->argc ) */
1952
1953 /* Did we get all the options? */
1954 if( reqbits ){
1955 // no
1956 Jim_SetResult_sprintf( goi->interp,
1957 "newtap: %s missing required parameters",
1958 pTap->dotted_name);
1959 /* TODO: Tell user what is missing :-( */
1960 /* no memory leaks pelase */
1961 free(((void *)(pTap->expected_ids)));
1962 free(((void *)(pTap->chip)));
1963 free(((void *)(pTap->tapname)));
1964 free(((void *)(pTap->dotted_name)));
1965 free(((void *)(pTap)));
1966 return JIM_ERR;
1967 }
1968
1969 pTap->expected = malloc( pTap->ir_length );
1970 pTap->expected_mask = malloc( pTap->ir_length );
1971 pTap->cur_instr = malloc( pTap->ir_length );
1972
1973 buf_set_u32( pTap->expected,
1974 0,
1975 pTap->ir_length,
1976 pTap->ir_capture_value );
1977 buf_set_u32( pTap->expected_mask,
1978 0,
1979 pTap->ir_length,
1980 pTap->ir_capture_mask );
1981 buf_set_ones( pTap->cur_instr,
1982 pTap->ir_length );
1983
1984 pTap->bypass = 1;
1985
1986 jtag_register_event_callback(jtag_reset_callback, pTap );
1987
1988 ppTap = &(jtag_all_taps);
1989 while( (*ppTap) != NULL ){
1990 ppTap = &((*ppTap)->next_tap);
1991 }
1992 *ppTap = pTap;
1993 {
1994 static int n_taps = 0;
1995 pTap->abs_chain_position = n_taps++;
1996 }
1997 LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
1998 (*ppTap)->dotted_name,
1999 (*ppTap)->abs_chain_position,
2000 (*ppTap)->ir_length,
2001 (*ppTap)->ir_capture_value,
2002 (*ppTap)->ir_capture_mask );
2003
2004 return ERROR_OK;
2005 }
2006
2007 static int jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
2008 {
2009 Jim_GetOptInfo goi;
2010 int e;
2011 Jim_Nvp *n;
2012 Jim_Obj *o;
2013 struct command_context_s *context;
2014
2015 enum {
2016 JTAG_CMD_INTERFACE,
2017 JTAG_CMD_INIT_RESET,
2018 JTAG_CMD_NEWTAP,
2019 JTAG_CMD_TAPENABLE,
2020 JTAG_CMD_TAPDISABLE,
2021 JTAG_CMD_TAPISENABLED,
2022 JTAG_CMD_CONFIGURE,
2023 JTAG_CMD_CGET
2024 };
2025
2026 const Jim_Nvp jtag_cmds[] = {
2027 { .name = "interface" , .value = JTAG_CMD_INTERFACE },
2028 { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET },
2029 { .name = "newtap" , .value = JTAG_CMD_NEWTAP },
2030 { .name = "tapisenabled" , .value = JTAG_CMD_TAPISENABLED },
2031 { .name = "tapenable" , .value = JTAG_CMD_TAPENABLE },
2032 { .name = "tapdisable" , .value = JTAG_CMD_TAPDISABLE },
2033 { .name = "configure" , .value = JTAG_CMD_CONFIGURE },
2034 { .name = "cget" , .value = JTAG_CMD_CGET },
2035
2036 { .name = NULL, .value = -1 },
2037 };
2038
2039 context = Jim_GetAssocData(interp, "context");
2040 /* go past the command */
2041 Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
2042
2043 e = Jim_GetOpt_Nvp( &goi, jtag_cmds, &n );
2044 if( e != JIM_OK ){
2045 Jim_GetOpt_NvpUnknown( &goi, jtag_cmds, 0 );
2046 return e;
2047 }
2048 Jim_SetEmptyResult( goi.interp );
2049 switch( n->value ){
2050 case JTAG_CMD_INTERFACE:
2051 /* return the name of the interface */
2052 /* TCL code might need to know the exact type... */
2053 /* FUTURE: we allow this as a means to "set" the interface. */
2054 if( goi.argc != 0 ){
2055 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
2056 return JIM_ERR;
2057 }
2058 Jim_SetResultString( goi.interp, jtag_interface->name, -1 );
2059 return JIM_OK;
2060 case JTAG_CMD_INIT_RESET:
2061 if( goi.argc != 0 ){
2062 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
2063 return JIM_ERR;
2064 }
2065 e = jtag_init_reset(context);
2066 if( e != ERROR_OK ){
2067 Jim_SetResult_sprintf( goi.interp, "error: %d", e);
2068 return JIM_ERR;
2069 }
2070 return JIM_OK;
2071 case JTAG_CMD_NEWTAP:
2072 return jim_newtap_cmd( &goi );
2073 break;
2074 case JTAG_CMD_TAPISENABLED:
2075 case JTAG_CMD_TAPENABLE:
2076 case JTAG_CMD_TAPDISABLE:
2077 if( goi.argc != 1 ){
2078 Jim_SetResultString( goi.interp, "Too many parameters",-1 );
2079 return JIM_ERR;
2080 }
2081
2082 {
2083 jtag_tap_t *t;
2084 t = jtag_TapByJimObj( goi.interp, goi.argv[0] );
2085 if( t == NULL ){
2086 return JIM_ERR;
2087 }
2088 switch( n->value ){
2089 case JTAG_CMD_TAPISENABLED:
2090 e = t->enabled;
2091 break;
2092 case JTAG_CMD_TAPENABLE:
2093 jtag_tap_handle_event( t, JTAG_TAP_EVENT_ENABLE);
2094 e = 1;
2095 t->enabled = e;
2096 break;
2097 case JTAG_CMD_TAPDISABLE:
2098 jtag_tap_handle_event( t, JTAG_TAP_EVENT_DISABLE);
2099 e = 0;
2100 t->enabled = e;
2101 break;
2102 }
2103 Jim_SetResult( goi.interp, Jim_NewIntObj( goi.interp, e ) );
2104 return JIM_OK;
2105 }
2106 break;
2107
2108 case JTAG_CMD_CGET:
2109 if( goi.argc < 2 ){
2110 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ...");
2111 return JIM_ERR;
2112 }
2113
2114 {
2115 jtag_tap_t *t;
2116
2117 Jim_GetOpt_Obj(&goi, &o);
2118 t = jtag_TapByJimObj( goi.interp, o );
2119 if( t == NULL ){
2120 return JIM_ERR;
2121 }
2122
2123 goi.isconfigure = 0;
2124 return jtag_tap_configure_cmd( &goi, t);
2125 }
2126 break;
2127
2128 case JTAG_CMD_CONFIGURE:
2129 if( goi.argc < 3 ){
2130 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ?VALUE? ...");
2131 return JIM_ERR;
2132 }
2133
2134 {
2135 jtag_tap_t *t;
2136
2137 Jim_GetOpt_Obj(&goi, &o);
2138 t = jtag_TapByJimObj( goi.interp, o );
2139 if( t == NULL ){
2140 return JIM_ERR;
2141 }
2142
2143 goi.isconfigure = 1;
2144 return jtag_tap_configure_cmd( &goi, t);
2145 }
2146 }
2147
2148 return JIM_ERR;
2149 }
2150
2151 int jtag_register_commands(struct command_context_s *cmd_ctx)
2152 {
2153 register_jim( cmd_ctx, "jtag", jim_jtag_command, "perform jtag tap actions");
2154
2155 register_command(cmd_ctx, NULL, "interface", handle_interface_command,
2156 COMMAND_CONFIG, "try to configure interface");
2157 register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
2158 COMMAND_ANY, "set jtag speed (if supported)");
2159 register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
2160 COMMAND_ANY, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");
2161 register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
2162 COMMAND_CONFIG, "jtag_device <ir_length> <ir_expected> <ir_mask>");
2163 register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
2164 COMMAND_ANY,
2165 "[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]");
2166 register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
2167 COMMAND_ANY, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
2168 register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
2169 COMMAND_ANY, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
2170
2171 register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
2172 COMMAND_EXEC, "print current scan chain configuration");
2173
2174 register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
2175 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
2176 register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
2177 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
2178 register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
2179 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
2180 register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
2181 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
2182 register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
2183
2184 register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
2185 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
2186 return ERROR_OK;
2187 }
2188
2189 int jtag_interface_init(struct command_context_s *cmd_ctx)
2190 {
2191 if (jtag)
2192 return ERROR_OK;
2193
2194 if (!jtag_interface)
2195 {
2196 /* nothing was previously specified by "interface" command */
2197 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
2198 return ERROR_JTAG_INVALID_INTERFACE;
2199 }
2200 if(hasKHz)
2201 {
2202 jtag_interface->khz(speed_khz, &jtag_speed);
2203 hasKHz = 0;
2204 }
2205
2206 if (jtag_interface->init() != ERROR_OK)
2207 return ERROR_JTAG_INIT_FAILED;
2208
2209 jtag = jtag_interface;
2210 return ERROR_OK;
2211 }
2212
2213 static int jtag_init_inner(struct command_context_s *cmd_ctx)
2214 {
2215 jtag_tap_t *tap;
2216 int retval;
2217
2218 LOG_DEBUG("Init JTAG chain");
2219
2220 tap = jtag_NextEnabledTap(NULL);
2221 if( tap == NULL ){
2222 LOG_ERROR("There are no enabled taps?");
2223 return ERROR_JTAG_INIT_FAILED;
2224 }
2225
2226 jtag_add_tlr();
2227 if ((retval=jtag_execute_queue())!=ERROR_OK)
2228 return retval;
2229
2230 /* examine chain first, as this could discover the real chain layout */
2231 if (jtag_examine_chain() != ERROR_OK)
2232 {
2233 LOG_ERROR("trying to validate configured JTAG chain anyway...");
2234 }
2235
2236 if (jtag_validate_chain() != ERROR_OK)
2237 {
2238 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
2239 }
2240
2241 return ERROR_OK;
2242 }
2243
2244 int jtag_init_reset(struct command_context_s *cmd_ctx)
2245 {
2246 int retval;
2247
2248 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2249 return retval;
2250
2251 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
2252
2253 /* Reset can happen after a power cycle.
2254 *
2255 * Ideally we would only assert TRST or run RESET before the target reset.
2256 *
2257 * However w/srst_pulls_trst, trst is asserted together with the target
2258 * reset whether we want it or not.
2259 *
2260 * NB! Some targets have JTAG circuitry disabled until a
2261 * trst & srst has been asserted.
2262 *
2263 * NB! here we assume nsrst/ntrst delay are sufficient!
2264 *
2265 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
2266 *
2267 */
2268 jtag_add_reset(1, 0); /* RESET or TRST */
2269 if (jtag_reset_config & RESET_HAS_SRST)
2270 {
2271 jtag_add_reset(1, 1);
2272 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
2273 jtag_add_reset(0, 1);
2274 }
2275 jtag_add_reset(0, 0);
2276 if ((retval = jtag_execute_queue()) != ERROR_OK)
2277 return retval;
2278
2279 /* Check that we can communication on the JTAG chain + eventually we want to
2280 * be able to perform enumeration only after OpenOCD has started
2281 * telnet and GDB server
2282 *
2283 * That would allow users to more easily perform any magic they need to before
2284 * reset happens.
2285 */
2286 return jtag_init_inner(cmd_ctx);
2287 }
2288
2289 int jtag_init(struct command_context_s *cmd_ctx)
2290 {
2291 int retval;
2292 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2293 return retval;
2294 if (jtag_init_inner(cmd_ctx)==ERROR_OK)
2295 {
2296 return ERROR_OK;
2297 }
2298 return jtag_init_reset(cmd_ctx);
2299 }
2300
2301 static int default_khz(int khz, int *jtag_speed)
2302 {
2303 LOG_ERROR("Translation from khz to jtag_speed not implemented");
2304 return ERROR_FAIL;
2305 }
2306
2307 static int default_speed_div(int speed, int *khz)
2308 {
2309 LOG_ERROR("Translation from jtag_speed to khz not implemented");
2310 return ERROR_FAIL;
2311 }
2312
2313 static int default_power_dropout(int *dropout)
2314 {
2315 *dropout=0; /* by default we can't detect power dropout */
2316 return ERROR_OK;
2317 }
2318
2319 static int default_srst_asserted(int *srst_asserted)
2320 {
2321 *srst_asserted=0; /* by default we can't detect srst asserted */
2322 return ERROR_OK;
2323 }
2324
2325 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2326 {
2327 int i;
2328 int retval;
2329
2330 /* check whether the interface is already configured */
2331 if (jtag_interface)
2332 {
2333 LOG_WARNING("Interface already configured, ignoring");
2334 return ERROR_OK;
2335 }
2336
2337 /* interface name is a mandatory argument */
2338 if (argc < 1 || args[0][0] == '\0')
2339 {
2340 return ERROR_COMMAND_SYNTAX_ERROR;
2341 }
2342
2343 for (i=0; jtag_interfaces[i]; i++)
2344 {
2345 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
2346 {
2347 if ((retval = jtag_interfaces[i]->register_commands(cmd_ctx)) != ERROR_OK)
2348 {
2349 return retval;
2350 }
2351
2352 jtag_interface = jtag_interfaces[i];
2353
2354 if (jtag_interface->khz == NULL)
2355 {
2356 jtag_interface->khz = default_khz;
2357 }
2358 if (jtag_interface->speed_div == NULL)
2359 {
2360 jtag_interface->speed_div = default_speed_div;
2361 }
2362 if (jtag_interface->power_dropout == NULL)
2363 {
2364 jtag_interface->power_dropout = default_power_dropout;
2365 }
2366 if (jtag_interface->srst_asserted == NULL)
2367 {
2368 jtag_interface->srst_asserted = default_srst_asserted;
2369 }
2370
2371 return ERROR_OK;
2372 }
2373 }
2374
2375 /* no valid interface was found (i.e. the configuration option,
2376 * didn't match one of the compiled-in interfaces
2377 */
2378 LOG_ERROR("No valid jtag interface found (%s)", args[0]);
2379 LOG_ERROR("compiled-in jtag interfaces:");
2380 for (i = 0; jtag_interfaces[i]; i++)
2381 {
2382 LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
2383 }
2384
2385 return ERROR_JTAG_INVALID_INTERFACE;
2386 }
2387
2388 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2389 {
2390 int e;
2391 char buf[1024];
2392 Jim_Obj *newargs[ 10 ];
2393 /*
2394 * CONVERT SYNTAX
2395 * argv[-1] = command
2396 * argv[ 0] = ir length
2397 * argv[ 1] = ir capture
2398 * argv[ 2] = ir mask
2399 * argv[ 3] = not actually used by anything but in the docs
2400 */
2401
2402 if( argc < 4 ){
2403 command_print( cmd_ctx, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
2404 return ERROR_OK;
2405 }
2406 command_print( cmd_ctx, "OLD SYNTAX: DEPRECATED - translating to new syntax");
2407 command_print( cmd_ctx, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
2408 args[0],
2409 args[1],
2410 args[2] );
2411 command_print( cmd_ctx, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
2412 command_print( cmd_ctx, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
2413 command_print( cmd_ctx, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
2414 command_print( cmd_ctx, "And then refer to the taps by the dotted name.");
2415
2416 newargs[0] = Jim_NewStringObj( interp, "jtag", -1 );
2417 newargs[1] = Jim_NewStringObj( interp, "newtap", -1 );
2418 sprintf( buf, "chip%d", jtag_NumTotalTaps() );
2419 newargs[2] = Jim_NewStringObj( interp, buf, -1 );
2420 sprintf( buf, "tap%d", jtag_NumTotalTaps() );
2421 newargs[3] = Jim_NewStringObj( interp, buf, -1 );
2422 newargs[4] = Jim_NewStringObj( interp, "-irlen", -1 );
2423 newargs[5] = Jim_NewStringObj( interp, args[0], -1 );
2424 newargs[6] = Jim_NewStringObj( interp, "-ircapture", -1 );
2425 newargs[7] = Jim_NewStringObj( interp, args[1], -1 );
2426 newargs[8] = Jim_NewStringObj( interp, "-irmask", -1 );
2427 newargs[9] = Jim_NewStringObj( interp, args[2], -1 );
2428
2429 command_print( cmd_ctx, "NEW COMMAND:");
2430 sprintf( buf, "%s %s %s %s %s %s %s %s %s %s",
2431 Jim_GetString( newargs[0], NULL ),
2432 Jim_GetString( newargs[1], NULL ),
2433 Jim_GetString( newargs[2], NULL ),
2434 Jim_GetString( newargs[3], NULL ),
2435 Jim_GetString( newargs[4], NULL ),
2436 Jim_GetString( newargs[5], NULL ),
2437 Jim_GetString( newargs[6], NULL ),
2438 Jim_GetString( newargs[7], NULL ),
2439 Jim_GetString( newargs[8], NULL ),
2440 Jim_GetString( newargs[9], NULL ) );
2441
2442 e = jim_jtag_command( interp, 10, newargs );
2443 if( e != JIM_OK ){
2444 command_print( cmd_ctx, "%s", Jim_GetString( Jim_GetResult(interp), NULL ) );
2445 }
2446 return e;
2447 }
2448
2449 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2450 {
2451 jtag_tap_t *tap;
2452
2453 tap = jtag_all_taps;
2454 command_print(cmd_ctx, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
2455 command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------");
2456
2457 while( tap ){
2458 u32 expected, expected_mask, cur_instr, ii;
2459 expected = buf_get_u32(tap->expected, 0, tap->ir_length);
2460 expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
2461 cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
2462
2463 command_print(cmd_ctx,
2464 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
2465 tap->abs_chain_position,
2466 tap->dotted_name,
2467 tap->enabled ? 'Y' : 'n',
2468 tap->idcode,
2469 (tap->expected_ids_cnt > 0 ? tap->expected_ids[0] : 0),
2470 tap->ir_length,
2471 expected,
2472 expected_mask,
2473 cur_instr);
2474
2475 for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
2476 command_print(cmd_ctx, " | | | | 0x%08x | | | | ",
2477 tap->expected_ids[ii]);
2478 }
2479
2480 tap = tap->next_tap;
2481 }
2482
2483 return ERROR_OK;
2484 }
2485
2486 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2487 {
2488 if (argc < 1)
2489 return ERROR_COMMAND_SYNTAX_ERROR;
2490
2491 if (argc >= 1)
2492 {
2493 if (strcmp(args[0], "none") == 0)
2494 jtag_reset_config = RESET_NONE;
2495 else if (strcmp(args[0], "trst_only") == 0)
2496 jtag_reset_config = RESET_HAS_TRST;
2497 else if (strcmp(args[0], "srst_only") == 0)
2498 jtag_reset_config = RESET_HAS_SRST;
2499 else if (strcmp(args[0], "trst_and_srst") == 0)
2500 jtag_reset_config = RESET_TRST_AND_SRST;
2501 else
2502 {
2503 LOG_ERROR("(1) invalid reset_config argument (%s), defaulting to none", args[0]);
2504 jtag_reset_config = RESET_NONE;
2505 return ERROR_INVALID_ARGUMENTS;
2506 }
2507 }
2508
2509 if (argc >= 2)
2510 {
2511 if (strcmp(args[1], "separate") == 0)
2512 {
2513 /* seperate reset lines - default */
2514 } else
2515 {
2516 if (strcmp(args[1], "srst_pulls_trst") == 0)
2517 jtag_reset_config |= RESET_SRST_PULLS_TRST;
2518 else if (strcmp(args[1], "trst_pulls_srst") == 0)
2519 jtag_reset_config |= RESET_TRST_PULLS_SRST;
2520 else if (strcmp(args[1], "combined") == 0)
2521 jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
2522 else
2523 {
2524 LOG_ERROR("(2) invalid reset_config argument (%s), defaulting to none", args[1]);
2525 jtag_reset_config = RESET_NONE;
2526 return ERROR_INVALID_ARGUMENTS;
2527 }
2528 }
2529 }
2530
2531 if (argc >= 3)
2532 {
2533 if (strcmp(args[2], "trst_open_drain") == 0)
2534 jtag_reset_config |= RESET_TRST_OPEN_DRAIN;
2535 else if (strcmp(args[2], "trst_push_pull") == 0)
2536 jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN;
2537 else
2538 {
2539 LOG_ERROR("(3) invalid reset_config argument (%s) defaulting to none", args[2] );
2540 jtag_reset_config = RESET_NONE;
2541 return ERROR_INVALID_ARGUMENTS;
2542 }
2543 }
2544
2545 if (argc >= 4)
2546 {
2547 if (strcmp(args[3], "srst_push_pull") == 0)
2548 jtag_reset_config |= RESET_SRST_PUSH_PULL;
2549 else if (strcmp(args[3], "srst_open_drain") == 0)
2550 jtag_reset_config &= ~RESET_SRST_PUSH_PULL;
2551 else
2552 {
2553 LOG_ERROR("(4) invalid reset_config argument (%s), defaulting to none", args[3]);
2554 jtag_reset_config = RESET_NONE;
2555 return ERROR_INVALID_ARGUMENTS;
2556 }
2557 }
2558
2559 return ERROR_OK;
2560 }
2561
2562 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2563 {
2564 if (argc < 1)
2565 {
2566 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2567 exit(-1);
2568 }
2569 else
2570 {
2571 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
2572 }
2573
2574 return ERROR_OK;
2575 }
2576
2577 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2578 {
2579 if (argc < 1)
2580 {
2581 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2582 exit(-1);
2583 }
2584 else
2585 {
2586 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
2587 }
2588
2589 return ERROR_OK;
2590 }
2591
2592 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2593 {
2594 int retval=ERROR_OK;
2595
2596 if (argc == 1)
2597 {
2598 LOG_DEBUG("handle jtag speed");
2599
2600 int cur_speed = 0;
2601 cur_speed = jtag_speed = strtoul(args[0], NULL, 0);
2602
2603 /* this command can be called during CONFIG,
2604 * in which case jtag isn't initialized */
2605 if (jtag)
2606 {
2607 retval=jtag->speed(cur_speed);
2608 }
2609 } else if (argc == 0)
2610 {
2611 } else
2612 {
2613 return ERROR_COMMAND_SYNTAX_ERROR;
2614 }
2615 command_print(cmd_ctx, "jtag_speed: %d", jtag_speed);
2616
2617 return retval;
2618 }
2619
2620 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2621 {
2622 int retval=ERROR_OK;
2623 LOG_DEBUG("handle jtag khz");
2624
2625 if(argc == 1)
2626 {
2627 speed_khz = strtoul(args[0], NULL, 0);
2628 if (jtag != NULL)
2629 {
2630 int cur_speed = 0;
2631 LOG_DEBUG("have interface set up");
2632 int speed_div1;
2633 if ((retval=jtag->khz(speed_khz, &speed_div1))!=ERROR_OK)
2634 {
2635 speed_khz = 0;
2636 return retval;
2637 }
2638
2639 cur_speed = jtag_speed = speed_div1;
2640
2641 retval=jtag->speed(cur_speed);
2642 } else
2643 {
2644 hasKHz = 1;
2645 }
2646 } else if (argc==0)
2647 {
2648 } else
2649 {
2650 return ERROR_COMMAND_SYNTAX_ERROR;
2651 }
2652
2653 if (jtag!=NULL)
2654 {
2655 if ((retval=jtag->speed_div(jtag_speed, &speed_khz))!=ERROR_OK)
2656 return retval;
2657 }
2658
2659 if (speed_khz==0)
2660 {
2661 command_print(cmd_ctx, "RCLK - adaptive");
2662 } else
2663 {
2664 command_print(cmd_ctx, "%d kHz", speed_khz);
2665 }
2666 return retval;
2667
2668 }
2669
2670 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2671 {
2672 tap_state_t state;
2673
2674 if (argc < 1)
2675 {
2676 return ERROR_COMMAND_SYNTAX_ERROR;
2677 }
2678 else
2679 {
2680 state = tap_state_by_name( args[0] );
2681 if( state < 0 ){
2682 command_print( cmd_ctx, "Invalid state name: %s\n", args[0] );
2683 return ERROR_COMMAND_SYNTAX_ERROR;
2684 }
2685 jtag_add_end_state(state);
2686 jtag_execute_queue();
2687 }
2688 command_print(cmd_ctx, "current endstate: %s", tap_state_name(cmd_queue_end_state));
2689
2690 return ERROR_OK;
2691 }
2692
2693 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2694 {
2695 int trst = -1;
2696 int srst = -1;
2697
2698 if (argc < 2)
2699 {
2700 return ERROR_COMMAND_SYNTAX_ERROR;
2701 }
2702
2703 if (args[0][0] == '1')
2704 trst = 1;
2705 else if (args[0][0] == '0')
2706 trst = 0;
2707 else
2708 {
2709 return ERROR_COMMAND_SYNTAX_ERROR;
2710 }
2711
2712 if (args[1][0] == '1')
2713 srst = 1;
2714 else if (args[1][0] == '0')
2715 srst = 0;
2716 else
2717 {
2718 return ERROR_COMMAND_SYNTAX_ERROR;
2719 }
2720
2721 if (jtag_interface_init(cmd_ctx) != ERROR_OK)
2722 return ERROR_JTAG_INIT_FAILED;
2723
2724 jtag_add_reset(trst, srst);
2725 jtag_execute_queue();
2726
2727 return ERROR_OK;
2728 }
2729
2730 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2731 {
2732 if (argc < 1)
2733 {
2734 return ERROR_COMMAND_SYNTAX_ERROR;
2735 }
2736
2737 jtag_add_runtest(strtol(args[0], NULL, 0), TAP_INVALID);
2738 jtag_execute_queue();
2739
2740 return ERROR_OK;
2741
2742 }
2743
2744 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2745 {
2746 int i;
2747 scan_field_t *fields;
2748 jtag_tap_t *tap;
2749 tap_state_t endstate;
2750
2751 if ((argc < 2) || (argc % 2))
2752 {
2753 return ERROR_COMMAND_SYNTAX_ERROR;
2754 }
2755
2756 /* optional "-endstate" */
2757 /* "statename" */
2758 /* at the end of the arguments. */
2759 /* assume none. */
2760 endstate = TAP_INVALID;
2761 if( argc >= 4 ){
2762 /* have at least one pair of numbers. */
2763 /* is last pair the magic text? */
2764 if( 0 == strcmp( "-endstate", args[ argc - 2 ] ) ){
2765 const char *cpA;
2766 const char *cpS;
2767 cpA = args[ argc-1 ];
2768 for( endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++ ){
2769 cpS = tap_state_name( endstate );
2770 if( 0 == strcmp( cpA, cpS ) ){
2771 break;
2772 }
2773 }
2774 if( endstate >= TAP_NUM_STATES ){
2775 return ERROR_COMMAND_SYNTAX_ERROR;
2776 } else {
2777 /* found - remove the last 2 args */
2778 argc -= 2;
2779 }
2780 }
2781 }
2782
2783 fields = malloc(sizeof(scan_field_t) * argc / 2);
2784
2785 for (i = 0; i < argc / 2; i++)
2786 {
2787 tap = jtag_TapByString( args[i*2] );
2788 if (tap==NULL)
2789 {
2790 command_print( cmd_ctx, "Tap: %s unknown", args[i*2] );
2791 return ERROR_FAIL;
2792 }
2793 int field_size = tap->ir_length;
2794 fields[i].tap = tap;
2795 fields[i].out_value = malloc(CEIL(field_size, 8));
2796 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
2797 fields[i].in_value = NULL;
2798 }
2799
2800 jtag_add_ir_scan(argc / 2, fields, TAP_INVALID);
2801 /* did we have an endstate? */
2802 if (endstate != TAP_INVALID)
2803 jtag_add_end_state(endstate);
2804
2805 jtag_execute_queue();
2806
2807 for (i = 0; i < argc / 2; i++)
2808 free(fields[i].out_value);
2809
2810 free (fields);
2811
2812 return ERROR_OK;
2813 }
2814
2815 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2816 {
2817 int retval;
2818 scan_field_t *fields;
2819 int num_fields;
2820 int field_count = 0;
2821 int i, e;
2822 jtag_tap_t *tap;
2823 tap_state_t endstate;
2824
2825 /* args[1] = device
2826 * args[2] = num_bits
2827 * args[3] = hex string
2828 * ... repeat num bits and hex string ...
2829 *
2830 * .. optionally:
2831 * args[N-2] = "-endstate"
2832 * args[N-1] = statename
2833 */
2834 if ((argc < 4) || ((argc % 2)!=0))
2835 {
2836 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
2837 return JIM_ERR;
2838 }
2839
2840 /* assume no endstate */
2841 endstate = TAP_INVALID;
2842 /* validate arguments as numbers */
2843 e = JIM_OK;
2844 for (i = 2; i < argc; i+=2)
2845 {
2846 long bits;
2847 const char *cp;
2848
2849 e = Jim_GetLong(interp, args[i], &bits);
2850 /* If valid - try next arg */
2851 if( e == JIM_OK ){
2852 continue;
2853 }
2854
2855 /* Not valid.. are we at the end? */
2856 if ( ((i+2) != argc) ){
2857 /* nope, then error */
2858 return e;
2859 }
2860
2861 /* it could be: "-endstate FOO" */
2862
2863 /* get arg as a string. */
2864 cp = Jim_GetString( args[i], NULL );
2865 /* is it the magic? */
2866 if( 0 == strcmp( "-endstate", cp ) ){
2867 /* is the statename valid? */
2868 cp = Jim_GetString( args[i+1], NULL );
2869
2870 /* see if it is a valid state name */
2871 endstate = tap_state_by_name(cp);
2872 if( endstate < 0 ){
2873 /* update the error message */
2874 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp );
2875 } else {
2876 /* valid - so clear the error */
2877 e = JIM_OK;
2878 /* and remove the last 2 args */
2879 argc -= 2;
2880 }
2881 }
2882
2883 /* Still an error? */
2884 if( e != JIM_OK ){
2885 return e; /* too bad */
2886 }
2887 } /* validate args */
2888
2889 tap = jtag_TapByJimObj( interp, args[1] );
2890 if( tap == NULL ){
2891 return JIM_ERR;
2892 }
2893
2894 num_fields=(argc-2)/2;
2895 fields = malloc(sizeof(scan_field_t) * num_fields);
2896 for (i = 2; i < argc; i+=2)
2897 {
2898 long bits;
2899 int len;
2900 const char *str;
2901
2902 Jim_GetLong(interp, args[i], &bits);
2903 str = Jim_GetString(args[i+1], &len);
2904
2905 fields[field_count].tap = tap;
2906 fields[field_count].num_bits = bits;
2907 fields[field_count].out_value = malloc(CEIL(bits, 8));
2908 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
2909 fields[field_count].in_value = fields[field_count].out_value;
2910 field_count++;
2911 }
2912
2913 jtag_add_dr_scan(num_fields, fields, TAP_INVALID);
2914 /* did we get an end state? */
2915 if (endstate != TAP_INVALID)
2916 jtag_add_end_state(endstate);
2917
2918 retval = jtag_execute_queue();
2919 if (retval != ERROR_OK)
2920 {
2921 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
2922 return JIM_ERR;
2923 }
2924
2925 field_count=0;
2926 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
2927 for (i = 2; i < argc; i+=2)
2928 {
2929 long bits;
2930 char *str;
2931
2932 Jim_GetLong(interp, args[i], &bits);
2933 str = buf_to_str(fields[field_count].in_value, bits, 16);
2934 free(fields[field_count].out_value);
2935
2936 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
2937 free(str);
2938 field_count++;
2939 }
2940
2941 Jim_SetResult(interp, list);
2942
2943 free(fields);
2944
2945 return JIM_OK;
2946 }
2947
2948 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2949 {
2950 if (argc == 1)
2951 {
2952 if (strcmp(args[0], "enable") == 0)
2953 {
2954 jtag_verify_capture_ir = 1;
2955 }
2956 else if (strcmp(args[0], "disable") == 0)
2957 {
2958 jtag_verify_capture_ir = 0;
2959 } else
2960 {
2961 return ERROR_COMMAND_SYNTAX_ERROR;
2962 }
2963 } else if (argc != 0)
2964 {
2965 return ERROR_COMMAND_SYNTAX_ERROR;
2966 }
2967
2968 command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
2969
2970 return ERROR_OK;
2971 }
2972
2973 int jtag_power_dropout(int *dropout)
2974 {
2975 return jtag->power_dropout(dropout);
2976 }
2977
2978 int jtag_srst_asserted(int *srst_asserted)
2979 {
2980 return jtag->srst_asserted(srst_asserted);
2981 }
2982
2983 void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e)
2984 {
2985 jtag_tap_event_action_t * jteap;
2986 int done;
2987
2988 jteap = tap->event_action;
2989
2990 done = 0;
2991 while (jteap) {
2992 if (jteap->event == e) {
2993 done = 1;
2994 LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
2995 tap->dotted_name,
2996 e,
2997 Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e)->name,
2998 Jim_GetString(jteap->body, NULL) );
2999 if (Jim_EvalObj(interp, jteap->body) != JIM_OK) {
3000 Jim_PrintErrorMessage(interp);
3001 }
3002 }
3003
3004 jteap = jteap->next;
3005 }
3006
3007 if (!done) {
3008 LOG_DEBUG( "event %d %s - no action",
3009 e,
3010 Jim_Nvp_value2name_simple( nvp_jtag_tap_event, e)->name);
3011 }
3012 }
3013
3014 /*-----<Cable Helper API>---------------------------------------*/
3015
3016 /* these Cable Helper API functions are all documented in the jtag.h header file,
3017 using a Doxygen format. And since Doxygen's configuration file "Doxyfile",
3018 is setup to prefer its docs in the header file, no documentation is here, for
3019 if it were, it would have to be doubly maintained.
3020 */
3021
3022 /**
3023 * @see tap_set_state() and tap_get_state() accessors.
3024 * Actual name is not important since accessors hide it.
3025 */
3026 static tap_state_t state_follower = TAP_RESET;
3027
3028 void tap_set_state_impl( tap_state_t new_state )
3029 {
3030 /* this is the state we think the TAPs are in now, was cur_state */
3031 state_follower = new_state;
3032 }
3033
3034 tap_state_t tap_get_state()
3035 {
3036 return state_follower;
3037 }
3038
3039 /**
3040 * @see tap_set_end_state() and tap_get_end_state() accessors.
3041 * Actual name is not important because accessors hide it.
3042 */
3043 static tap_state_t end_state_follower = TAP_RESET;
3044
3045 void tap_set_end_state( tap_state_t new_end_state )
3046 {
3047 /* this is the state we think the TAPs will be in at completion of the
3048 current TAP operation, was end_state
3049 */
3050 end_state_follower = new_end_state;
3051 }
3052
3053 tap_state_t tap_get_end_state()
3054 {
3055 return end_state_follower;
3056 }
3057
3058
3059 int tap_move_ndx( tap_state_t astate )
3060 {
3061 /* given a stable state, return the index into the tms_seqs[] array within tap_get_tms_path() */
3062
3063 int ndx;
3064
3065 switch( astate )
3066 {
3067 case TAP_RESET: ndx = 0; break;
3068 case TAP_DRSHIFT: ndx = 2; break;
3069 case TAP_DRPAUSE: ndx = 3; break;
3070 case TAP_IDLE: ndx = 1; break;
3071 case TAP_IRSHIFT: ndx = 4; break;
3072 case TAP_IRPAUSE: ndx = 5; break;
3073 default:
3074 LOG_ERROR( "fatal: unstable state \"%s\" used in tap_move_ndx()", tap_state_name(astate) );
3075 exit(1);
3076 }
3077
3078 return ndx;
3079 }
3080
3081
3082 /* tap_move[i][j]: tap movement command to go from state i to state j
3083 * 0: Test-Logic-Reset
3084 * 1: Run-Test/Idle
3085 * 2: Shift-DR
3086 * 3: Pause-DR
3087 * 4: Shift-IR
3088 * 5: Pause-IR
3089 *
3090 * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code
3091 */
3092 static struct
3093 {
3094 u8 bits;
3095 u8 bit_count;
3096
3097 } tms_seqs[6][6] = /* [from_state_ndx][to_state_ndx] */
3098 {
3099 /* value clocked to TMS to move from one of six stable states to another.
3100 * N.B. OOCD clocks TMS from LSB first, so read these right-to-left.
3101 * N.B. These values are tightly bound to the table in tap_get_tms_path_len().
3102 * N.B. Reset only needs to be 0b11111, but in JLink an even byte of 1's is more stable.
3103 * These extra ones cause no TAP state problem, because we go into reset and stay in reset.
3104 */
3105
3106 /*
3107 * These macros allow us to specify TMS state transitions by bits rather than hex bytes.
3108 * Read the bits from LSBit first to MSBit last (right-to-left).
3109 */
3110 #define HEX__(n) 0x##n##LU
3111
3112 #define B8__(x) \
3113 (((x) & 0x0000000FLU)?(1<<0):0) \
3114 +(((x) & 0x000000F0LU)?(1<<1):0) \
3115 +(((x) & 0x00000F00LU)?(1<<2):0) \
3116 +(((x) & 0x0000F000LU)?(1<<3):0) \
3117 +(((x) & 0x000F0000LU)?(1<<4):0) \
3118 +(((x) & 0x00F00000LU)?(1<<5):0) \
3119 +(((x) & 0x0F000000LU)?(1<<6):0) \
3120 +(((x) & 0xF0000000LU)?(1<<7):0)
3121
3122 #define B8(bits,count) { ((u8)B8__(HEX__(bits))), (count) }
3123
3124 #if 0 && ((BUILD_FT2232_FTD2XX==1) || (BUILD_FT2232_LIBFTDI==1) || (BUILD_JLINK==1))
3125 /* this is the table submitted by Jeff Williams on 3/30/2009 with this comment:
3126
3127 OK, I added Peter's version of the state table, and it works OK for
3128 me on MC1322x. I've recreated the jlink portion of patch with this
3129 new state table. His changes to my state table are pretty minor in
3130 terms of total transitions, but Peter feels that his version fixes
3131 some long-standing problems.
3132 Jeff
3133
3134 I added the bit count into the table, reduced RESET column to 7 bits from 8.
3135 Dick
3136
3137 state specific comments:
3138 ------------------------
3139 *->RESET tried the 5 bit reset and it gave me problems, 7 bits seems to
3140 work better on ARM9 with ft2232 driver. (Dick)
3141
3142 RESET->DRSHIFT add 1 extra clock cycles in the RESET state before advancing.
3143 needed on ARM9 with ft2232 driver. (Dick)
3144
3145 RESET->IRSHIFT add 1 extra clock cycles in the RESET state before advancing.
3146 needed on ARM9 with ft2232 driver. (Dick)
3147 */
3148
3149 /* to state: */
3150 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
3151 { B8(1111111,7), B8(0,1), B8(00101,5), B8(01010,5), B8(001101,6), B8(010110,6) }, /* RESET */
3152 { B8(1111111,7), B8(0,1), B8(001,3), B8(0101,4), B8(0011,4), B8(01011,5) }, /* IDLE */
3153 { B8(1111111,7), B8(011,3), B8(00111,5), B8(01,2), B8(001111,6), B8(0101111,7) }, /* DRSHIFT */
3154 { B8(1111111,7), B8(011,3), B8(01,2), B8(0,1), B8(001111,6), B8(0101111,7) }, /* DRPAUSE */
3155 { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(001111,6), B8(01,2) }, /* IRSHIFT */
3156 { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(01,2), B8(0,1) } /* IRPAUSE */
3157
3158 #else /* this is the old table, converted from hex and with the bit_count set to 7 for each combo, like before */
3159
3160 /* to state: */
3161 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
3162 { B8(1111111,7), B8(0000000,7), B8(0010111,7), B8(0001010,7), B8(0011011,7), B8(0010110,7) }, /* RESET */
3163 { B8(1111111,7), B8(0000000,7), B8(0100101,7), B8(0000101,7), B8(0101011,7), B8(0001011,7) }, /* IDLE */
3164 { B8(1111111,7), B8(0110001,7), B8(0000000,7), B8(0000001,7), B8(0001111,7), B8(0101111,7) }, /* DRSHIFT */
3165 { B8(1111111,7), B8(0110000,7), B8(0100000,7), B8(0010111,7), B8(0011110,7), B8(0101111,7) }, /* DRPAUSE */
3166 { B8(1111111,7), B8(0110001,7), B8(0000111,7), B8(0010111,7), B8(0000000,7), B8(0000001,7) }, /* IRSHIFT */
3167 { B8(1111111,7), B8(0110000,7), B8(0011100,7), B8(0010111,7), B8(0100000,7), B8(0101111,7) } /* IRPAUSE */
3168
3169 #endif
3170
3171 #if 0 /* keeping old hex stuff for awhile, for reference */
3172 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */
3173 { 0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16 }, /* RESET */
3174 { 0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b }, /* IDLE */
3175 { 0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f }, /* DRSHIFT */
3176 { 0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f }, /* DRPAUSE */
3177 { 0x7f, 0x31, 0x07, 0x17, 0x00, 0x01 }, /* IRSHIFT */
3178 { 0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f } /* IRPAUSE */
3179 #endif
3180 };
3181
3182
3183 int tap_get_tms_path( tap_state_t from, tap_state_t to )
3184 {
3185 return tms_seqs[tap_move_ndx(from)][tap_move_ndx(to)].bits;
3186 }
3187
3188
3189 int tap_get_tms_path_len( tap_state_t from, tap_state_t to )
3190 {
3191 return tms_seqs[tap_move_ndx(from)][tap_move_ndx(to)].bit_count;
3192 }
3193
3194
3195 bool tap_is_state_stable(tap_state_t astate)
3196 {
3197 bool is_stable;
3198
3199 /* A switch() is used because it is symbol dependent
3200 (not value dependent like an array), and can also check bounds.
3201 */
3202 switch( astate )
3203 {
3204 case TAP_RESET:
3205 case TAP_IDLE:
3206 case TAP_DRSHIFT:
3207 case TAP_DRPAUSE:
3208 case TAP_IRSHIFT:
3209 case TAP_IRPAUSE:
3210 is_stable = true;
3211 break;
3212 default:
3213 is_stable = false;
3214 }
3215
3216 return is_stable;
3217 }
3218
3219 tap_state_t tap_state_transition(tap_state_t cur_state, bool tms)
3220 {
3221 tap_state_t new_state;
3222
3223 /* A switch is used because it is symbol dependent and not value dependent
3224 like an array. Also it can check for out of range conditions.
3225 */
3226
3227 if (tms)
3228 {
3229 switch (cur_state)
3230 {
3231 case TAP_RESET:
3232 new_state = cur_state;
3233 break;
3234 case TAP_IDLE:
3235 case TAP_DRUPDATE:
3236 case TAP_IRUPDATE:
3237 new_state = TAP_DRSELECT;
3238 break;
3239 case TAP_DRSELECT:
3240 new_state = TAP_IRSELECT;
3241 break;
3242 case TAP_DRCAPTURE:
3243 case TAP_DRSHIFT:
3244 new_state = TAP_DREXIT1;
3245 break;
3246 case TAP_DREXIT1:
3247 case TAP_DREXIT2:
3248 new_state = TAP_DRUPDATE;
3249 break;
3250 case TAP_DRPAUSE:
3251 new_state = TAP_DREXIT2;
3252 break;
3253 case TAP_IRSELECT:
3254 new_state = TAP_RESET;
3255 break;
3256 case TAP_IRCAPTURE:
3257 case TAP_IRSHIFT:
3258 new_state = TAP_IREXIT1;
3259 break;
3260 case TAP_IREXIT1:
3261 case TAP_IREXIT2:
3262 new_state = TAP_IRUPDATE;
3263 break;
3264 case TAP_IRPAUSE:
3265 new_state = TAP_IREXIT2;
3266 break;
3267 default:
3268 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3269 exit(1);
3270 break;
3271 }
3272 }
3273 else
3274 {
3275 switch (cur_state)
3276 {
3277 case TAP_RESET:
3278 case TAP_IDLE:
3279 case TAP_DRUPDATE:
3280 case TAP_IRUPDATE:
3281 new_state = TAP_IDLE;
3282 break;
3283 case TAP_DRSELECT:
3284 new_state = TAP_DRCAPTURE;
3285 break;
3286 case TAP_DRCAPTURE:
3287 case TAP_DRSHIFT:
3288 case TAP_DREXIT2:
3289 new_state = TAP_DRSHIFT;
3290 break;
3291 case TAP_DREXIT1:
3292 case TAP_DRPAUSE:
3293 new_state = TAP_DRPAUSE;
3294 break;
3295 case TAP_IRSELECT:
3296 new_state = TAP_IRCAPTURE;
3297 break;
3298 case TAP_IRCAPTURE:
3299 case TAP_IRSHIFT:
3300 case TAP_IREXIT2:
3301 new_state = TAP_IRSHIFT;
3302 break;
3303 case TAP_IREXIT1:
3304 case TAP_IRPAUSE:
3305 new_state = TAP_IRPAUSE;
3306 break;
3307 default:
3308 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3309 exit(1);
3310 break;
3311 }
3312 }
3313
3314 return new_state;
3315 }
3316
3317 const char* tap_state_name(tap_state_t state)
3318 {
3319 const char* ret;
3320
3321 switch( state )
3322 {
3323 case TAP_RESET: ret = "RESET"; break;
3324 case TAP_IDLE: ret = "RUN/IDLE"; break;
3325 case TAP_DRSELECT: ret = "DRSELECT"; break;
3326 case TAP_DRCAPTURE: ret = "DRCAPTURE"; break;
3327 case TAP_DRSHIFT: ret = "DRSHIFT"; break;
3328 case TAP_DREXIT1: ret = "DREXIT1"; break;
3329 case TAP_DRPAUSE: ret = "DRPAUSE"; break;
3330 case TAP_DREXIT2: ret = "DREXIT2"; break;
3331 case TAP_DRUPDATE: ret = "DRUPDATE"; break;
3332 case TAP_IRSELECT: ret = "IRSELECT"; break;
3333 case TAP_IRCAPTURE: ret = "IRCAPTURE"; break;
3334 case TAP_IRSHIFT: ret = "IRSHIFT"; break;
3335 case TAP_IREXIT1: ret = "IREXIT1"; break;
3336 case TAP_IRPAUSE: ret = "IRPAUSE"; break;
3337 case TAP_IREXIT2: ret = "IREXIT2"; break;
3338 case TAP_IRUPDATE: ret = "IRUPDATE"; break;
3339 default: ret = "???";
3340 }
3341
3342 return ret;
3343 }
3344
3345 static tap_state_t tap_state_by_name( const char *name )
3346 {
3347 tap_state_t x;
3348
3349 for( x = 0 ; x < TAP_NUM_STATES ; x++ ){
3350 /* be nice to the human */
3351 if( 0 == strcasecmp( name, tap_state_name(x) ) ){
3352 return x;
3353 }
3354 }
3355 /* not found */
3356 return TAP_INVALID;
3357 }
3358
3359 #ifdef _DEBUG_JTAG_IO_
3360
3361 #define JTAG_DEBUG_STATE_APPEND(buf, len, bit) \
3362 do { buf[len] = bit ? '1' : '0'; } while(0)
3363 #define JTAG_DEBUG_STATE_PRINT(a, b, astr, bstr) \
3364 DEBUG_JTAG_IO("TAP/SM: %9s -> %5s\tTMS: %s\tTDI: %s", \
3365 tap_state_name(a), tap_state_name(b), astr, bstr)
3366
3367 tap_state_t jtag_debug_state_machine(const void *tms_buf, const void *tdi_buf,
3368 unsigned tap_bits, tap_state_t next_state)
3369 {
3370 const u8 *tms_buffer;
3371 const u8 *tdi_buffer;
3372 unsigned tap_bytes;
3373 unsigned cur_byte;
3374 unsigned cur_bit;
3375
3376 unsigned tap_out_bits;
3377 char tms_str[33];
3378 char tdi_str[33];
3379
3380 tap_state_t last_state;
3381
3382 // set startstate (and possibly last, if tap_bits == 0)
3383 last_state = next_state;
3384 DEBUG_JTAG_IO("TAP/SM: START state: %s", tap_state_name(next_state));
3385
3386 tms_buffer = (const u8 *)tms_buf;
3387 tdi_buffer = (const u8 *)tdi_buf;
3388
3389 tap_bytes = TAP_SCAN_BYTES(tap_bits);
3390 DEBUG_JTAG_IO("TAP/SM: TMS bits: %u (bytes: %u)", tap_bits, tap_bytes);
3391
3392 tap_out_bits = 0;
3393 for(cur_byte = 0; cur_byte < tap_bytes; cur_byte++)
3394 {
3395 for(cur_bit = 0; cur_bit < 8; cur_bit++)
3396 {
3397 // make sure we do not run off the end of the buffers
3398 unsigned tap_bit = cur_byte * 8 + cur_bit;
3399 if (tap_bit == tap_bits)
3400 break;
3401
3402 // check and save TMS bit
3403 tap_bit = !!(tms_buffer[cur_byte] & (1 << cur_bit));
3404 JTAG_DEBUG_STATE_APPEND(tms_str, tap_out_bits, tap_bit);
3405
3406 // use TMS bit to find the next TAP state
3407 next_state = tap_state_transition(last_state, tap_bit);
3408
3409 // check and store TDI bit
3410 tap_bit = !!(tdi_buffer[cur_byte] & (1 << cur_bit));
3411 JTAG_DEBUG_STATE_APPEND(tdi_str, tap_out_bits, tap_bit);
3412
3413 // increment TAP bits
3414 tap_out_bits++;
3415
3416 // Only show TDO bits on state transitions, or
3417 // after some number of bits in the same state.
3418 if ((next_state == last_state) && (tap_out_bits < 32))
3419 continue;
3420
3421 // terminate strings and display state transition
3422 tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
3423 JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
3424
3425 // reset state
3426 last_state = next_state;
3427 tap_out_bits = 0;
3428 }
3429 }
3430
3431 if (tap_out_bits)
3432 {
3433 // terminate strings and display state transition
3434 tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
3435 JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
3436 }
3437
3438 DEBUG_JTAG_IO("TAP/SM: FINAL state: %s", tap_state_name(next_state));
3439
3440 return next_state;
3441 }
3442 #endif // _DEBUG_JTAG_IO_
3443
3444 /*-----</Cable Helper API>--------------------------------------*/
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)