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