Code Review / openocd.git / blob
? search:


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